3000f9c0 <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();
3000f9c0: e59f3030 ldr r3, [pc, #48] ; 3000f9f8 <TOD_MICROSECONDS_TO_TICKS+0x38><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
3000f9c4: 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();
3000f9c8: e593500c ldr r5, [r3, #12] <== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
3000f9cc: 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;
3000f9d0: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f9d4: eb004d80 bl 30022fdc <__aeabi_uidiv> <== NOT EXECUTED
if ( (microseconds % microseconds_per_tick) != 0 )
3000f9d8: 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;
3000f9dc: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( (microseconds % microseconds_per_tick) != 0 )
3000f9e0: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f9e4: eb004dc2 bl 300230f4 <__umodsi3> <== NOT EXECUTED 3000f9e8: e3500000 cmp r0, #0 <== NOT EXECUTED
ticks += 1;
3000f9ec: 12844001 addne r4, r4, #1 <== NOT EXECUTED
return ticks;
}
3000f9f0: e1a00004 mov r0, r4 <== NOT EXECUTED
3000f9f4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000b84c <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();
3000b84c: e59f3040 ldr r3, [pc, #64] ; 3000b894 <TOD_MILLISECONDS_TO_TICKS+0x48><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000b850: 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();
3000b854: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000b858: 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();
3000b85c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000b860: eb00406f bl 3001ba24 <__aeabi_uidiv> <== NOT EXECUTED 3000b864: e1a05000 mov r5, r0 <== NOT EXECUTED
ticks = milliseconds / milliseconds_per_tick;
3000b868: e1a01005 mov r1, r5 <== NOT EXECUTED 3000b86c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b870: eb00406b bl 3001ba24 <__aeabi_uidiv> <== NOT EXECUTED
if ( (milliseconds % milliseconds_per_tick) != 0 )
3000b874: 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;
3000b878: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( (milliseconds % milliseconds_per_tick) != 0 )
3000b87c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b880: eb0040ad bl 3001bb3c <__umodsi3> <== NOT EXECUTED 3000b884: e3500000 cmp r0, #0 <== NOT EXECUTED
ticks += 1;
3000b888: 12844001 addne r4, r4, #1 <== NOT EXECUTED
return ticks;
}
3000b88c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000b890: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000d0e8 <_CORE_RWLock_Obtain_for_reading>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000d0e8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000d0ec: e1a08003 mov r8, r3
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000d0f0: e59f30a4 ldr r3, [pc, #164] ; 3000d19c <_CORE_RWLock_Obtain_for_reading+0xb4>
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000d0f4: e1a04000 mov r4, r0
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000d0f8: e5936008 ldr r6, [r3, #8]
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000d0fc: e1a05001 mov r5, r1 3000d100: e202a0ff and sl, r2, #255 ; 0xff
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d104: e10f7000 mrs r7, CPSR 3000d108: e3873080 orr r3, r7, #128 ; 0x80 3000d10c: e129f003 msr CPSR_fc, r3
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
3000d110: e590c044 ldr ip, [r0, #68] ; 0x44 3000d114: e35c0000 cmp ip, #0
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000d118: 03a03001 moveq r3, #1 3000d11c: 05803044 streq r3, [r0, #68] ; 0x44
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
3000d120: 0a000004 beq 3000d138 <_CORE_RWLock_Obtain_for_reading+0x50>
3000d124: e35c0001 cmp ip, #1
3000d128: 1a000008 bne 3000d150 <_CORE_RWLock_Obtain_for_reading+0x68>
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
return;
case CORE_RWLOCK_LOCKED_FOR_READING: {
Thread_Control *waiter;
waiter = _Thread_queue_First( &the_rwlock->Wait_queue );
3000d12c: eb0008a1 bl 3000f3b8 <_Thread_queue_First> <== NOT EXECUTED
if ( !waiter ) {
3000d130: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d134: 1a000005 bne 3000d150 <_CORE_RWLock_Obtain_for_reading+0x68><== NOT EXECUTED
the_rwlock->number_of_readers += 1;
3000d138: e5943048 ldr r3, [r4, #72] ; 0x48 3000d13c: e2833001 add r3, r3, #1 3000d140: e5843048 str r3, [r4, #72] ; 0x48
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d144: e129f007 msr CPSR_fc, r7
_ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d148: e3a03000 mov r3, #0 3000d14c: ea000003 b 3000d160 <_CORE_RWLock_Obtain_for_reading+0x78>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
3000d150: e35a0000 cmp sl, #0
3000d154: 1a000003 bne 3000d168 <_CORE_RWLock_Obtain_for_reading+0x80>
3000d158: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000d15c: e3a03002 mov r3, #2 3000d160: e5863034 str r3, [r6, #52] ; 0x34
return;
3000d164: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3000d168: e3a03001 mov r3, #1
3000d16c: e5843030 str r3, [r4, #48] ; 0x30
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
3000d170: e3a03000 mov r3, #0
/*
* We need to wait to enter this critical section
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
3000d174: e5864044 str r4, [r6, #68] ; 0x44
executing->Wait.id = id;
3000d178: e5865020 str r5, [r6, #32]
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
3000d17c: e5863030 str r3, [r6, #48] ; 0x30
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d180: e5863034 str r3, [r6, #52] ; 0x34 3000d184: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
3000d188: e59f2010 ldr r2, [pc, #16] ; 3000d1a0 <_CORE_RWLock_Obtain_for_reading+0xb8> 3000d18c: e1a00004 mov r0, r4 3000d190: e1a01008 mov r1, r8
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
3000d194: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
3000d198: ea0007b3 b 3000f06c <_Thread_queue_Enqueue_with_handler>
3000d230 <_CORE_RWLock_Release>:
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000d230: e59f30d8 ldr r3, [pc, #216] ; 3000d310 <_CORE_RWLock_Release+0xe0>
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
3000d234: e92d4010 push {r4, lr}
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000d238: e5932008 ldr r2, [r3, #8]
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
3000d23c: e1a04000 mov r4, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d240: e10f3000 mrs r3, CPSR 3000d244: e3831080 orr r1, r3, #128 ; 0x80 3000d248: e129f001 msr CPSR_fc, r1
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
3000d24c: e5901044 ldr r1, [r0, #68] ; 0x44 3000d250: e3510000 cmp r1, #0
3000d254: 1a000003 bne 3000d268 <_CORE_RWLock_Release+0x38>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d258: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000d25c: e3a03002 mov r3, #2 <== NOT EXECUTED 3000d260: e5823034 str r3, [r2, #52] ; 0x34 <== NOT EXECUTED
return CORE_RWLOCK_SUCCESSFUL;
3000d264: ea000027 b 3000d308 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
3000d268: e3510001 cmp r1, #1
3000d26c: 1a000006 bne 3000d28c <_CORE_RWLock_Release+0x5c> the_rwlock->number_of_readers -= 1;
3000d270: e5901048 ldr r1, [r0, #72] ; 0x48 3000d274: e2411001 sub r1, r1, #1
if ( the_rwlock->number_of_readers != 0 ) {
3000d278: e3510000 cmp r1, #0
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
the_rwlock->number_of_readers -= 1;
3000d27c: e5801048 str r1, [r0, #72] ; 0x48
if ( the_rwlock->number_of_readers != 0 ) {
3000d280: 0a000001 beq 3000d28c <_CORE_RWLock_Release+0x5c>
3000d284: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* must be unlocked again */
_ISR_Enable( level );
return CORE_RWLOCK_SUCCESSFUL;
3000d288: ea00001e b 3000d308 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d28c: e3a01000 mov r1, #0 3000d290: e5821034 str r1, [r2, #52] ; 0x34
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
3000d294: e5841044 str r1, [r4, #68] ; 0x44 3000d298: e129f003 msr CPSR_fc, r3
_ISR_Enable( level );
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
3000d29c: e1a00004 mov r0, r4 3000d2a0: eb000719 bl 3000ef0c <_Thread_queue_Dequeue>
if ( next ) {
3000d2a4: e3500000 cmp r0, #0
3000d2a8: 0a000016 beq 3000d308 <_CORE_RWLock_Release+0xd8>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
3000d2ac: e5903030 ldr r3, [r0, #48] ; 0x30 3000d2b0: e3530001 cmp r3, #1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
3000d2b4: 03a03002 moveq r3, #2 3000d2b8: 05843044 streq r3, [r4, #68] ; 0x44
_ISR_Enable( level );
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
if ( next ) {
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
3000d2bc: 0a000011 beq 3000d308 <_CORE_RWLock_Release+0xd8>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
3000d2c0: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000d2c4: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000d2c8: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000d2cc: e3a03001 mov r3, #1 <== NOT EXECUTED 3000d2d0: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
3000d2d4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d2d8: eb000836 bl 3000f3b8 <_Thread_queue_First> <== NOT EXECUTED
if ( !next ||
3000d2dc: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000d2e0: 0a000008 beq 3000d308 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED 3000d2e4: e5913030 ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED 3000d2e8: e3530001 cmp r3, #1 <== NOT EXECUTED 3000d2ec: 0a000005 beq 3000d308 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
3000d2f0: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
3000d2f4: e1a00004 mov r0, r4 <== NOT EXECUTED
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
3000d2f8: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000d2fc: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
3000d300: eb0007e5 bl 3000f29c <_Thread_queue_Extract> <== NOT EXECUTED
}
3000d304: eafffff2 b 3000d2d4 <_CORE_RWLock_Release+0xa4> <== NOT EXECUTED
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
3000d308: e3a00000 mov r0, #0
3000d30c: e8bd8010 pop {r4, pc}
3000d314 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
3000d314: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d318: e1a0100d mov r1, sp <== NOT EXECUTED 3000d31c: eb00062e bl 3000ebdc <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000d320: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000d324: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d328: 1a000004 bne 3000d340 <_CORE_RWLock_Timeout+0x2c> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
3000d32c: eb00085c bl 3000f4a4 <_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;
3000d330: e59f300c ldr r3, [pc, #12] ; 3000d344 <_CORE_RWLock_Timeout+0x30><== NOT EXECUTED 3000d334: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000d338: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000d33c: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000d340: e8bd8008 pop {r3, pc} <== NOT EXECUTED
30019de0 <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
30019de0: 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
)
{
30019de4: 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 ) {
30019de8: 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
)
{
30019dec: e1a06000 mov r6, r0 30019df0: e1a0a001 mov sl, r1 30019df4: e1a07002 mov r7, r2 30019df8: 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 ) {
30019dfc: 8a000013 bhi 30019e50 <_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 ) {
30019e00: e5905048 ldr r5, [r0, #72] ; 0x48 30019e04: e3550000 cmp r5, #0
*count = 0;
30019e08: 13a00000 movne r0, #0 30019e0c: 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 ) {
30019e10: 0a000007 beq 30019e34 <_CORE_message_queue_Broadcast+0x54>
30019e14: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30019e18: e594002c ldr r0, [r4, #44] ; 0x2c 30019e1c: e1a0100a mov r1, sl 30019e20: e1a02007 mov r2, r7 30019e24: eb00203c bl 30021f1c <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30019e28: 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;
30019e2c: e2855001 add r5, r5, #1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30019e30: 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 =
30019e34: e1a00006 mov r0, r6 30019e38: eb000b70 bl 3001cc00 <_Thread_queue_Dequeue> 30019e3c: e2504000 subs r4, r0, #0
30019e40: 1afffff4 bne 30019e18 <_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;
30019e44: e5885000 str r5, [r8]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30019e48: e1a00004 mov r0, r4
30019e4c: 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;
30019e50: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
30019e54: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30012b64 <_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
)
{
30012b64: 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)) {
30012b68: 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
)
{
30012b6c: 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;
30012b70: 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
)
{
30012b74: e1a07001 mov r7, r1 30012b78: e1a05002 mov r5, r2
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
30012b7c: e5842044 str r2, [r4, #68] ; 0x44
the_message_queue->number_of_pending_messages = 0;
30012b80: e5840048 str r0, [r4, #72] ; 0x48
the_message_queue->maximum_message_size = maximum_message_size;
30012b84: e584304c str r3, [r4, #76] ; 0x4c
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
30012b88: e5840060 str r0, [r4, #96] ; 0x60
the_message_queue->notify_argument = the_argument;
30012b8c: e5840064 str r0, [r4, #100] ; 0x64
/*
* 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)) {
30012b90: 01a06003 moveq r6, r3
30012b94: 0a000003 beq 30012ba8 <_CORE_message_queue_Initialize+0x44>
allocated_message_size += sizeof(uintptr_t);
30012b98: e2836004 add r6, r3, #4 <== NOT EXECUTED
allocated_message_size &= ~(sizeof(uintptr_t) - 1);
30012b9c: 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)
30012ba0: e1560003 cmp r6, r3 <== NOT EXECUTED
30012ba4: 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(
30012ba8: e2866014 add r6, r6, #20
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
30012bac: e0810695 umull r0, r1, r5, r6
if ( x > SIZE_MAX )
30012bb0: e3e02000 mvn r2, #0 30012bb4: e3a03000 mov r3, #0 30012bb8: e1520000 cmp r2, r0 30012bbc: 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;
30012bc0: b3a00000 movlt r0, #0
size_t *c
)
{
long long x = (long long)a*b;
if ( x > SIZE_MAX )
30012bc4: 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 );
30012bc8: eb000b65 bl 30015964 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
30012bcc: e3500000 cmp r0, #0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
30012bd0: e1a01000 mov r1, r0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
30012bd4: e584005c str r0, [r4, #92] ; 0x5c
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
30012bd8: 0a000013 beq 30012c2c <_CORE_message_queue_Initialize+0xc8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
30012bdc: e2840068 add r0, r4, #104 ; 0x68 30012be0: e1a02005 mov r2, r5 30012be4: e1a03006 mov r3, r6 30012be8: ebffffcd bl 30012b24 <_Chain_Initialize>
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
30012bec: 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 );
30012bf0: e2843050 add r3, r4, #80 ; 0x50 30012bf4: e2842054 add r2, r4, #84 ; 0x54
head->next = tail;
head->previous = NULL;
tail->previous = head;
30012bf8: e5843058 str r3, [r4, #88] ; 0x58 30012bfc: e2413001 sub r3, r1, #1 30012c00: e2731000 rsbs r1, r3, #0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30012c04: e5842050 str r2, [r4, #80] ; 0x50
head->previous = NULL;
30012c08: e3a02000 mov r2, #0 30012c0c: e5842054 str r2, [r4, #84] ; 0x54 30012c10: e1a00004 mov r0, r4 30012c14: e0a11003 adc r1, r1, r3 30012c18: e3a02080 mov r2, #128 ; 0x80 30012c1c: e3a03006 mov r3, #6 30012c20: eb000950 bl 30015168 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
30012c24: e3a00001 mov r0, #1
30012c28: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
30012c2c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30017b10 <_CORE_message_queue_Insert_message>:
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
else
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
30017b10: e3720106 cmn r2, #-2147483647 ; 0x80000001
void _CORE_message_queue_Insert_message(
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message,
CORE_message_queue_Submit_types submit_type
)
{
30017b14: e92d4010 push {r4, lr}
30017b18: e5812008 str r2, [r1, #8]
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
else
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
30017b1c: 1a00000e bne 30017b5c <_CORE_message_queue_Insert_message+0x4c>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30017b20: e10fc000 mrs ip, CPSR 30017b24: e38c3080 orr r3, ip, #128 ; 0x80 30017b28: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
SET_NOTIFY();
30017b2c: e5903048 ldr r3, [r0, #72] ; 0x48
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
30017b30: e2804054 add r4, r0, #84 ; 0x54
#include <rtems/score/coremsg.h>
#include <rtems/score/states.h>
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
void _CORE_message_queue_Insert_message(
30017b34: e2732001 rsbs r2, r3, #1
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
30017b38: e2833001 add r3, r3, #1 30017b3c: e5803048 str r3, [r0, #72] ; 0x48
Chain_Node *old_last = tail->previous;
30017b40: e5903058 ldr r3, [r0, #88] ; 0x58
the_node->next = tail;
30017b44: e5814000 str r4, [r1]
tail->previous = the_node;
30017b48: e5801058 str r1, [r0, #88] ; 0x58
#include <rtems/score/coremsg.h>
#include <rtems/score/states.h>
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
void _CORE_message_queue_Insert_message(
30017b4c: 33a02000 movcc r2, #0
old_last->next = the_node;
30017b50: e5831000 str r1, [r3]
the_node->previous = old_last;
30017b54: e5813004 str r3, [r1, #4] 30017b58: ea000011 b 30017ba4 <_CORE_message_queue_Insert_message+0x94>
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
30017b5c: e3520102 cmp r2, #-2147483648 ; 0x80000000
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
30017b60: 15903050 ldrne r3, [r0, #80] ; 0x50
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 ));
30017b64: 1280c054 addne ip, r0, #84 ; 0x54
30017b68: 1a000013 bne 30017bbc <_CORE_message_queue_Insert_message+0xac>
30017b6c: e10fc000 mrs ip, CPSR 30017b70: e38c3080 orr r3, ip, #128 ; 0x80 30017b74: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
SET_NOTIFY();
30017b78: e5903048 ldr r3, [r0, #72] ; 0x48
#include <rtems/score/coremsg.h>
#include <rtems/score/states.h>
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
void _CORE_message_queue_Insert_message(
30017b7c: e2732001 rsbs r2, r3, #1
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
30017b80: e2833001 add r3, r3, #1 30017b84: e5803048 str r3, [r0, #72] ; 0x48
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
30017b88: e2803050 add r3, r0, #80 ; 0x50
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
30017b8c: e5813004 str r3, [r1, #4]
before_node = after_node->next;
30017b90: e5903050 ldr r3, [r0, #80] ; 0x50
#include <rtems/score/coremsg.h>
#include <rtems/score/states.h>
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
void _CORE_message_queue_Insert_message(
30017b94: 33a02000 movcc r2, #0
after_node->next = the_node;
30017b98: e5801050 str r1, [r0, #80] ; 0x50
the_node->next = before_node; before_node->previous = the_node;
30017b9c: e5831004 str r1, [r3, #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;
30017ba0: e5813000 str r3, [r1]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30017ba4: e129f00c msr CPSR_fc, ip 30017ba8: ea000014 b 30017c00 <_CORE_message_queue_Insert_message+0xf0>
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
30017bac: e5934008 ldr r4, [r3, #8] <== NOT EXECUTED 30017bb0: e1540002 cmp r4, r2 <== NOT EXECUTED 30017bb4: ca000002 bgt 30017bc4 <_CORE_message_queue_Insert_message+0xb4><== NOT EXECUTED
the_node = the_node->next;
30017bb8: e5933000 ldr r3, [r3] <== NOT EXECUTED
int the_priority;
the_priority = _CORE_message_queue_Get_message_priority(the_message);
the_header = &the_message_queue->Pending_messages;
the_node = _Chain_First( the_header );
while ( !_Chain_Is_tail( the_header, the_node ) ) {
30017bbc: e153000c cmp r3, ip
30017bc0: 1afffff9 bne 30017bac <_CORE_message_queue_Insert_message+0x9c>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30017bc4: e10f4000 mrs r4, CPSR 30017bc8: e3842080 orr r2, r4, #128 ; 0x80 30017bcc: e129f002 msr CPSR_fc, r2
continue;
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
30017bd0: e590c048 ldr ip, [r0, #72] ; 0x48
the_message_queue->number_of_pending_messages++;
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
30017bd4: e5933004 ldr r3, [r3, #4]
#include <rtems/score/coremsg.h>
#include <rtems/score/states.h>
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
void _CORE_message_queue_Insert_message(
30017bd8: e27c2001 rsbs r2, ip, #1
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
30017bdc: e28cc001 add ip, ip, #1 30017be0: e580c048 str ip, [r0, #72] ; 0x48
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
30017be4: e593c000 ldr ip, [r3]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
30017be8: e5813004 str r3, [r1, #4]
before_node = after_node->next; after_node->next = the_node;
30017bec: e5831000 str r1, [r3]
#include <rtems/score/coremsg.h>
#include <rtems/score/states.h>
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
void _CORE_message_queue_Insert_message(
30017bf0: 33a02000 movcc r2, #0
the_node->next = before_node;
30017bf4: e581c000 str ip, [r1]
before_node->previous = the_node;
30017bf8: e58c1004 str r1, [ip, #4]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30017bfc: e129f004 msr CPSR_fc, r4
/*
* According to POSIX, does this happen before or after the message
* is actually enqueued. It is logical to think afterwards, because
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
30017c00: e3520000 cmp r2, #0
30017c04: 08bd8010 popeq {r4, pc}
30017c08: e5903060 ldr r3, [r0, #96] ; 0x60
30017c0c: e3530000 cmp r3, #0
30017c10: 08bd8010 popeq {r4, pc}
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
30017c14: e5900064 ldr r0, [r0, #100] ; 0x64 <== NOT EXECUTED
30017c18: e1a0e00f mov lr, pc <== NOT EXECUTED
30017c1c: e12fff13 bx r3 <== NOT EXECUTED
30017c20: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30012c30 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
30012c30: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30012c34: e1a04000 mov r4, r0
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
30012c38: e59f0110 ldr r0, [pc, #272] ; 30012d50 <_CORE_message_queue_Seize+0x120>
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30012c3c: e3a05000 mov r5, #0
{
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
30012c40: e5900008 ldr r0, [r0, #8]
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
30012c44: e59dc020 ldr ip, [sp, #32] 30012c48: e5dd801c ldrb r8, [sp, #28]
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30012c4c: e5805034 str r5, [r0, #52] ; 0x34
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30012c50: e10f6000 mrs r6, CPSR 30012c54: e3865080 orr r5, r6, #128 ; 0x80 30012c58: e129f005 msr CPSR_fc, r5
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
30012c5c: e1a07004 mov r7, r4 30012c60: e5b75050 ldr r5, [r7, #80]! ; 0x50
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30012c64: e284a054 add sl, r4, #84 ; 0x54
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
30012c68: e155000a cmp r5, sl
30012c6c: 0a000025 beq 30012d08 <_CORE_message_queue_Seize+0xd8>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
30012c70: e5951000 ldr r1, [r5]
head->next = new_first;
30012c74: e5841050 str r1, [r4, #80] ; 0x50
new_first->previous = head;
30012c78: e5817004 str r7, [r1, #4]
_ISR_Disable( level );
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
30012c7c: e5941048 ldr r1, [r4, #72] ; 0x48 30012c80: e2411001 sub r1, r1, #1 30012c84: e5841048 str r1, [r4, #72] ; 0x48
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30012c88: e129f006 msr CPSR_fc, r6
_ISR_Enable( level );
*size_p = the_message->Contents.size;
30012c8c: e595100c ldr r1, [r5, #12]
_Thread_Executing->Wait.count =
30012c90: e5950008 ldr r0, [r5, #8]
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
_ISR_Enable( level );
*size_p = the_message->Contents.size;
30012c94: e5831000 str r1, [r3]
_Thread_Executing->Wait.count =
30012c98: e59f10b0 ldr r1, [pc, #176] ; 30012d50 <_CORE_message_queue_Seize+0x120>
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
30012c9c: e2856010 add r6, r5, #16
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
_ISR_Enable( level );
*size_p = the_message->Contents.size;
_Thread_Executing->Wait.count =
30012ca0: e5911008 ldr r1, [r1, #8] 30012ca4: e5810024 str r0, [r1, #36] ; 0x24
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30012ca8: e1a00002 mov r0, r2 30012cac: e1a01006 mov r1, r6 30012cb0: e5932000 ldr r2, [r3] 30012cb4: eb001e47 bl 3001a5d8 <memcpy>
* is not, then we can go ahead and free the buffer.
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
30012cb8: e1a00004 mov r0, r4 30012cbc: eb00082f bl 30014d80 <_Thread_queue_Dequeue>
if ( !the_thread ) {
30012cc0: e2503000 subs r3, r0, #0
30012cc4: 1a000003 bne 30012cd8 <_CORE_message_queue_Seize+0xa8>
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
30012cc8: e2840068 add r0, r4, #104 ; 0x68 30012ccc: e1a01005 mov r1, r5
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
30012cd0: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
30012cd4: eaffff7a b 30012ac4 <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
30012cd8: e5932024 ldr r2, [r3, #36] ; 0x24 <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30012cdc: e1a00006 mov r0, r6 <== NOT EXECUTED
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
30012ce0: e5852008 str r2, [r5, #8] <== NOT EXECUTED
*/
_CORE_message_queue_Set_message_priority(
the_message,
the_thread->Wait.count
);
the_message->Contents.size = (size_t) the_thread->Wait.option;
30012ce4: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED 30012ce8: e585200c str r2, [r5, #12] <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30012cec: e593102c ldr r1, [r3, #44] ; 0x2c <== NOT EXECUTED 30012cf0: eb001e38 bl 3001a5d8 <memcpy> <== NOT EXECUTED
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
30012cf4: e5952008 ldr r2, [r5, #8] <== NOT EXECUTED 30012cf8: e1a00004 mov r0, r4 <== NOT EXECUTED 30012cfc: e1a01005 mov r1, r5 <== NOT EXECUTED
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
30012d00: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
30012d04: ea001381 b 30017b10 <_CORE_message_queue_Insert_message> <== NOT EXECUTED
return;
}
#endif
}
if ( !wait ) {
30012d08: e3580000 cmp r8, #0
30012d0c: 1a000003 bne 30012d20 <_CORE_message_queue_Seize+0xf0>
30012d10: e129f006 msr CPSR_fc, r6
_ISR_Enable( level );
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
30012d14: e3a03004 mov r3, #4 30012d18: e5803034 str r3, [r0, #52] ; 0x34
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
30012d1c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
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;
30012d20: e3a05001 mov r5, #1 30012d24: e5845030 str r5, [r4, #48] ; 0x30
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
return;
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
30012d28: e5804044 str r4, [r0, #68] ; 0x44
executing->Wait.id = id;
30012d2c: e5801020 str r1, [r0, #32]
executing->Wait.return_argument_second.mutable_object = buffer;
30012d30: e580202c str r2, [r0, #44] ; 0x2c
executing->Wait.return_argument = size_p;
30012d34: e5803028 str r3, [r0, #40] ; 0x28 30012d38: e129f006 msr CPSR_fc, r6
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
30012d3c: e59f2010 ldr r2, [pc, #16] ; 30012d54 <_CORE_message_queue_Seize+0x124> 30012d40: e1a00004 mov r0, r4 30012d44: e1a0100c mov r1, ip
}
30012d48: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
30012d4c: ea000863 b 30014ee0 <_Thread_queue_Enqueue_with_handler>
30012d58 <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012d58: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30012d5c: e1a09003 mov r9, r3
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30012d60: e590304c ldr r3, [r0, #76] ; 0x4c
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012d64: e1a04000 mov r4, r0
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30012d68: e1520003 cmp r2, r3
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012d6c: e1a08001 mov r8, r1 30012d70: e1a05002 mov r5, r2 30012d74: e59d6028 ldr r6, [sp, #40] ; 0x28 30012d78: e5ddb02c ldrb fp, [sp, #44] ; 0x2c
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;
30012d7c: 83a00001 movhi r0, #1
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30012d80: 88bd8ff0 pophi {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
30012d84: e594a048 ldr sl, [r4, #72] ; 0x48 30012d88: e35a0000 cmp sl, #0
30012d8c: 1a00000b bne 30012dc0 <_CORE_message_queue_Submit+0x68>
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
30012d90: eb0007fa bl 30014d80 <_Thread_queue_Dequeue>
if ( the_thread ) {
30012d94: e2507000 subs r7, r0, #0
30012d98: 0a000008 beq 30012dc0 <_CORE_message_queue_Submit+0x68>
30012d9c: e597002c ldr r0, [r7, #44] ; 0x2c 30012da0: e1a01008 mov r1, r8 30012da4: e1a02005 mov r2, r5 30012da8: eb001e0a bl 3001a5d8 <memcpy>
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30012dac: e5973028 ldr r3, [r7, #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;
30012db0: e1a0000a mov r0, sl
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30012db4: e5835000 str r5, [r3]
the_thread->Wait.count = (uint32_t) submit_type;
30012db8: e5876024 str r6, [r7, #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;
30012dbc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, 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 *)
30012dc0: e2840068 add r0, r4, #104 ; 0x68 30012dc4: ebffff49 bl 30012af0 <_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 ) {
30012dc8: e2507000 subs r7, r0, #0
30012dcc: 0a00000b beq 30012e00 <_CORE_message_queue_Submit+0xa8>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30012dd0: e1a01008 mov r1, r8 30012dd4: e1a02005 mov r2, r5 30012dd8: e2870010 add r0, r7, #16 30012ddc: eb001dfd bl 3001a5d8 <memcpy>
size
);
the_message->Contents.size = size;
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30012de0: e1a00004 mov r0, r4
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
30012de4: e587500c str r5, [r7, #12]
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
30012de8: e5876008 str r6, [r7, #8]
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30012dec: e1a01007 mov r1, r7 30012df0: e1a02006 mov r2, r6 30012df4: eb001345 bl 30017b10 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30012df8: e3a00000 mov r0, #0
30012dfc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
30012e00: e35b0000 cmp fp, #0 <== NOT EXECUTED
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
30012e04: 03a00002 moveq r0, #2 <== NOT EXECUTED
/*
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
30012e08: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* Do NOT block on a send if the caller is in an ISR. It is
* deadly to block in an ISR.
*/
if ( _ISR_Is_in_progress() ) {
30012e0c: e59f3058 ldr r3, [pc, #88] ; 30012e6c <_CORE_message_queue_Submit+0x114><== NOT EXECUTED 30012e10: e5932000 ldr r2, [r3] <== NOT EXECUTED 30012e14: e3520000 cmp r2, #0 <== NOT EXECUTED 30012e18: 1a000011 bne 30012e64 <_CORE_message_queue_Submit+0x10c> <== NOT EXECUTED
* Thus the unusual choice to open a new scope and declare
* it as a variable. Doing this emphasizes how dangerous it
* would be to use this variable prior to here.
*/
{
Thread_Control *executing = _Thread_Executing;
30012e1c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30012e20: e10f2000 mrs r2, CPSR <== NOT EXECUTED 30012e24: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30012e28: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 30012e2c: e3a01001 mov r1, #1 <== NOT EXECUTED 30012e30: e5841030 str r1, [r4, #48] ; 0x30 <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
30012e34: e5834044 str r4, [r3, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
30012e38: e5839020 str r9, [r3, #32] <== NOT EXECUTED
executing->Wait.return_argument_second.immutable_object = buffer;
30012e3c: e583802c str r8, [r3, #44] ; 0x2c <== NOT EXECUTED
executing->Wait.option = (uint32_t) size;
30012e40: e5835030 str r5, [r3, #48] ; 0x30 <== NOT EXECUTED
executing->Wait.count = submit_type;
30012e44: e5836024 str r6, [r3, #36] ; 0x24 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30012e48: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
30012e4c: e59f201c ldr r2, [pc, #28] ; 30012e70 <_CORE_message_queue_Submit+0x118><== NOT EXECUTED 30012e50: e1a00004 mov r0, r4 <== NOT EXECUTED 30012e54: e59d1030 ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED 30012e58: eb000820 bl 30014ee0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
30012e5c: e3a00007 mov r0, #7 <== NOT EXECUTED
30012e60: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* Do NOT block on a send if the caller is in an ISR. It is
* deadly to block in an ISR.
*/
if ( _ISR_Is_in_progress() ) {
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
30012e64: e3a00003 mov r0, #3 <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
30012e68: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000adec <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000adec: e92d40f0 push {r4, r5, r6, r7, lr}
3000adf0: 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 )
3000adf4: e59f30b4 ldr r3, [pc, #180] ; 3000aeb0 <_CORE_mutex_Seize+0xc4> 3000adf8: e1a04000 mov r4, r0 3000adfc: e5933000 ldr r3, [r3] 3000ae00: e1a05001 mov r5, r1 3000ae04: e3530000 cmp r3, #0 3000ae08: e20260ff and r6, r2, #255 ; 0xff
3000ae0c: 0a000007 beq 3000ae30 <_CORE_mutex_Seize+0x44>
3000ae10: ea000023 b 3000aea4 <_CORE_mutex_Seize+0xb8>
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
3000ae14: e59f3098 ldr r3, [pc, #152] ; 3000aeb4 <_CORE_mutex_Seize+0xc8>
3000ae18: e5933000 ldr r3, [r3]
3000ae1c: e3530001 cmp r3, #1
3000ae20: 83a00000 movhi r0, #0
3000ae24: 81a01000 movhi r1, r0
3000ae28: 83a02012 movhi r2, #18
3000ae2c: 8b0001c0 blhi 3000b534 <_Internal_error_Occurred>
3000ae30: e1a00004 mov r0, r4
3000ae34: e28d1014 add r1, sp, #20
3000ae38: eb00127c bl 3000f830 <_CORE_mutex_Seize_interrupt_trylock>
3000ae3c: e3500000 cmp r0, #0
3000ae40: 08bd80f0 popeq {r4, r5, r6, r7, pc}
3000ae44: e3560000 cmp r6, #0
3000ae48: e59f3068 ldr r3, [pc, #104] ; 3000aeb8 <_CORE_mutex_Seize+0xcc>
3000ae4c: 1a000005 bne 3000ae68 <_CORE_mutex_Seize+0x7c>
3000ae50: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
3000ae54: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
3000ae58: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
3000ae5c: e3a02001 mov r2, #1 <== NOT EXECUTED
3000ae60: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
3000ae64: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000ae68: 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;
3000ae6c: e3a02001 mov r2, #1 3000ae70: e5842030 str r2, [r4, #48] ; 0x30 3000ae74: e5834044 str r4, [r3, #68] ; 0x44 3000ae78: 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;
3000ae7c: e59f302c ldr r3, [pc, #44] ; 3000aeb0 <_CORE_mutex_Seize+0xc4> 3000ae80: e5932000 ldr r2, [r3]
++level;
3000ae84: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000ae88: e5832000 str r2, [r3]
3000ae8c: e59d3014 ldr r3, [sp, #20]
3000ae90: e129f003 msr CPSR_fc, r3
3000ae94: e1a00004 mov r0, r4
3000ae98: e1a01007 mov r1, r7
3000ae9c: ebffffb3 bl 3000ad70 <_CORE_mutex_Seize_interrupt_blocking>
3000aea0: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000aea4: e3560000 cmp r6, #0
3000aea8: 1affffd9 bne 3000ae14 <_CORE_mutex_Seize+0x28>
3000aeac: eaffffdf b 3000ae30 <_CORE_mutex_Seize+0x44> <== NOT EXECUTED
3000f830 <_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
)
{
3000f830: e1a03000 mov r3, r0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000f834: e59f2114 ldr r2, [pc, #276] ; 3000f950 <_CORE_mutex_Seize_interrupt_trylock+0x120>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000f838: 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;
3000f83c: e3a00000 mov r0, #0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000f840: e5922008 ldr r2, [r2, #8]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000f844: e15c0000 cmp ip, r0
3000f848: e92d4010 push {r4, lr}
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000f84c: e5820034 str r0, [r2, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000f850: 0a00002a beq 3000f900 <_CORE_mutex_Seize_interrupt_trylock+0xd0>
the_mutex->lock = CORE_MUTEX_LOCKED;
3000f854: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
3000f858: 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;
3000f85c: e583205c str r2, [r3, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
3000f860: e5830060 str r0, [r3, #96] ; 0x60
the_mutex->nest_count = 1;
3000f864: e3a00001 mov r0, #1 3000f868: 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;
3000f86c: 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 ) ||
3000f870: e3500002 cmp r0, #2
3000f874: 0a000001 beq 3000f880 <_CORE_mutex_Seize_interrupt_trylock+0x50>
3000f878: e3500003 cmp r0, #3
3000f87c: 1a00002d bne 3000f938 <_CORE_mutex_Seize_interrupt_trylock+0x108>
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000f880: e592c01c ldr ip, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
3000f884: 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++;
3000f888: e28c4001 add r4, ip, #1 3000f88c: e582401c str r4, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
3000f890: 1a000028 bne 3000f938 <_CORE_mutex_Seize_interrupt_trylock+0x108>
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
3000f894: e593004c ldr r0, [r3, #76] ; 0x4c
current = executing->current_priority;
3000f898: e5924014 ldr r4, [r2, #20]
if ( current == ceiling ) {
3000f89c: e1540000 cmp r4, r0
3000f8a0: 0a000024 beq 3000f938 <_CORE_mutex_Seize_interrupt_trylock+0x108>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
3000f8a4: 9a00000b bls 3000f8d8 <_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;
3000f8a8: e59f20a4 ldr r2, [pc, #164] ; 3000f954 <_CORE_mutex_Seize_interrupt_trylock+0x124><== NOT EXECUTED 3000f8ac: e5920000 ldr r0, [r2] <== NOT EXECUTED
++level;
3000f8b0: e2800001 add r0, r0, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000f8b4: e5820000 str r0, [r2] <== NOT EXECUTED 3000f8b8: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000f8bc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
3000f8c0: e3a02000 mov r2, #0 <== NOT EXECUTED 3000f8c4: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED 3000f8c8: e593104c ldr r1, [r3, #76] ; 0x4c <== NOT EXECUTED 3000f8cc: ebfff2ce bl 3000c40c <_Thread_Change_priority> <== NOT EXECUTED
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
3000f8d0: ebfff3e6 bl 3000c870 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000f8d4: ea000019 b 3000f940 <_CORE_mutex_Seize_interrupt_trylock+0x110><== NOT EXECUTED
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
3000f8d8: e3a00006 mov r0, #6 3000f8dc: e5820034 str r0, [r2, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000f8e0: e3a00001 mov r0, #1 3000f8e4: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
3000f8e8: e3a00000 mov r0, #0 3000f8ec: e5830054 str r0, [r3, #84] ; 0x54
executing->resource_count--; /* undo locking above */
3000f8f0: e582c01c str ip, [r2, #28]
3000f8f4: e5913000 ldr r3, [r1]
3000f8f8: e129f003 msr CPSR_fc, r3
3000f8fc: 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 ) ) {
3000f900: e593005c ldr r0, [r3, #92] ; 0x5c 3000f904: e1500002 cmp r0, r2
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000f908: 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 ) ) {
3000f90c: 18bd8010 popne {r4, pc}
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000f910: e5932040 ldr r2, [r3, #64] ; 0x40 3000f914: e3520000 cmp r2, #0
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
3000f918: 05932054 ldreq r2, [r3, #84] ; 0x54 3000f91c: 02822001 addeq r2, r2, #1 3000f920: 05832054 streq r2, [r3, #84] ; 0x54
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000f924: 0a000003 beq 3000f938 <_CORE_mutex_Seize_interrupt_trylock+0x108>
3000f928: e3520001 cmp r2, #1
3000f92c: 1a000005 bne 3000f948 <_CORE_mutex_Seize_interrupt_trylock+0x118>
the_mutex->nest_count++;
_ISR_Enable( *level_p );
return 0;
#if defined(RTEMS_POSIX_API)
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
3000f930: e3a03002 mov r3, #2 3000f934: e5803034 str r3, [r0, #52] ; 0x34 3000f938: e5913000 ldr r3, [r1] 3000f93c: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
3000f940: e3a00000 mov r0, #0
3000f944: e8bd8010 pop {r4, pc}
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000f948: e3a00001 mov r0, #1
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
3000f94c: e8bd8010 pop {r4, pc}
3000aebc <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000aebc: e92d4030 push {r4, r5, lr}
3000aec0: 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 ) {
3000aec4: e5d43044 ldrb r3, [r4, #68] ; 0x44
)
{
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
3000aec8: 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 ) {
3000aecc: e3530000 cmp r3, #0
3000aed0: 0a000004 beq 3000aee8 <_CORE_mutex_Surrender+0x2c>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000aed4: e59f30e8 ldr r3, [pc, #232] ; 3000afc4 <_CORE_mutex_Surrender+0x108>
if ( !_Thread_Is_executing( holder ) )
3000aed8: e5933008 ldr r3, [r3, #8] 3000aedc: e1500003 cmp r0, r3
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
3000aee0: 13a05003 movne r5, #3
* 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 ) )
3000aee4: 1a000034 bne 3000afbc <_CORE_mutex_Surrender+0x100>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
3000aee8: e5945054 ldr r5, [r4, #84] ; 0x54 3000aeec: e3550000 cmp r5, #0
3000aef0: 0a000031 beq 3000afbc <_CORE_mutex_Surrender+0x100>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000aef4: e2455001 sub r5, r5, #1
if ( the_mutex->nest_count != 0 ) {
3000aef8: e3550000 cmp r5, #0
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000aefc: 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;
3000af00: 13a05000 movne r5, #0
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
3000af04: 1a00002c bne 3000afbc <_CORE_mutex_Surrender+0x100>
3000af08: 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 ) ||
3000af0c: e3530002 cmp r3, #2
3000af10: 0a000001 beq 3000af1c <_CORE_mutex_Surrender+0x60>
3000af14: e3530003 cmp r3, #3
3000af18: 1a000009 bne 3000af44 <_CORE_mutex_Surrender+0x88>
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000af1c: e590301c ldr r3, [r0, #28] 3000af20: 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 &&
3000af24: e3530000 cmp r3, #0
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000af28: 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 &&
3000af2c: 1a000004 bne 3000af44 <_CORE_mutex_Surrender+0x88>
holder->real_priority != holder->current_priority ) {
3000af30: 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 &&
3000af34: e5903014 ldr r3, [r0, #20] 3000af38: e1510003 cmp r1, r3
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
3000af3c: 13a02001 movne r2, #1 3000af40: 1b000531 blne 3000c40c <_Thread_Change_priority>
}
}
the_mutex->holder = NULL;
3000af44: e3a05000 mov r5, #0 3000af48: e584505c str r5, [r4, #92] ; 0x5c
the_mutex->holder_id = 0;
3000af4c: 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 ) ) ) {
3000af50: e1a00004 mov r0, r4 3000af54: eb000719 bl 3000cbc0 <_Thread_queue_Dequeue> 3000af58: e3a02001 mov r2, #1 3000af5c: e2503000 subs r3, r0, #0
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000af60: 05842050 streq r2, [r4, #80] ; 0x50
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000af64: 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 ) ) ) {
3000af68: 0a000013 beq 3000afbc <_CORE_mutex_Surrender+0x100>
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000af6c: e5931008 ldr r1, [r3, #8]
the_mutex->nest_count = 1;
3000af70: e5842054 str r2, [r4, #84] ; 0x54
switch ( the_mutex->Attributes.discipline ) {
3000af74: e5942048 ldr r2, [r4, #72] ; 0x48
} else
#endif
{
the_mutex->holder = the_thread;
3000af78: e584305c str r3, [r4, #92] ; 0x5c
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000af7c: 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++;
3000af80: 0593201c ldreq r2, [r3, #28]
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000af84: 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++;
3000af88: 02822001 addeq r2, r2, #1 3000af8c: 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 ) {
3000af90: 0a000009 beq 3000afbc <_CORE_mutex_Surrender+0x100>
3000af94: e3520003 cmp r2, #3
3000af98: 1a000007 bne 3000afbc <_CORE_mutex_Surrender+0x100>
_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++;
3000af9c: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000afa0: 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++;
3000afa4: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000afa8: e583201c str r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000afac: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED 3000afb0: e1510003 cmp r1, r3 <== NOT EXECUTED
the_thread->current_priority){
_Thread_Change_priority(
3000afb4: 31a02005 movcc r2, r5 <== NOT EXECUTED 3000afb8: 3b000513 blcc 3000c40c <_Thread_Change_priority> <== NOT EXECUTED
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
3000afbc: e1a00005 mov r0, r5
3000afc0: e8bd8030 pop {r4, r5, pc}
3000cb50 <_CORE_spinlock_Initialize>:
CORE_spinlock_Control *the_spinlock,
CORE_spinlock_Attributes *the_spinlock_attributes
)
{
the_spinlock->Attributes = *the_spinlock_attributes;
3000cb50: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000cb54: e5803000 str r3, [r0] <== NOT EXECUTED
the_spinlock->lock = 0;
3000cb58: e3a03000 mov r3, #0 <== NOT EXECUTED 3000cb5c: e5803004 str r3, [r0, #4] <== NOT EXECUTED
the_spinlock->users = 0;
3000cb60: e5803008 str r3, [r0, #8] <== NOT EXECUTED
the_spinlock->holder = 0;
3000cb64: e580300c str r3, [r0, #12] <== NOT EXECUTED
}
3000cb68: e12fff1e bx lr <== NOT EXECUTED
3000b880 <_CORE_spinlock_Release>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b880: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000b884: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000b888: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Disable( level );
/*
* It must locked before it can be unlocked.
*/
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000b88c: e5902004 ldr r2, [r0, #4] <== NOT EXECUTED 3000b890: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b894: 1a000002 bne 3000b8a4 <_CORE_spinlock_Release+0x24> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b898: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_NOT_LOCKED;
3000b89c: e3a00006 mov r0, #6 <== NOT EXECUTED 3000b8a0: e12fff1e bx lr <== NOT EXECUTED
}
/*
* It must locked by the current thread before it can be unlocked.
*/
if ( the_spinlock->holder != _Thread_Executing->Object.id ) {
3000b8a4: e59f2040 ldr r2, [pc, #64] ; 3000b8ec <_CORE_spinlock_Release+0x6c><== NOT EXECUTED 3000b8a8: e590100c ldr r1, [r0, #12] <== NOT EXECUTED 3000b8ac: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000b8b0: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000b8b4: e1510002 cmp r1, r2 <== NOT EXECUTED 3000b8b8: 0a000002 beq 3000b8c8 <_CORE_spinlock_Release+0x48> <== NOT EXECUTED 3000b8bc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_NOT_HOLDER;
3000b8c0: e3a00002 mov r0, #2 <== NOT EXECUTED 3000b8c4: e12fff1e bx lr <== NOT EXECUTED
}
/*
* Let it be unlocked.
*/
the_spinlock->users -= 1;
3000b8c8: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED 3000b8cc: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000b8d0: e5802008 str r2, [r0, #8] <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_UNLOCKED;
3000b8d4: e3a02000 mov r2, #0 <== NOT EXECUTED 3000b8d8: e5802004 str r2, [r0, #4] <== NOT EXECUTED
the_spinlock->holder = 0;
3000b8dc: e580200c str r2, [r0, #12] <== NOT EXECUTED 3000b8e0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_SUCCESSFUL;
3000b8e4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000b8e8: e12fff1e bx lr <== NOT EXECUTED
3000b8f0 <_CORE_spinlock_Wait>:
CORE_spinlock_Status _CORE_spinlock_Wait(
CORE_spinlock_Control *the_spinlock,
bool wait,
Watchdog_Interval timeout
)
{
3000b8f0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000b8f4: e1a04000 mov r4, r0 <== NOT EXECUTED
3000b8f8: e20160ff and r6, r1, #255 ; 0xff <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b8fc: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b900: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b904: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3000b908: e1a03002 mov r3, r2 <== NOT EXECUTED
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout;
#endif
_ISR_Disable( level );
if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) &&
3000b90c: e5901004 ldr r1, [r0, #4] <== NOT EXECUTED 3000b910: e3510001 cmp r1, #1 <== NOT EXECUTED 3000b914: 1a000008 bne 3000b93c <_CORE_spinlock_Wait+0x4c> <== NOT EXECUTED
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
3000b918: e59f10a0 ldr r1, [pc, #160] ; 3000b9c0 <_CORE_spinlock_Wait+0xd0><== NOT EXECUTED 3000b91c: e590000c ldr r0, [r0, #12] <== NOT EXECUTED 3000b920: e5911008 ldr r1, [r1, #8] <== NOT EXECUTED
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout;
#endif
_ISR_Disable( level );
if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) &&
3000b924: e5911008 ldr r1, [r1, #8] <== NOT EXECUTED 3000b928: e1500001 cmp r0, r1 <== NOT EXECUTED 3000b92c: 1a000002 bne 3000b93c <_CORE_spinlock_Wait+0x4c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b930: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
_ISR_Enable( level );
return CORE_SPINLOCK_HOLDER_RELOCKING;
3000b934: e3a00001 mov r0, #1 <== NOT EXECUTED
3000b938: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
}
the_spinlock->users += 1;
3000b93c: e5942008 ldr r2, [r4, #8] <== 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;
3000b940: e59f507c ldr r5, [pc, #124] ; 3000b9c4 <_CORE_spinlock_Wait+0xd4><== NOT EXECUTED 3000b944: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000b948: e5842008 str r2, [r4, #8] <== NOT EXECUTED
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000b94c: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000b950: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b954: 1a000008 bne 3000b97c <_CORE_spinlock_Wait+0x8c> <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_LOCKED;
3000b958: e3a02001 mov r2, #1 <== NOT EXECUTED 3000b95c: e5842004 str r2, [r4, #4] <== NOT EXECUTED
the_spinlock->holder = _Thread_Executing->Object.id;
3000b960: e59f2058 ldr r2, [pc, #88] ; 3000b9c0 <_CORE_spinlock_Wait+0xd0><== NOT EXECUTED 3000b964: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000b968: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000b96c: e584200c str r2, [r4, #12] <== NOT EXECUTED 3000b970: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_SUCCESSFUL;
3000b974: e3a00000 mov r0, #0 <== NOT EXECUTED
3000b978: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
}
/*
* Spinlock is unavailable. If not willing to wait, return.
*/
if ( !wait ) {
3000b97c: e3560000 cmp r6, #0 <== NOT EXECUTED 3000b980: 1a000005 bne 3000b99c <_CORE_spinlock_Wait+0xac> <== NOT EXECUTED
the_spinlock->users -= 1;
3000b984: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3000b988: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000b98c: e5842008 str r2, [r4, #8] <== NOT EXECUTED 3000b990: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_UNAVAILABLE;
3000b994: e3a00005 mov r0, #5 <== NOT EXECUTED
3000b998: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000b99c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
_ISR_Enable( level );
/* An ISR could occur here */
_Thread_Enable_dispatch();
3000b9a0: eb0005f0 bl 3000d168 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000b9a4: e5953000 ldr r3, [r5] <== NOT EXECUTED
++level;
3000b9a8: e2833001 add r3, r3, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000b9ac: e5853000 str r3, [r5] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b9b0: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000b9b4: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000b9b8: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
/* Reenter the critical sections so we can attempt the lock again. */
_Thread_Disable_dispatch();
_ISR_Disable( level );
}
3000b9bc: eaffffe2 b 3000b94c <_CORE_spinlock_Wait+0x5c> <== NOT EXECUTED
3000b378 <_Chain_Append_with_empty_check>:
bool _Chain_Append_with_empty_check(
Chain_Control *chain,
Chain_Node *node
)
{
3000b378: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b37c: e1a03000 mov r3, r0 <== NOT EXECUTED
3000b380: e10f4000 mrs r4, CPSR <== NOT EXECUTED
3000b384: e3842080 orr r2, r4, #128 ; 0x80 <== NOT EXECUTED
3000b388: 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 );
3000b38c: 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 )
3000b390: e5900000 ldr r0, [r0] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3000b394: e581c000 str ip, [r1] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000b398: e06c2000 rsb r2, ip, r0 <== NOT EXECUTED 3000b39c: e2720000 rsbs r0, r2, #0 <== NOT EXECUTED 3000b3a0: 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;
3000b3a4: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
the_node->next = tail;
tail->previous = the_node;
3000b3a8: e5831008 str r1, [r3, #8] <== NOT EXECUTED
old_last->next = the_node;
3000b3ac: e5821000 str r1, [r2] <== NOT EXECUTED
the_node->previous = old_last;
3000b3b0: 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 (
3000b3b4: 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;
}
3000b3b8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b3e8 <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
3000b3e8: e92d4010 push {r4, lr} <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b3ec: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000b3f0: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000b3f4: 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;
3000b3f8: 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 );
3000b3fc: e280c004 add ip, r0, #4 <== NOT EXECUTED
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000b400: e152000c cmp r2, ip <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
} else
*the_node = NULL;
3000b404: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000b408: 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;
3000b40c: 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 ) {
3000b410: 0a000006 beq 3000b430 <_Chain_Get_with_empty_check+0x48> <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
3000b414: e5923000 ldr r3, [r2] <== NOT EXECUTED
head->next = new_first;
3000b418: e5803000 str r3, [r0] <== NOT EXECUTED
new_first->previous = head;
3000b41c: e5830004 str r0, [r3, #4] <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
3000b420: e06c3003 rsb r3, ip, r3 <== NOT EXECUTED 3000b424: 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;
3000b428: e5812000 str r2, [r1] <== NOT EXECUTED
is_empty_now = new_first == tail;
3000b42c: 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 (
3000b430: 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;
}
3000b434: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cd40 <_Chain_Insert>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000cd40: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000cd44: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000cd48: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000cd4c: e5903000 ldr r3, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000cd50: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000cd54: e5801000 str r1, [r0] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000cd58: 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;
3000cd5c: 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 (
3000cd60: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
_Chain_Insert_unprotected( after_node, node );
_ISR_Enable( level );
}
3000cd64: e12fff1e bx lr <== NOT EXECUTED
3000b4d4 <_Chain_Prepend_with_empty_check>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b4d4: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b4d8: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b4dc: 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;
3000b4e0: e5903000 ldr r3, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b4e4: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b4e8: e4801004 str r1, [r0], #4 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b4ec: 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;
3000b4f0: 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 (
3000b4f4: 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;
}
3000b4f8: e0603003 rsb r3, r0, r3 <== NOT EXECUTED 3000b4fc: e2730000 rsbs r0, r3, #0 <== NOT EXECUTED 3000b500: e0a00003 adc r0, r0, r3 <== NOT EXECUTED 3000b504: 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: eb000dab bl 3000d420 <_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: eb000cce bl 3000d0b8 <_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: ea000983 b 3000c3c0 <_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: eb000d9e bl 3000d57c <_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: ea00097c b 3000c504 <_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: eb000a57 bl 3000c890 <_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: eb000960 bl 3000c504 <_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
3000f958 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f958: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000f95c: 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;
3000f960: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f964: e24dd01c sub sp, sp, #28 3000f968: 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 ) {
3000f96c: e2913004 adds r3, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f970: e1a05000 mov r5, r0 3000f974: 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;
3000f978: 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 ) {
3000f97c: e58d300c str r3, [sp, #12]
3000f980: 2a00006a bcs 3000fb30 <_Heap_Allocate_aligned_with_boundary+0x1d8>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
3000f984: e35b0000 cmp fp, #0
3000f988: 0a000003 beq 3000f99c <_Heap_Allocate_aligned_with_boundary+0x44>
if ( boundary < alloc_size ) {
3000f98c: e15b0001 cmp fp, r1 <== NOT EXECUTED 3000f990: 3a000066 bcc 3000fb30 <_Heap_Allocate_aligned_with_boundary+0x1d8><== NOT EXECUTED
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
3000f994: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f998: 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
3000f99c: e59d2000 ldr r2, [sp]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000f9a0: 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
3000f9a4: 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;
3000f9a8: 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 ) {
3000f9ac: 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
3000f9b0: e58d2014 str r2, [sp, #20]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000f9b4: 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 ) {
3000f9b8: ea000048 b 3000fae0 <_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 ) {
3000f9bc: e59a4004 ldr r4, [sl, #4] 3000f9c0: e59d200c ldr r2, [sp, #12] 3000f9c4: e1540002 cmp r4, r2
3000f9c8: 9a00003f bls 3000facc <_Heap_Allocate_aligned_with_boundary+0x174>
if ( alignment == 0 ) {
3000f9cc: 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;
3000f9d0: 028a4008 addeq r4, sl, #8
3000f9d4: 0a00003d beq 3000fad0 <_Heap_Allocate_aligned_with_boundary+0x178>
3000f9d8: 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;
3000f9dc: e5953014 ldr r3, [r5, #20] 3000f9e0: 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;
3000f9e4: 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;
3000f9e8: 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;
3000f9ec: 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;
3000f9f0: e3c44001 bic r4, r4, #1
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000f9f4: 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;
3000f9f8: 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
3000f9fc: 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;
3000fa00: e0834004 add r4, r3, r4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000fa04: e1a00004 mov r0, r4 3000fa08: e1a01008 mov r1, r8 3000fa0c: eb002c0d bl 3001aa48 <__umodsi3> 3000fa10: 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 ) {
3000fa14: e1540009 cmp r4, r9
3000fa18: 9a000003 bls 3000fa2c <_Heap_Allocate_aligned_with_boundary+0xd4>
3000fa1c: e1a00009 mov r0, r9 <== NOT EXECUTED 3000fa20: e1a01008 mov r1, r8 <== NOT EXECUTED 3000fa24: eb002c07 bl 3001aa48 <__umodsi3> <== NOT EXECUTED 3000fa28: e0604009 rsb r4, r0, r9 <== NOT EXECUTED
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
3000fa2c: e35b0000 cmp fp, #0
3000fa30: 0a000014 beq 3000fa88 <_Heap_Allocate_aligned_with_boundary+0x130>
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000fa34: 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;
3000fa38: e0849006 add r9, r4, r6 <== NOT EXECUTED
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000fa3c: e0822006 add r2, r2, r6 <== NOT EXECUTED 3000fa40: e58d2010 str r2, [sp, #16] <== NOT EXECUTED 3000fa44: ea000008 b 3000fa6c <_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 ) {
3000fa48: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000fa4c: e1500003 cmp r0, r3 <== NOT EXECUTED 3000fa50: 3a00001d bcc 3000facc <_Heap_Allocate_aligned_with_boundary+0x174><== NOT EXECUTED
return 0;
}
alloc_begin = boundary_line - alloc_size;
3000fa54: e0664000 rsb r4, r6, r0 <== NOT EXECUTED 3000fa58: e1a00004 mov r0, r4 <== NOT EXECUTED 3000fa5c: e1a01008 mov r1, r8 <== NOT EXECUTED 3000fa60: eb002bf8 bl 3001aa48 <__umodsi3> <== NOT EXECUTED 3000fa64: e0604004 rsb r4, r0, r4 <== NOT EXECUTED
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
3000fa68: e0849006 add r9, r4, r6 <== NOT EXECUTED 3000fa6c: e1a00009 mov r0, r9 <== NOT EXECUTED 3000fa70: e1a0100b mov r1, fp <== NOT EXECUTED 3000fa74: eb002bf3 bl 3001aa48 <__umodsi3> <== NOT EXECUTED 3000fa78: 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 ) {
3000fa7c: e1500009 cmp r0, r9 <== NOT EXECUTED 3000fa80: 31540000 cmpcc r4, r0 <== NOT EXECUTED 3000fa84: 3affffef bcc 3000fa48 <_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 ) {
3000fa88: e59d2008 ldr r2, [sp, #8] 3000fa8c: e1540002 cmp r4, r2
3000fa90: 3a00000d bcc 3000facc <_Heap_Allocate_aligned_with_boundary+0x174>
3000fa94: e1a00004 mov r0, r4 3000fa98: e59d1000 ldr r1, [sp] 3000fa9c: eb002be9 bl 3001aa48 <__umodsi3> 3000faa0: e3e09007 mvn r9, #7 3000faa4: 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);
3000faa8: e0899004 add r9, r9, r4
if ( free_size >= min_block_size || free_size == 0 ) {
return alloc_begin;
}
}
return 0;
3000faac: 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 ) {
3000fab0: e0603009 rsb r3, r0, r9
return alloc_begin;
}
}
return 0;
3000fab4: e1590000 cmp r9, r0 3000fab8: 11530002 cmpne r3, r2 3000fabc: 33a09000 movcc r9, #0 3000fac0: 23a09001 movcs r9, #1 3000fac4: 31a04009 movcc r4, r9 3000fac8: ea000000 b 3000fad0 <_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 ) {
3000facc: e3a04000 mov r4, #0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
3000fad0: e3540000 cmp r4, #0
);
}
}
/* Statistics */
++search_count;
3000fad4: e2877001 add r7, r7, #1
if ( alloc_begin != 0 ) {
3000fad8: 1a000004 bne 3000faf0 <_Heap_Allocate_aligned_with_boundary+0x198>
break;
}
block = block->next;
3000fadc: 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 ) {
3000fae0: e15a0005 cmp sl, r5
3000fae4: 1affffb4 bne 3000f9bc <_Heap_Allocate_aligned_with_boundary+0x64>
3000fae8: e3a04000 mov r4, #0 3000faec: ea00000a b 3000fb1c <_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;
3000faf0: e5953048 ldr r3, [r5, #72] ; 0x48
stats->searches += search_count;
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000faf4: e1a00005 mov r0, r5
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000faf8: e2833001 add r3, r3, #1 3000fafc: e5853048 str r3, [r5, #72] ; 0x48
stats->searches += search_count;
3000fb00: e595304c ldr r3, [r5, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000fb04: e1a0100a mov r1, sl
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
stats->searches += search_count;
3000fb08: e0833007 add r3, r3, r7 3000fb0c: e585304c str r3, [r5, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000fb10: e1a02004 mov r2, r4 3000fb14: e1a03006 mov r3, r6 3000fb18: ebffee3a bl 3000b408 <_Heap_Block_allocate>
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000fb1c: e5953044 ldr r3, [r5, #68] ; 0x44
stats->max_search = search_count;
}
return (void *) alloc_begin;
3000fb20: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000fb24: e1530007 cmp r3, r7
stats->max_search = search_count;
3000fb28: 35857044 strcc r7, [r5, #68] ; 0x44
}
return (void *) alloc_begin;
3000fb2c: ea000000 b 3000fb34 <_Heap_Allocate_aligned_with_boundary+0x1dc>
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
3000fb30: e3a00000 mov r0, #0
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000fb34: e28dd01c add sp, sp, #28
3000fb38: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000b408 <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000b408: 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;
3000b40c: 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;
3000b410: e2426008 sub r6, r2, #8 3000b414: e1a04001 mov r4, r1 3000b418: 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;
3000b41c: 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;
3000b420: 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);
3000b424: e0849001 add r9, r4, r1
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000b428: 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;
3000b42c: e5990004 ldr r0, [r9, #4]
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000b430: 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 );
3000b434: 11a08005 movne r8, r5
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000b438: 1a00000c bne 3000b470 <_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;
3000b43c: e5940008 ldr r0, [r4, #8]
free_list_anchor = block->prev;
3000b440: e594800c ldr r8, [r4, #12]
Heap_Block *prev = block->prev;
prev->next = next;
3000b444: e5880008 str r0, [r8, #8]
next->prev = prev;
3000b448: e580800c str r8, [r0, #12]
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000b44c: e5950038 ldr r0, [r5, #56] ; 0x38 3000b450: e2400001 sub r0, r0, #1 3000b454: e5850038 str r0, [r5, #56] ; 0x38
++stats->used_blocks;
3000b458: e5950040 ldr r0, [r5, #64] ; 0x40 3000b45c: e2800001 add r0, r0, #1 3000b460: e5850040 str r0, [r5, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000b464: e5950030 ldr r0, [r5, #48] ; 0x30 3000b468: e0611000 rsb r1, r1, r0 3000b46c: e5851030 str r1, [r5, #48] ; 0x30
} else {
free_list_anchor = _Heap_Free_list_head( heap );
}
if ( alloc_area_offset < heap->page_size ) {
3000b470: e5951010 ldr r1, [r5, #16] 3000b474: e1530001 cmp r3, r1
3000b478: 2a000005 bcs 3000b494 <_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 );
3000b47c: e1a00005 mov r0, r5 3000b480: e1a01004 mov r1, r4 3000b484: e1a02008 mov r2, r8 3000b488: e0833007 add r3, r3, r7 3000b48c: ebffff31 bl 3000b158 <_Heap_Block_split> 3000b490: ea000021 b 3000b51c <_Heap_Block_allocate+0x114>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000b494: e1a00002 mov r0, r2 3000b498: eb003d6a bl 3001aa48 <__umodsi3>
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000b49c: 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);
3000b4a0: 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;
3000b4a4: 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;
3000b4a8: e0822003 add r2, r2, r3
if ( _Heap_Is_prev_used( block ) ) {
3000b4ac: 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;
3000b4b0: 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;
3000b4b4: e5852030 str r2, [r5, #48] ; 0x30
if ( _Heap_Is_prev_used( block ) ) {
3000b4b8: 0a000009 beq 3000b4e4 <_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;
3000b4bc: e5982008 ldr r2, [r8, #8]
new_block->next = next;
new_block->prev = block_before;
3000b4c0: e584800c str r8, [r4, #12]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
3000b4c4: e5842008 str r2, [r4, #8]
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
3000b4c8: e582400c str r4, [r2, #12]
_Heap_Free_list_insert_after( free_list_anchor, block );
free_list_anchor = block;
/* Statistics */
++stats->free_blocks;
3000b4cc: 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;
3000b4d0: e5884008 str r4, [r8, #8] 3000b4d4: e2822001 add r2, r2, #1 3000b4d8: e5852038 str r2, [r5, #56] ; 0x38 3000b4dc: e1a02004 mov r2, r4 3000b4e0: ea000005 b 3000b4fc <_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);
3000b4e4: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000b4e8: 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;
3000b4ec: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000b4f0: 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;
3000b4f4: e0833002 add r3, r3, r2 <== NOT EXECUTED 3000b4f8: e1a02008 mov r2, r8 <== NOT EXECUTED
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
3000b4fc: e3831001 orr r1, r3, #1 3000b500: 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 );
3000b504: 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;
3000b508: e8860208 stm r6, {r3, r9}
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000b50c: e1a01006 mov r1, r6 3000b510: e1a03007 mov r3, r7 3000b514: ebffff0f bl 3000b158 <_Heap_Block_split> 3000b518: e1a04006 mov r4, r6
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000b51c: e5953030 ldr r3, [r5, #48] ; 0x30 3000b520: e5952034 ldr r2, [r5, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000b524: e1a00004 mov r0, r4
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000b528: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000b52c: 85853034 strhi r3, [r5, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000b530: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
3000b158 <_Heap_Block_split>:
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000b158: 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;
3000b15c: e5908014 ldr r8, [r0, #20]
uintptr_t alloc_size
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
3000b160: 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;
3000b164: 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;
3000b168: e153000b cmp r3, fp 3000b16c: 21a0b003 movcs fp, r3
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const used_size =
3000b170: e28bb008 add fp, fp, #8
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000b174: 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;
3000b178: e5919004 ldr r9, [r1, #4] 3000b17c: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000b180: e1a0100a mov r1, sl 3000b184: e1a0000b mov r0, fp 3000b188: e1a06002 mov r6, r2 3000b18c: eb003e2d bl 3001aa48 <__umodsi3> 3000b190: e3c97001 bic r7, r9, #1
if ( remainder != 0 ) {
3000b194: 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;
3000b198: e2872004 add r2, r7, #4
return value - remainder + alignment;
3000b19c: 108ba00a addne sl, fp, sl
} else {
return value;
3000b1a0: 01a0a00b moveq sl, fp
uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS;
3000b1a4: 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;
3000b1a8: e06bb002 rsb fp, fp, r2
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
3000b1ac: 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);
3000b1b0: 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 ) {
3000b1b4: 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;
3000b1b8: 35932004 ldrcc r2, [r3, #4] 3000b1bc: 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 ) {
3000b1c0: 3a000023 bcc 3000b254 <_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;
3000b1c4: 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;
3000b1c8: 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;
3000b1cc: 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);
3000b1d0: 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;
3000b1d4: e18aa009 orr sl, sl, r9 3000b1d8: 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;
3000b1dc: e0811007 add r1, r1, r7 3000b1e0: 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;
3000b1e4: e5931004 ldr r1, [r3, #4] 3000b1e8: 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;
3000b1ec: e0830001 add r0, r3, r1 3000b1f0: e5900004 ldr r0, [r0, #4]
if ( _Heap_Is_used( next_block ) ) {
3000b1f4: e3100001 tst r0, #1
3000b1f8: 0a000008 beq 3000b220 <_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;
3000b1fc: e5961008 ldr r1, [r6, #8]
new_block->next = next;
new_block->prev = block_before;
3000b200: e582600c str r6, [r2, #12]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
3000b204: e5821008 str r1, [r2, #8]
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
3000b208: e581200c str r2, [r1, #12]
_Heap_Free_list_insert_after( free_list_anchor, free_block );
/* Statistics */
++stats->free_blocks;
3000b20c: 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;
3000b210: e5862008 str r2, [r6, #8] 3000b214: e2811001 add r1, r1, #1 3000b218: e5841038 str r1, [r4, #56] ; 0x38 3000b21c: ea000007 b 3000b240 <_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;
3000b220: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
Heap_Block *prev = old_block->prev;
3000b224: 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;
3000b228: e0877001 add r7, r7, r1 <== NOT EXECUTED
new_block->next = next;
new_block->prev = prev;
3000b22c: e582300c str r3, [r2, #12] <== NOT EXECUTED
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3000b230: e5820008 str r0, [r2, #8] <== NOT EXECUTED
new_block->prev = prev;
next->prev = new_block;
3000b234: e580200c str r2, [r0, #12] <== NOT EXECUTED
prev->next = new_block;
3000b238: 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);
3000b23c: 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;
3000b240: e3871001 orr r1, r7, #1 3000b244: e5821004 str r1, [r2, #4]
next_block->prev_size = free_block_size;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000b248: 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;
3000b24c: e5837000 str r7, [r3]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000b250: e3c22001 bic r2, r2, #1
_Heap_Protection_block_initialize( heap, free_block );
} else {
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000b254: e5832004 str r2, [r3, #4]
3000b258: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000fbb0 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
3000fbb0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3000fbb4: e1a05001 mov r5, r1 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
3000fbb8: 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))
)
{
3000fbbc: 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;
3000fbc0: 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;
3000fbc4: 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;
3000fbc8: 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;
3000fbcc: 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 ) {
3000fbd0: 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))
)
{
3000fbd4: 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;
3000fbd8: 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;
3000fbdc: 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;
3000fbe0: 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;
3000fbe4: 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;
3000fbe8: 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;
3000fbec: 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 ) {
3000fbf0: 2a000099 bcs 3000fe5c <_Heap_Extend+0x2ac> <== NOT EXECUTED
return 0;
}
extend_area_ok = _Heap_Get_first_and_last_block(
3000fbf4: e28d101c add r1, sp, #28 <== NOT EXECUTED 3000fbf8: e58d1000 str r1, [sp] <== NOT EXECUTED 3000fbfc: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000fc00: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3000fc04: e1a00005 mov r0, r5 <== NOT EXECUTED 3000fc08: e1a01002 mov r1, r2 <== NOT EXECUTED 3000fc0c: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 3000fc10: ebffeda8 bl 3000b2b8 <_Heap_Get_first_and_last_block> <== NOT EXECUTED
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
3000fc14: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fc18: 0a00008f beq 3000fe5c <_Heap_Extend+0x2ac> <== NOT EXECUTED 3000fc1c: e59da010 ldr sl, [sp, #16] <== NOT EXECUTED 3000fc20: e1a07008 mov r7, r8 <== NOT EXECUTED 3000fc24: 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;
3000fc28: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED 3000fc2c: e1a03008 mov r3, r8 <== NOT EXECUTED 3000fc30: e1a0c004 mov ip, r4 <== NOT EXECUTED 3000fc34: ea000000 b 3000fc3c <_Heap_Extend+0x8c> <== NOT EXECUTED 3000fc38: e1a0100a mov r1, sl <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
3000fc3c: e59a4000 ldr r4, [sl] <== NOT EXECUTED
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
3000fc40: e1560001 cmp r6, r1 <== NOT EXECUTED 3000fc44: 93a00000 movls r0, #0 <== NOT EXECUTED 3000fc48: 83a00001 movhi r0, #1 <== NOT EXECUTED 3000fc4c: e1550004 cmp r5, r4 <== NOT EXECUTED 3000fc50: 23a00000 movcs r0, #0 <== NOT EXECUTED 3000fc54: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fc58: 1a00007e bne 3000fe58 <_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 ) {
3000fc5c: e1560001 cmp r6, r1 <== NOT EXECUTED 3000fc60: 01a0300a moveq r3, sl <== NOT EXECUTED 3000fc64: 0a000001 beq 3000fc70 <_Heap_Extend+0xc0> <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
3000fc68: e1560004 cmp r6, r4 <== NOT EXECUTED 3000fc6c: 31a0900a movcc r9, sl <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000fc70: e1a00004 mov r0, r4 <== NOT EXECUTED 3000fc74: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 3000fc78: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000fc7c: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 3000fc80: eb002c3a bl 3001ad70 <__umodsi3> <== NOT EXECUTED 3000fc84: e244b008 sub fp, r4, #8 <== NOT EXECUTED
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
3000fc88: 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);
3000fc8c: e060000b rsb r0, r0, fp <== NOT EXECUTED 3000fc90: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3000fc94: 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 )
3000fc98: 01a07000 moveq r7, r0 <== NOT EXECUTED
start_block->prev_size = extend_area_end;
3000fc9c: 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 ) {
3000fca0: 0a000000 beq 3000fca8 <_Heap_Extend+0xf8> <== NOT EXECUTED 3000fca4: 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;
3000fca8: 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 );
3000fcac: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000fcb0: 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);
3000fcb4: e080a00a add sl, r0, sl <== NOT EXECUTED 3000fcb8: e15a0002 cmp sl, r2 <== NOT EXECUTED 3000fcbc: 1affffdd bne 3000fc38 <_Heap_Extend+0x88> <== NOT EXECUTED 3000fcc0: e1a02009 mov r2, r9 <== NOT EXECUTED 3000fcc4: e1a09003 mov r9, r3 <== NOT EXECUTED
if ( extend_area_begin < heap->area_begin ) {
3000fcc8: e59c3018 ldr r3, [ip, #24] <== NOT EXECUTED 3000fccc: e1a0400c mov r4, ip <== NOT EXECUTED 3000fcd0: e1550003 cmp r5, r3 <== NOT EXECUTED
heap->area_begin = extend_area_begin;
3000fcd4: 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 ) {
3000fcd8: 3a000002 bcc 3000fce8 <_Heap_Extend+0x138> <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
3000fcdc: e59c301c ldr r3, [ip, #28] <== NOT EXECUTED 3000fce0: e1530006 cmp r3, r6 <== NOT EXECUTED
heap->area_end = extend_area_end;
3000fce4: 358c601c strcc r6, [ip, #28] <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
3000fce8: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3000fcec: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
extend_first_block->prev_size = extend_area_end;
3000fcf0: 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 =
3000fcf4: 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;
3000fcf8: e380c001 orr ip, r0, #1 <== NOT EXECUTED
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
3000fcfc: e5830000 str r0, [r3] <== NOT EXECUTED
extend_last_block->size_and_flag = 0;
3000fd00: 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 =
3000fd04: 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;
3000fd08: 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 ) {
3000fd0c: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED 3000fd10: e1500001 cmp r0, r1 <== NOT EXECUTED
heap->first_block = extend_first_block;
3000fd14: 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 ) {
3000fd18: 8a000002 bhi 3000fd28 <_Heap_Extend+0x178> <== NOT EXECUTED
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
3000fd1c: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000fd20: e1510003 cmp r1, r3 <== NOT EXECUTED
heap->last_block = extend_last_block;
3000fd24: 35843024 strcc r3, [r4, #36] ; 0x24 <== NOT EXECUTED
}
if ( merge_below_block != NULL ) {
3000fd28: e3590000 cmp r9, #0 <== NOT EXECUTED 3000fd2c: 0a000010 beq 3000fd74 <_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;
3000fd30: 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 );
3000fd34: 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;
3000fd38: e1a00005 mov r0, r5 <== NOT EXECUTED 3000fd3c: e1a0100a mov r1, sl <== NOT EXECUTED 3000fd40: eb002c0a bl 3001ad70 <__umodsi3> <== NOT EXECUTED
if ( remainder != 0 ) {
3000fd44: e3500000 cmp r0, #0 <== NOT EXECUTED
return value - remainder + alignment;
3000fd48: 1085500a addne r5, r5, sl <== NOT EXECUTED 3000fd4c: 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;
3000fd50: 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 =
3000fd54: 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;
3000fd58: 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 =
3000fd5c: 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;
3000fd60: e3833001 orr r3, r3, #1 <== NOT EXECUTED 3000fd64: e5053004 str r3, [r5, #-4] <== NOT EXECUTED
_Heap_Free_block( heap, new_first_block );
3000fd68: e1a00004 mov r0, r4 <== NOT EXECUTED 3000fd6c: ebffff7a bl 3000fb5c <_Heap_Free_block> <== NOT EXECUTED 3000fd70: ea000004 b 3000fd88 <_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 ) {
3000fd74: e3520000 cmp r2, #0 <== NOT EXECUTED
_Heap_Link_below(
3000fd78: 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;
3000fd7c: 10632002 rsbne r2, r3, r2 <== NOT EXECUTED 3000fd80: 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 =
3000fd84: 15832004 strne r2, [r3, #4] <== NOT EXECUTED
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
3000fd88: e3570000 cmp r7, #0 <== NOT EXECUTED 3000fd8c: 0a000012 beq 3000fddc <_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,
3000fd90: 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(
3000fd94: 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);
3000fd98: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED 3000fd9c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000fda0: eb002bf2 bl 3001ad70 <__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)
3000fda4: e5972004 ldr r2, [r7, #4] <== NOT EXECUTED 3000fda8: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000fdac: 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 =
3000fdb0: e0863007 add r3, r6, r7 <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
3000fdb4: 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 =
3000fdb8: 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;
3000fdbc: 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 );
3000fdc0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000fdc4: e2033001 and r3, r3, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000fdc8: e1866003 orr r6, r6, r3 <== NOT EXECUTED 3000fdcc: e5876004 str r6, [r7, #4] <== NOT EXECUTED 3000fdd0: e1a01007 mov r1, r7 <== NOT EXECUTED 3000fdd4: ebffff60 bl 3000fb5c <_Heap_Free_block> <== NOT EXECUTED 3000fdd8: ea00000b b 3000fe0c <_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 ) {
3000fddc: e3580000 cmp r8, #0 <== NOT EXECUTED 3000fde0: 0a000009 beq 3000fe0c <_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;
3000fde4: 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 );
3000fde8: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3000fdec: e2022001 and r2, r2, #1 <== NOT EXECUTED 3000fdf0: 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(
3000fdf4: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
block->size_and_flag = size | flag;
3000fdf8: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000fdfc: 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;
3000fe00: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000fe04: e3822001 orr r2, r2, #1 <== NOT EXECUTED 3000fe08: e5832004 str r2, [r3, #4] <== NOT EXECUTED
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
3000fe0c: e3570000 cmp r7, #0 <== NOT EXECUTED 3000fe10: 03590000 cmpeq r9, #0 <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
3000fe14: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000fe18: 059d101c ldreq r1, [sp, #28] <== NOT EXECUTED 3000fe1c: 0bffff4e bleq 3000fb5c <_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
3000fe20: 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(
3000fe24: 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;
3000fe28: 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(
3000fe2c: 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;
3000fe30: e2022001 and r2, r2, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000fe34: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000fe38: e5832004 str r2, [r3, #4] <== NOT EXECUTED
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
3000fe3c: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 3000fe40: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3000fe44: e0630000 rsb r0, r3, r0 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
3000fe48: e594302c ldr r3, [r4, #44] ; 0x2c <== NOT EXECUTED 3000fe4c: e0833000 add r3, r3, r0 <== NOT EXECUTED 3000fe50: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return extended_size;
3000fe54: ea000000 b 3000fe5c <_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;
3000fe58: e3a00000 mov r0, #0 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
return extended_size;
}
3000fe5c: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
3000fe60: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000fb5c <_Heap_Free_block>:
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *first_free;
/* Statistics */
++stats->used_blocks;
3000fb5c: 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 )
{
3000fb60: e92d4010 push {r4, lr} <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats;
Heap_Block *first_free;
/* Statistics */
++stats->used_blocks;
3000fb64: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000fb68: e5803040 str r3, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
3000fb6c: 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 )
{
3000fb70: e1a04000 mov r4, r0 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats;
Heap_Block *first_free;
/* Statistics */
++stats->used_blocks;
--stats->frees;
3000fb74: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000fb78: 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 ) );
3000fb7c: e2811008 add r1, r1, #8 <== NOT EXECUTED 3000fb80: eb0000b7 bl 3000fe64 <_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;
3000fb84: 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;
3000fb88: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
Heap_Block *prev = block->prev;
3000fb8c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
prev->next = next;
next->prev = prev;
3000fb90: 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;
3000fb94: 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;
3000fb98: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
new_block->next = block_next;
3000fb9c: e5834008 str r4, [r3, #8] <== NOT EXECUTED
new_block->prev = prev;
3000fba0: e583200c str r2, [r3, #12] <== NOT EXECUTED
prev->next = new_block;
3000fba4: e5823008 str r3, [r2, #8] <== NOT EXECUTED
block_next->prev = new_block;
3000fba8: 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 ); }
3000fbac: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b2e8 <_Heap_Initialize>:
Heap_Control *heap,
void *heap_area_begin_ptr,
uintptr_t heap_area_size,
uintptr_t page_size
)
{
3000b2e8: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr}
3000b2ec: 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 ) {
3000b2f0: 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;
3000b2f4: e3a02000 mov r2, #0
Heap_Control *heap,
void *heap_area_begin_ptr,
uintptr_t heap_area_size,
uintptr_t page_size
)
{
3000b2f8: e1a04000 mov r4, r0 3000b2fc: 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;
3000b300: e58d2008 str r2, [sp, #8]
Heap_Block *last_block = NULL;
3000b304: e58d200c str r2, [sp, #12]
if ( page_size == 0 ) {
page_size = CPU_ALIGNMENT;
3000b308: 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 ) {
3000b30c: 0a000004 beq 3000b324 <_Heap_Initialize+0x3c>
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
3000b310: e2153007 ands r3, r5, #7
return value - remainder + alignment;
3000b314: 12855008 addne r5, r5, #8 3000b318: 10635005 rsbne r5, r3, r5
page_size = CPU_ALIGNMENT;
} else {
page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT );
if ( page_size < CPU_ALIGNMENT ) {
3000b31c: e3550007 cmp r5, #7
3000b320: 9a000034 bls 3000b3f8 <_Heap_Initialize+0x110>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000b324: e1a01005 mov r1, r5 3000b328: e3a00010 mov r0, #16 3000b32c: eb003dc5 bl 3001aa48 <__umodsi3>
if ( remainder != 0 ) {
3000b330: e3500000 cmp r0, #0
return value - remainder + alignment;
3000b334: 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(
3000b338: e28d3008 add r3, sp, #8 3000b33c: 10607007 rsbne r7, r0, r7
} else {
return value;
3000b340: 03a07010 moveq r7, #16 3000b344: e58d3000 str r3, [sp] 3000b348: e28d300c add r3, sp, #12 3000b34c: e58d3004 str r3, [sp, #4] 3000b350: e1a00006 mov r0, r6 3000b354: e1a01008 mov r1, r8 3000b358: e1a02005 mov r2, r5 3000b35c: e1a03007 mov r3, r7 3000b360: ebffffbd bl 3000b25c <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&first_block,
&last_block
);
if ( !area_ok ) {
3000b364: e3500000 cmp r0, #0
3000b368: 0a000023 beq 3000b3fc <_Heap_Initialize+0x114>
return 0;
}
memset(heap, 0, sizeof(*heap));
3000b36c: e3a01000 mov r1, #0 3000b370: e3a02058 mov r2, #88 ; 0x58 3000b374: e1a00004 mov r0, r4 3000b378: eb001beb bl 3001232c <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;
3000b37c: e59d3008 ldr r3, [sp, #8]
last_block_begin = (uintptr_t) last_block;
3000b380: 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;
3000b384: 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;
3000b388: 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;
3000b38c: 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;
3000b390: e5838000 str r8, [r3]
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; first_block->next = _Heap_Free_list_tail( heap );
3000b394: e9830012 stmib r3, {r1, r4}
first_block->prev = _Heap_Free_list_head( heap );
3000b398: 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;
3000b39c: 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;
3000b3a0: 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;
3000b3a4: 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(
3000b3a8: 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;
3000b3ac: 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;
3000b3b0: e5845010 str r5, [r4, #16]
heap->min_block_size = min_block_size;
3000b3b4: e5847014 str r7, [r4, #20]
heap->area_begin = heap_area_begin;
3000b3b8: e5846018 str r6, [r4, #24]
heap->area_end = heap_area_end;
3000b3bc: 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;
3000b3c0: 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;
3000b3c4: 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;
3000b3c8: 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;
3000b3cc: e5843038 str r3, [r4, #56] ; 0x38
stats->max_free_blocks = 1;
3000b3d0: e584303c str r3, [r4, #60] ; 0x3c
stats->instance = instance++;
3000b3d4: e59f3028 ldr r3, [pc, #40] ; 3000b404 <_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;
3000b3d8: 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++;
3000b3dc: 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;
3000b3e0: 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++;
3000b3e4: e5842028 str r2, [r4, #40] ; 0x28 3000b3e8: 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;
3000b3ec: e5840034 str r0, [r4, #52] ; 0x34
stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++;
3000b3f0: e5832000 str r2, [r3]
);
_HAssert(
_Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size )
);
return first_block_size;
3000b3f4: ea000000 b 3000b3fc <_Heap_Initialize+0x114>
} else {
page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT );
if ( page_size < CPU_ALIGNMENT ) {
/* Integer overflow */
return 0;
3000b3f8: e3a00000 mov r0, #0 <== NOT EXECUTED
_HAssert(
_Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size )
);
return first_block_size;
}
3000b3fc: e28dd010 add sp, sp, #16
3000b400: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000f7e4 <_Heap_No_extend>:
uintptr_t unused_2 __attribute__((unused)),
uintptr_t unused_3 __attribute__((unused))
)
{
return 0;
}
3000f7e4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000f7e8: e12fff1e bx lr <== NOT EXECUTED
3000fd2c <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
3000fd2c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000fd30: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000fd34: e241a008 sub sl, r1, #8 3000fd38: e1a00001 mov r0, r1 3000fd3c: e1a05001 mov r5, r1 3000fd40: e5941010 ldr r1, [r4, #16] 3000fd44: e1a08003 mov r8, r3 3000fd48: e1a07002 mov r7, r2 3000fd4c: eb002b3d bl 3001aa48 <__umodsi3> 3000fd50: 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;
3000fd54: e3a03000 mov r3, #0 3000fd58: e5883000 str r3, [r8]
*new_size = 0;
3000fd5c: 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;
3000fd60: 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);
3000fd64: 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;
3000fd68: e1530001 cmp r3, r1
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
3000fd6c: 83a00002 movhi r0, #2
3000fd70: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
3000fd74: e5943024 ldr r3, [r4, #36] ; 0x24
3000fd78: e1530001 cmp r3, r1
3000fd7c: 3a000035 bcc 3000fe58 <_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;
3000fd80: 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;
3000fd84: e265c004 rsb ip, r5, #4 3000fd88: 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;
3000fd8c: e0812003 add r2, r1, r3 3000fd90: e5920004 ldr r0, [r2, #4]
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
3000fd94: e08cc002 add ip, ip, r2 3000fd98: 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;
3000fd9c: e082a000 add sl, r2, r0 3000fda0: 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;
3000fda4: e588c000 str ip, [r8]
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
3000fda8: e31a0001 tst sl, #1 3000fdac: 13a0a000 movne sl, #0 3000fdb0: 03a0a001 moveq sl, #1
if ( next_block_is_free ) {
3000fdb4: e35a0000 cmp sl, #0
block_size += next_block_size;
alloc_size += next_block_size;
3000fdb8: 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;
3000fdbc: 10833000 addne r3, r3, r0
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
3000fdc0: e157000c cmp r7, ip
return HEAP_RESIZE_UNSATISFIED;
3000fdc4: 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 ) {
3000fdc8: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
3000fdcc: e35a0000 cmp sl, #0
3000fdd0: 0a000011 beq 3000fe1c <_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;
3000fdd4: e591c004 ldr ip, [r1, #4] <== NOT EXECUTED 3000fdd8: e20cc001 and ip, ip, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000fddc: e183c00c orr ip, r3, ip <== NOT EXECUTED 3000fde0: e581c004 str ip, [r1, #4] <== NOT EXECUTED
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
3000fde4: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
Heap_Block *prev = block->prev;
3000fde8: e592200c ldr r2, [r2, #12] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000fdec: e0833001 add r3, r3, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
3000fdf0: e582c008 str ip, [r2, #8] <== NOT EXECUTED
next->prev = prev;
3000fdf4: e58c200c str r2, [ip, #12] <== NOT EXECUTED
_Heap_Block_set_size( block, block_size );
_Heap_Free_list_remove( next_block );
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000fdf8: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000fdfc: e3822001 orr r2, r2, #1 <== NOT EXECUTED 3000fe00: e5832004 str r2, [r3, #4] <== NOT EXECUTED
/* Statistics */
--stats->free_blocks;
3000fe04: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 3000fe08: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000fe0c: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
stats->free_size -= next_block_size;
3000fe10: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED 3000fe14: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 3000fe18: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
3000fe1c: e1a02005 mov r2, r5 3000fe20: e1a03007 mov r3, r7 3000fe24: e1a00004 mov r0, r4 3000fe28: ebffed76 bl 3000b408 <_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;
3000fe2c: e5903004 ldr r3, [r0, #4] 3000fe30: 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);
3000fe34: 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;
3000fe38: e0655003 rsb r5, r5, r3 3000fe3c: e0800005 add r0, r0, r5 3000fe40: e5860000 str r0, [r6]
/* Statistics */
++stats->resizes;
3000fe44: e5943054 ldr r3, [r4, #84] ; 0x54
return HEAP_RESIZE_SUCCESSFUL;
3000fe48: 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;
3000fe4c: e2833001 add r3, r3, #1
3000fe50: e5843054 str r3, [r4, #84] ; 0x54
3000fe54: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
3000fe58: e3a00002 mov r0, #2 <== NOT EXECUTED
}
3000fe5c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000bef0 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000bef0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
uintptr_t const page_size = heap->page_size;
3000bef4: e590c010 ldr ip, [r0, #16] <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000bef8: 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;
3000befc: e59f34f0 ldr r3, [pc, #1264] ; 3000c3f4 <_Heap_Walk+0x504> <== NOT EXECUTED 3000bf00: e59f84f0 ldr r8, [pc, #1264] ; 3000c3f8 <_Heap_Walk+0x508> <== NOT EXECUTED 3000bf04: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
3000bf08: e58dc020 str ip, [sp, #32] <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
3000bf0c: 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;
3000bf10: 11a08003 movne r8, r3 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000bf14: e59f34e0 ldr r3, [pc, #1248] ; 3000c3fc <_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;
3000bf18: e58dc028 str ip, [sp, #40] ; 0x28 <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block;
3000bf1c: 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() ) ) {
3000bf20: 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;
3000bf24: e58dc024 str ip, [sp, #36] ; 0x24 <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
3000bf28: 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() ) ) {
3000bf2c: e3530003 cmp r3, #3 <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000bf30: e1a05000 mov r5, r0 <== NOT EXECUTED 3000bf34: 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;
3000bf38: 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() ) ) {
3000bf3c: 1a000120 bne 3000c3c4 <_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)(
3000bf40: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bf44: e59f24b4 ldr r2, [pc, #1204] ; 3000c400 <_Heap_Walk+0x510> <== NOT EXECUTED 3000bf48: e58dc000 str ip, [sp] <== NOT EXECUTED 3000bf4c: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED 3000bf50: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bf54: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000bf58: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3000bf5c: e58dc00c str ip, [sp, #12] <== NOT EXECUTED 3000bf60: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000bf64: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000bf68: e58dc010 str ip, [sp, #16] <== NOT EXECUTED 3000bf6c: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED 3000bf70: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 3000bf74: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000bf78: e1a00001 mov r0, r1 <== NOT EXECUTED 3000bf7c: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000bf80: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bf84: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3000bf88: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf8c: 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 ) {
3000bf90: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000bf94: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000bf98: 1a000006 bne 3000bfb8 <_Heap_Walk+0xc8> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
3000bf9c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bfa0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bfa4: e59f2458 ldr r2, [pc, #1112] ; 3000c404 <_Heap_Walk+0x514> <== NOT EXECUTED 3000bfa8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bfac: 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;
3000bfb0: e59d6020 ldr r6, [sp, #32] <== NOT EXECUTED 3000bfb4: ea000103 b 3000c3c8 <_Heap_Walk+0x4d8> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
3000bfb8: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000bfbc: e21c7007 ands r7, ip, #7 <== NOT EXECUTED
(*printer)(
3000bfc0: 11a00004 movne r0, r4 <== NOT EXECUTED 3000bfc4: 13a01001 movne r1, #1 <== NOT EXECUTED 3000bfc8: 159f2438 ldrne r2, [pc, #1080] ; 3000c408 <_Heap_Walk+0x518><== NOT EXECUTED 3000bfcc: 11a0300c movne r3, ip <== NOT EXECUTED 3000bfd0: 1a000103 bne 3000c3e4 <_Heap_Walk+0x4f4> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bfd4: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bfd8: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000bfdc: ebffe428 bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
3000bfe0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000bfe4: 0a000006 beq 3000c004 <_Heap_Walk+0x114> <== NOT EXECUTED
(*printer)(
3000bfe8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bfec: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bff0: e59f2414 ldr r2, [pc, #1044] ; 3000c40c <_Heap_Walk+0x51c> <== NOT EXECUTED 3000bff4: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bff8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bffc: e12fff18 bx r8 <== NOT EXECUTED 3000c000: ea000025 b 3000c09c <_Heap_Walk+0x1ac> <== NOT EXECUTED 3000c004: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c008: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000c00c: e28c0008 add r0, ip, #8 <== NOT EXECUTED 3000c010: ebffe41b bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000c014: e2507000 subs r7, r0, #0 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
3000c018: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c01c: 13a01001 movne r1, #1 <== NOT EXECUTED 3000c020: 159f23e8 ldrne r2, [pc, #1000] ; 3000c410 <_Heap_Walk+0x520><== NOT EXECUTED 3000c024: 159d3024 ldrne r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c028: 1a000041 bne 3000c134 <_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;
3000c02c: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c030: e59c6004 ldr r6, [ip, #4] <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
3000c034: e2166001 ands r6, r6, #1 <== NOT EXECUTED
(*printer)(
3000c038: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000c03c: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000c040: 059f23cc ldreq r2, [pc, #972] ; 3000c414 <_Heap_Walk+0x524><== NOT EXECUTED 3000c044: 0a000009 beq 3000c070 <_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;
3000c048: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000c04c: e59ca004 ldr sl, [ip, #4] <== NOT EXECUTED 3000c050: 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);
3000c054: 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;
3000c058: e59a6004 ldr r6, [sl, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
3000c05c: e2166001 ands r6, r6, #1 <== NOT EXECUTED 3000c060: 1a000005 bne 3000c07c <_Heap_Walk+0x18c> <== NOT EXECUTED
(*printer)(
3000c064: e59f23ac ldr r2, [pc, #940] ; 3000c418 <_Heap_Walk+0x528> <== NOT EXECUTED 3000c068: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c06c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c070: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c074: e12fff18 bx r8 <== NOT EXECUTED 3000c078: ea0000d2 b 3000c3c8 <_Heap_Walk+0x4d8> <== NOT EXECUTED
);
return false;
}
if (
3000c07c: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c080: e15a000c cmp sl, ip <== NOT EXECUTED 3000c084: 0a000006 beq 3000c0a4 <_Heap_Walk+0x1b4> <== NOT EXECUTED
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
3000c088: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c08c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c090: e59f2384 ldr r2, [pc, #900] ; 3000c41c <_Heap_Walk+0x52c> <== NOT EXECUTED 3000c094: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c098: 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;
3000c09c: e1a06007 mov r6, r7 <== NOT EXECUTED 3000c0a0: ea0000c8 b 3000c3c8 <_Heap_Walk+0x4d8> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
3000c0a4: 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;
3000c0a8: e5959008 ldr r9, [r5, #8] <== NOT EXECUTED
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
3000c0ac: e1a0b005 mov fp, r5 <== NOT EXECUTED 3000c0b0: ea000032 b 3000c180 <_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;
3000c0b4: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 3000c0b8: e1530009 cmp r3, r9 <== NOT EXECUTED 3000c0bc: 83a06000 movhi r6, #0 <== NOT EXECUTED 3000c0c0: 8a000003 bhi 3000c0d4 <_Heap_Walk+0x1e4> <== NOT EXECUTED 3000c0c4: e5956024 ldr r6, [r5, #36] ; 0x24 <== NOT EXECUTED 3000c0c8: e1560009 cmp r6, r9 <== NOT EXECUTED 3000c0cc: 33a06000 movcc r6, #0 <== NOT EXECUTED 3000c0d0: 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 ) ) {
3000c0d4: e21660ff ands r6, r6, #255 ; 0xff <== NOT EXECUTED
(*printer)(
3000c0d8: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000c0dc: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000c0e0: 059f2338 ldreq r2, [pc, #824] ; 3000c420 <_Heap_Walk+0x530><== NOT EXECUTED 3000c0e4: 0a000011 beq 3000c130 <_Heap_Walk+0x240> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000c0e8: e2890008 add r0, r9, #8 <== NOT EXECUTED 3000c0ec: e1a01007 mov r1, r7 <== NOT EXECUTED 3000c0f0: ebffe3e3 bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000c0f4: e2506000 subs r6, r0, #0 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
3000c0f8: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c0fc: 13a01001 movne r1, #1 <== NOT EXECUTED 3000c100: 159f231c ldrne r2, [pc, #796] ; 3000c424 <_Heap_Walk+0x534><== NOT EXECUTED 3000c104: 11a03009 movne r3, r9 <== NOT EXECUTED 3000c108: 1a0000b5 bne 3000c3e4 <_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;
3000c10c: e5993004 ldr r3, [r9, #4] <== NOT EXECUTED 3000c110: 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;
3000c114: e0893003 add r3, r9, r3 <== NOT EXECUTED 3000c118: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000c11c: e21cc001 ands ip, ip, #1 <== NOT EXECUTED 3000c120: 0a000006 beq 3000c140 <_Heap_Walk+0x250> <== NOT EXECUTED
(*printer)(
3000c124: e59f22fc ldr r2, [pc, #764] ; 3000c428 <_Heap_Walk+0x538> <== NOT EXECUTED 3000c128: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c12c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c130: e1a03009 mov r3, r9 <== NOT EXECUTED 3000c134: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c138: e12fff18 bx r8 <== NOT EXECUTED 3000c13c: ea0000a1 b 3000c3c8 <_Heap_Walk+0x4d8> <== NOT EXECUTED
);
return false;
}
if ( free_block->prev != prev_block ) {
3000c140: e599300c ldr r3, [r9, #12] <== NOT EXECUTED 3000c144: e153000b cmp r3, fp <== NOT EXECUTED 3000c148: 0a00000a beq 3000c178 <_Heap_Walk+0x288> <== NOT EXECUTED
(*printer)(
3000c14c: e58d3000 str r3, [sp] <== NOT EXECUTED 3000c150: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000c154: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c158: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c15c: e59f22c8 ldr r2, [pc, #712] ; 3000c42c <_Heap_Walk+0x53c> <== NOT EXECUTED 3000c160: e1a03009 mov r3, r9 <== NOT EXECUTED 3000c164: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c168: 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;
3000c16c: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 3000c170: e1a0600c mov r6, ip <== NOT EXECUTED 3000c174: ea000093 b 3000c3c8 <_Heap_Walk+0x4d8> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
3000c178: e1a0b009 mov fp, r9 <== NOT EXECUTED 3000c17c: 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 ) {
3000c180: e1590005 cmp r9, r5 <== NOT EXECUTED 3000c184: 1affffca bne 3000c0b4 <_Heap_Walk+0x1c4> <== NOT EXECUTED 3000c188: ea000000 b 3000c190 <_Heap_Walk+0x2a0> <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000c18c: 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;
3000c190: 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;
3000c194: 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;
3000c198: 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);
3000c19c: 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;
3000c1a0: e1530009 cmp r3, r9 <== NOT EXECUTED 3000c1a4: 83a03000 movhi r3, #0 <== NOT EXECUTED 3000c1a8: 8a000003 bhi 3000c1bc <_Heap_Walk+0x2cc> <== NOT EXECUTED 3000c1ac: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED 3000c1b0: e1530009 cmp r3, r9 <== NOT EXECUTED 3000c1b4: 33a03000 movcc r3, #0 <== NOT EXECUTED 3000c1b8: 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 ) ) {
3000c1bc: e21330ff ands r3, r3, #255 ; 0xff <== NOT EXECUTED 3000c1c0: 1a000008 bne 3000c1e8 <_Heap_Walk+0x2f8> <== NOT EXECUTED 3000c1c4: e1a06003 mov r6, r3 <== NOT EXECUTED
(*printer)(
3000c1c8: e58d9000 str r9, [sp] <== NOT EXECUTED 3000c1cc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c1d0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c1d4: e59f2254 ldr r2, [pc, #596] ; 3000c430 <_Heap_Walk+0x540> <== NOT EXECUTED 3000c1d8: e1a0300a mov r3, sl <== NOT EXECUTED 3000c1dc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c1e0: e12fff18 bx r8 <== NOT EXECUTED
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
3000c1e4: ea000077 b 3000c3c8 <_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;
3000c1e8: 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;
3000c1ec: e1a0000b mov r0, fp <== NOT EXECUTED 3000c1f0: e05a700c subs r7, sl, ip <== NOT EXECUTED 3000c1f4: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000c1f8: 13a07001 movne r7, #1 <== NOT EXECUTED 3000c1fc: ebffe3a0 bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
3000c200: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c204: 0a000005 beq 3000c220 <_Heap_Walk+0x330> <== NOT EXECUTED 3000c208: e3570000 cmp r7, #0 <== NOT EXECUTED
(*printer)(
3000c20c: 158db000 strne fp, [sp] <== NOT EXECUTED 3000c210: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c214: 13a01001 movne r1, #1 <== NOT EXECUTED 3000c218: 159f2214 ldrne r2, [pc, #532] ; 3000c434 <_Heap_Walk+0x544><== NOT EXECUTED 3000c21c: 1a000014 bne 3000c274 <_Heap_Walk+0x384> <== NOT EXECUTED
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
3000c220: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3000c224: e15b000c cmp fp, ip <== NOT EXECUTED 3000c228: 2a000009 bcs 3000c254 <_Heap_Walk+0x364> <== NOT EXECUTED 3000c22c: e3570000 cmp r7, #0 <== NOT EXECUTED 3000c230: 0a000007 beq 3000c254 <_Heap_Walk+0x364> <== NOT EXECUTED
(*printer)(
3000c234: e88d1800 stm sp, {fp, ip} <== NOT EXECUTED
3000c238: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c23c: e3a01001 mov r1, #1 <== NOT EXECUTED
3000c240: e59f21f0 ldr r2, [pc, #496] ; 3000c438 <_Heap_Walk+0x548> <== NOT EXECUTED
3000c244: e1a0300a mov r3, sl <== NOT EXECUTED
3000c248: e1a0e00f mov lr, pc <== NOT EXECUTED
3000c24c: e12fff18 bx r8 <== NOT EXECUTED
3000c250: ea000065 b 3000c3ec <_Heap_Walk+0x4fc> <== NOT EXECUTED
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
3000c254: e159000a cmp r9, sl <== NOT EXECUTED 3000c258: 8a000009 bhi 3000c284 <_Heap_Walk+0x394> <== NOT EXECUTED 3000c25c: e3570000 cmp r7, #0 <== NOT EXECUTED 3000c260: 0a000007 beq 3000c284 <_Heap_Walk+0x394> <== NOT EXECUTED
(*printer)(
3000c264: e59f21d0 ldr r2, [pc, #464] ; 3000c43c <_Heap_Walk+0x54c> <== NOT EXECUTED 3000c268: e58d9000 str r9, [sp] <== NOT EXECUTED 3000c26c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c270: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c274: e1a0300a mov r3, sl <== NOT EXECUTED 3000c278: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c27c: e12fff18 bx r8 <== NOT EXECUTED 3000c280: ea000059 b 3000c3ec <_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;
3000c284: e5993004 ldr r3, [r9, #4] <== NOT EXECUTED 3000c288: e2066001 and r6, r6, #1 <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
3000c28c: e3130001 tst r3, #1 <== NOT EXECUTED 3000c290: 1a000036 bne 3000c370 <_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 ?
3000c294: 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)(
3000c298: 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;
3000c29c: e595100c ldr r1, [r5, #12] <== NOT EXECUTED 3000c2a0: e1520003 cmp r2, r3 <== NOT EXECUTED 3000c2a4: 059f0194 ldreq r0, [pc, #404] ; 3000c440 <_Heap_Walk+0x550><== NOT EXECUTED 3000c2a8: 0a000003 beq 3000c2bc <_Heap_Walk+0x3cc> <== NOT EXECUTED
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
3000c2ac: e59f3190 ldr r3, [pc, #400] ; 3000c444 <_Heap_Walk+0x554> <== NOT EXECUTED 3000c2b0: e1520005 cmp r2, r5 <== NOT EXECUTED 3000c2b4: e59f018c ldr r0, [pc, #396] ; 3000c448 <_Heap_Walk+0x558> <== NOT EXECUTED 3000c2b8: 11a00003 movne r0, r3 <== NOT EXECUTED
block->next,
block->next == last_free_block ?
3000c2bc: 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)(
3000c2c0: e1530001 cmp r3, r1 <== NOT EXECUTED 3000c2c4: 059f1180 ldreq r1, [pc, #384] ; 3000c44c <_Heap_Walk+0x55c><== NOT EXECUTED 3000c2c8: 0a000003 beq 3000c2dc <_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)" : "")
3000c2cc: e59fc17c ldr ip, [pc, #380] ; 3000c450 <_Heap_Walk+0x560> <== NOT EXECUTED 3000c2d0: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c2d4: e59f1168 ldr r1, [pc, #360] ; 3000c444 <_Heap_Walk+0x554> <== NOT EXECUTED 3000c2d8: 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)(
3000c2dc: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000c2e0: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000c2e4: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000c2e8: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000c2ec: e1a0300a mov r3, sl <== NOT EXECUTED 3000c2f0: e58db000 str fp, [sp] <== NOT EXECUTED 3000c2f4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c2f8: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c2fc: e59f2150 ldr r2, [pc, #336] ; 3000c454 <_Heap_Walk+0x564> <== NOT EXECUTED 3000c300: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c304: 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 ) {
3000c308: e5993000 ldr r3, [r9] <== NOT EXECUTED 3000c30c: e15b0003 cmp fp, r3 <== NOT EXECUTED 3000c310: 0a000008 beq 3000c338 <_Heap_Walk+0x448> <== NOT EXECUTED
(*printer)(
3000c314: e98d0208 stmib sp, {r3, r9} <== NOT EXECUTED
3000c318: e58db000 str fp, [sp] <== NOT EXECUTED
3000c31c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c320: e3a01001 mov r1, #1 <== NOT EXECUTED
3000c324: e59f212c ldr r2, [pc, #300] ; 3000c458 <_Heap_Walk+0x568> <== NOT EXECUTED
3000c328: e1a0300a mov r3, sl <== NOT EXECUTED
3000c32c: e1a0e00f mov lr, pc <== NOT EXECUTED
3000c330: e12fff18 bx r8 <== NOT EXECUTED
3000c334: ea00002c b 3000c3ec <_Heap_Walk+0x4fc> <== NOT EXECUTED
);
return false;
}
if ( !prev_used ) {
3000c338: e3560000 cmp r6, #0 <== NOT EXECUTED
(*printer)(
3000c33c: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000c340: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000c344: 059f2110 ldreq r2, [pc, #272] ; 3000c45c <_Heap_Walk+0x56c><== NOT EXECUTED 3000c348: 01a0300a moveq r3, sl <== NOT EXECUTED 3000c34c: 0affff78 beq 3000c134 <_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;
3000c350: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c354: ea000002 b 3000c364 <_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 ) {
3000c358: e153000a cmp r3, sl <== NOT EXECUTED 3000c35c: 0a000015 beq 3000c3b8 <_Heap_Walk+0x4c8> <== NOT EXECUTED
return true;
}
free_block = free_block->next;
3000c360: 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 ) {
3000c364: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c368: 1afffffa bne 3000c358 <_Heap_Walk+0x468> <== NOT EXECUTED 3000c36c: ea000018 b 3000c3d4 <_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) {
3000c370: e3560000 cmp r6, #0 <== NOT EXECUTED
(*printer)(
3000c374: 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) {
3000c378: 0a000006 beq 3000c398 <_Heap_Walk+0x4a8> <== NOT EXECUTED
(*printer)(
3000c37c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c380: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c384: e59f20d4 ldr r2, [pc, #212] ; 3000c460 <_Heap_Walk+0x570> <== NOT EXECUTED 3000c388: e1a0300a mov r3, sl <== NOT EXECUTED 3000c38c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c390: e12fff18 bx r8 <== NOT EXECUTED 3000c394: ea000007 b 3000c3b8 <_Heap_Walk+0x4c8> <== NOT EXECUTED
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
3000c398: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3000c39c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c3a0: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000c3a4: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c3a8: e59f20b4 ldr r2, [pc, #180] ; 3000c464 <_Heap_Walk+0x574> <== NOT EXECUTED 3000c3ac: e1a0300a mov r3, sl <== NOT EXECUTED 3000c3b0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c3b4: e12fff18 bx r8 <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000c3b8: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c3bc: e159000c cmp r9, ip <== NOT EXECUTED 3000c3c0: 1affff71 bne 3000c18c <_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;
3000c3c4: e3a06001 mov r6, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000c3c8: e1a00006 mov r0, r6 <== NOT EXECUTED
3000c3cc: e28dd030 add sp, sp, #48 ; 0x30 <== NOT EXECUTED
3000c3d0: 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)(
3000c3d4: e59f208c ldr r2, [pc, #140] ; 3000c468 <_Heap_Walk+0x578> <== NOT EXECUTED 3000c3d8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c3dc: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c3e0: e1a0300a mov r3, sl <== NOT EXECUTED 3000c3e4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c3e8: 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;
3000c3ec: e3a06000 mov r6, #0 <== NOT EXECUTED 3000c3f0: eafffff4 b 3000c3c8 <_Heap_Walk+0x4d8> <== NOT EXECUTED
3000beac <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000beac: e92d000c push {r2, r3} <== NOT EXECUTED
3000beb0: e92d4001 push {r0, lr} <== NOT EXECUTED
3000beb4: e1a03000 mov r3, r0 <== NOT EXECUTED
va_list ap;
if ( error ) {
3000beb8: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
3000bebc: 159f0024 ldrne r0, [pc, #36] ; 3000bee8 <_Heap_Walk_print+0x3c><== NOT EXECUTED
} else {
printk( "PASS[%d]: ", source );
3000bec0: 059f0024 ldreq r0, [pc, #36] ; 3000beec <_Heap_Walk_print+0x40><== NOT EXECUTED 3000bec4: e1a01003 mov r1, r3 <== NOT EXECUTED 3000bec8: ebffee76 bl 300078a8 <printk> <== NOT EXECUTED
}
va_start( ap, fmt );
3000becc: e28d100c add r1, sp, #12 <== NOT EXECUTED
vprintk( fmt, ap );
3000bed0: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
3000bed4: e58d1000 str r1, [sp] <== NOT EXECUTED
vprintk( fmt, ap );
3000bed8: ebfff7fa bl 30009ec8 <vprintk> <== NOT EXECUTED
va_end( ap ); }
3000bedc: e8bd4008 pop {r3, lr} <== NOT EXECUTED
3000bee0: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000bee4: e12fff1e bx lr <== NOT EXECUTED
3000bea0 <_Heap_Walk_print_nothing>:
int source,
bool error,
const char *fmt,
...
)
{
3000bea0: e92d000c push {r2, r3} <== NOT EXECUTED
/* Do nothing */ }
3000bea4: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000bea8: e12fff1e bx lr <== NOT EXECUTED
3000b534 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000b534: e92d4007 push {r0, r1, r2, lr}
3000b538: e20160ff and r6, r1, #255 ; 0xff
3000b53c: e1a04000 mov r4, r0
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
3000b540: e58d0000 str r0, [sp]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
3000b544: e59f1040 ldr r1, [pc, #64] ; 3000b58c <_Internal_error_Occurred+0x58> 3000b548: e1a0000d mov r0, sp 3000b54c: e1a05002 mov r5, r2
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
3000b550: e58d2008 str r2, [sp, #8] 3000b554: e5cd6004 strb r6, [sp, #4]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
3000b558: eb00076e bl 3000d318 <_User_extensions_Iterate>
_User_extensions_Fatal( the_source, is_internal, the_error );
_Internal_errors_What_happened.the_source = the_source;
3000b55c: e59f302c ldr r3, [pc, #44] ; 3000b590 <_Internal_error_Occurred+0x5c><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
3000b560: e3a02005 mov r2, #5 <== NOT EXECUTED 3000b564: e5834000 str r4, [r3] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
3000b568: e5c36004 strb r6, [r3, #4] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
3000b56c: e5835008 str r5, [r3, #8] <== NOT EXECUTED 3000b570: e59f301c ldr r3, [pc, #28] ; 3000b594 <_Internal_error_Occurred+0x60><== NOT EXECUTED 3000b574: e5832000 str r2, [r3] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b578: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b57c: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b580: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
3000b584: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b588: eafffffe b 3000b588 <_Internal_error_Occurred+0x54> <== NOT EXECUTED
3000ba3c <_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;
3000ba3c: e5903008 ldr r3, [r0, #8]
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000ba40: 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;
3000ba44: e2633001 rsb r3, r3, #1
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000ba48: 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 ) {
3000ba4c: 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;
3000ba50: 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 ) {
3000ba54: 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;
3000ba58: 83a03001 movhi r3, #1 3000ba5c: 85843000 strhi r3, [r4]
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000ba60: 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 ) {
3000ba64: 8a00000b bhi 3000ba98 <_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;
3000ba68: e59f2030 ldr r2, [pc, #48] ; 3000baa0 <_Objects_Get+0x64> 3000ba6c: e5921000 ldr r1, [r2]
++level;
3000ba70: e2811001 add r1, r1, #1
_Thread_Dispatch_disable_level = level;
3000ba74: e5821000 str r1, [r2]
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000ba78: e590201c ldr r2, [r0, #28] 3000ba7c: e7925103 ldr r5, [r2, r3, lsl #2] 3000ba80: e3550000 cmp r5, #0
*location = OBJECTS_LOCAL;
3000ba84: 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 ) {
3000ba88: 1a000001 bne 3000ba94 <_Objects_Get+0x58>
/*
* Valid Id for this API, Class and Node but the object has not
* been allocated yet.
*/
_Thread_Enable_dispatch();
3000ba8c: eb000377 bl 3000c870 <_Thread_Enable_dispatch> <== NOT EXECUTED
*location = OBJECTS_ERROR;
3000ba90: e3a03001 mov r3, #1 <== NOT EXECUTED
3000ba94: e5843000 str r3, [r4]
_Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif }
3000ba98: e1a00005 mov r0, r5
3000ba9c: e8bd8030 pop {r4, r5, pc}
3000b970 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000b970: e1a01801 lsl r1, r1, #16
3000b974: e92d4030 push {r4, r5, lr}
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000b978: e1b05821 lsrs r5, r1, #16
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000b97c: e1a04000 mov r4, r0
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
3000b980: 01a00005 moveq r0, r5
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000b984: 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 );
3000b988: eb00115a bl 3000fef8 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
3000b98c: e3500000 cmp r0, #0
3000b990: 08bd8030 popeq {r4, r5, pc}
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
3000b994: e1550000 cmp r5, r0
3000b998: 8a00000a bhi 3000b9c8 <_Objects_Get_information+0x58>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
3000b99c: e59f302c ldr r3, [pc, #44] ; 3000b9d0 <_Objects_Get_information+0x60>
3000b9a0: e7930104 ldr r0, [r3, r4, lsl #2]
3000b9a4: e3500000 cmp r0, #0
3000b9a8: 08bd8030 popeq {r4, r5, pc}
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
3000b9ac: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !info )
3000b9b0: e3500000 cmp r0, #0
3000b9b4: 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 )
3000b9b8: e1d031b0 ldrh r3, [r0, #16]
return NULL;
3000b9bc: e3530000 cmp r3, #0
3000b9c0: 03a00000 moveq r0, #0
3000b9c4: 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;
3000b9c8: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
3000b9cc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b9d4 <_Objects_Get_isr_disable>:
{
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000b9d4: e590c008 ldr ip, [r0, #8]
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
3000b9d8: e92d4010 push {r4, lr}
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000b9dc: e26cc001 rsb ip, ip, #1 3000b9e0: e08c1001 add r1, ip, r1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b9e4: e10f4000 mrs r4, CPSR 3000b9e8: e384c080 orr ip, r4, #128 ; 0x80 3000b9ec: e129f00c msr CPSR_fc, ip
_ISR_Disable( level );
if ( information->maximum >= index ) {
3000b9f0: e1d0c1b0 ldrh ip, [r0, #16] 3000b9f4: e15c0001 cmp ip, r1
3000b9f8: 3a00000a bcc 3000ba28 <_Objects_Get_isr_disable+0x54>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b9fc: e590001c ldr r0, [r0, #28] 3000ba00: e7900101 ldr r0, [r0, r1, lsl #2] 3000ba04: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000ba08: 13a01000 movne r1, #0 3000ba0c: 15821000 strne r1, [r2]
*level_p = level;
3000ba10: 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 ) {
3000ba14: 18bd8010 popne {r4, pc}
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ba18: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000ba1c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ba20: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000ba24: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ba28: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
} _ISR_Enable( level ); *location = OBJECTS_ERROR;
3000ba2c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ba30: 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;
3000ba34: e3a00000 mov r0, #0 <== NOT EXECUTED
#endif }
3000ba38: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3001615c <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
3001615c: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr} <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
30016160: e2516000 subs r6, r1, #0 <== NOT EXECUTED
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
30016164: e1a04002 mov r4, r2 <== NOT EXECUTED
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
return NULL;
30016168: 01a04006 moveq r4, r6 <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3001616c: 0a000038 beq 30016254 <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
if ( name == NULL )
30016170: e3540000 cmp r4, #0 <== NOT EXECUTED 30016174: 0a000036 beq 30016254 <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
30016178: e3500000 cmp r0, #0 <== NOT EXECUTED 3001617c: 059f30d8 ldreq r3, [pc, #216] ; 3001625c <_Objects_Get_name_as_string+0x100><== NOT EXECUTED 30016180: 11a07000 movne r7, r0 <== NOT EXECUTED 30016184: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED 30016188: 05937008 ldreq r7, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3001618c: e1a00007 mov r0, r7 <== NOT EXECUTED 30016190: ebffe3d5 bl 3000f0ec <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
30016194: e2505000 subs r5, r0, #0 <== NOT EXECUTED
return NULL;
30016198: 01a04005 moveq r4, r5 <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
information = _Objects_Get_information_id( tmpId );
if ( !information )
3001619c: 0a00002c beq 30016254 <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
300161a0: e1a01007 mov r1, r7 <== NOT EXECUTED 300161a4: e28d2008 add r2, sp, #8 <== NOT EXECUTED 300161a8: ebffe407 bl 3000f1cc <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
300161ac: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 300161b0: e3530000 cmp r3, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
300161b4: 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 ) {
300161b8: 1a000025 bne 30016254 <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
300161bc: e5d52038 ldrb r2, [r5, #56] ; 0x38 <== NOT EXECUTED 300161c0: e3520000 cmp r2, #0 <== NOT EXECUTED 300161c4: 0a000004 beq 300161dc <_Objects_Get_name_as_string+0x80> <== NOT EXECUTED
s = the_object->name.name_p;
300161c8: e590000c ldr r0, [r0, #12] <== NOT EXECUTED
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
300161cc: e3500000 cmp r0, #0 <== NOT EXECUTED 300161d0: 01a02004 moveq r2, r4 <== NOT EXECUTED 300161d4: 1a00000a bne 30016204 <_Objects_Get_name_as_string+0xa8> <== NOT EXECUTED 300161d8: ea00001a b 30016248 <_Objects_Get_name_as_string+0xec> <== 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;
300161dc: e590300c ldr r3, [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';
300161e0: e5cd2004 strb r2, [sp, #4] <== NOT EXECUTED
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
300161e4: e1a01c23 lsr r1, r3, #24 <== NOT EXECUTED 300161e8: e5cd1000 strb r1, [sp] <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
300161ec: e1a01823 lsr r1, r3, #16 <== NOT EXECUTED 300161f0: e5cd1001 strb r1, [sp, #1] <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
300161f4: e1a01423 lsr r1, r3, #8 <== NOT EXECUTED 300161f8: e5cd1002 strb r1, [sp, #2] <== NOT EXECUTED
lname[ 3 ] = (u32_name >> 0) & 0xff;
300161fc: e5cd3003 strb r3, [sp, #3] <== NOT EXECUTED
lname[ 4 ] = '\0';
s = lname;
30016200: e1a0000d mov r0, sp <== NOT EXECUTED
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint((unsigned char)*s)) ? *s : '*';
30016204: e1a02004 mov r2, r4 <== NOT EXECUTED 30016208: e3a01000 mov r1, #0 <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3001620c: e2466001 sub r6, r6, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
30016210: e59fc048 ldr ip, [pc, #72] ; 30016260 <_Objects_Get_name_as_string+0x104><== NOT EXECUTED 30016214: ea000006 b 30016234 <_Objects_Get_name_as_string+0xd8> <== NOT EXECUTED 30016218: e59ce000 ldr lr, [ip] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3001621c: e2811001 add r1, r1, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
30016220: e08ee003 add lr, lr, r3 <== NOT EXECUTED 30016224: e5dee001 ldrb lr, [lr, #1] <== NOT EXECUTED 30016228: e31e0097 tst lr, #151 ; 0x97 <== NOT EXECUTED 3001622c: 03a0302a moveq r3, #42 ; 0x2a <== NOT EXECUTED 30016230: e4c23001 strb r3, [r2], #1 <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
30016234: e1510006 cmp r1, r6 <== NOT EXECUTED 30016238: 2a000002 bcs 30016248 <_Objects_Get_name_as_string+0xec> <== NOT EXECUTED 3001623c: e7d03001 ldrb r3, [r0, r1] <== NOT EXECUTED 30016240: e3530000 cmp r3, #0 <== NOT EXECUTED 30016244: 1afffff3 bne 30016218 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
30016248: e3a03000 mov r3, #0 <== NOT EXECUTED 3001624c: e5c23000 strb r3, [r2] <== NOT EXECUTED
_Thread_Enable_dispatch();
30016250: ebffe78f bl 30010094 <_Thread_Enable_dispatch> <== NOT EXECUTED
return name;
}
return NULL; /* unreachable path */
}
30016254: e1a00004 mov r0, r4 <== NOT EXECUTED
30016258: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
30018850 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
30018850: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
30018854: e2507000 subs r7, r0, #0 <== NOT EXECUTED
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
30018858: e1a04002 mov r4, r2 <== NOT EXECUTED 3001885c: e1a06003 mov r6, r3 <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
30018860: 01a00007 moveq r0, r7 <== NOT EXECUTED
)
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
30018864: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return NULL;
if ( !location_p )
30018868: e3520000 cmp r2, #0 <== NOT EXECUTED
return NULL;
3001886c: 01a00002 moveq r0, r2 <== NOT EXECUTED
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
30018870: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return NULL;
if ( !next_id_p )
30018874: e3530000 cmp r3, #0 <== NOT EXECUTED 30018878: 0a000016 beq 300188d8 <_Objects_Get_next+0x88> <== NOT EXECUTED
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
3001887c: e1b03801 lsls r3, r1, #16 <== NOT EXECUTED
next_id = information->minimum_id;
30018880: 05975008 ldreq r5, [r7, #8] <== NOT EXECUTED
else
next_id = id;
30018884: 11a05001 movne r5, r1 <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
30018888: e1d731b0 ldrh r3, [r7, #16] <== NOT EXECUTED 3001888c: e1a02805 lsl r2, r5, #16 <== NOT EXECUTED 30018890: e1530822 cmp r3, r2, lsr #16 <== NOT EXECUTED 30018894: 2a000005 bcs 300188b0 <_Objects_Get_next+0x60> <== NOT EXECUTED
{
*location_p = OBJECTS_ERROR;
30018898: e3a03001 mov r3, #1 <== NOT EXECUTED 3001889c: e5843000 str r3, [r4] <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
300188a0: e3e03000 mvn r3, #0 <== NOT EXECUTED 300188a4: e5863000 str r3, [r6] <== NOT EXECUTED
return 0;
300188a8: e3a00000 mov r0, #0 <== NOT EXECUTED
300188ac: 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);
300188b0: e1a01005 mov r1, r5 <== NOT EXECUTED 300188b4: e1a00007 mov r0, r7 <== NOT EXECUTED 300188b8: e1a02004 mov r2, r4 <== NOT EXECUTED 300188bc: ebffda42 bl 3000f1cc <_Objects_Get> <== NOT EXECUTED
next_id++;
} while (*location_p != OBJECTS_LOCAL);
300188c0: e5943000 ldr r3, [r4] <== NOT EXECUTED
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
next_id++;
300188c4: e2855001 add r5, r5, #1 <== NOT EXECUTED
} while (*location_p != OBJECTS_LOCAL);
300188c8: e3530000 cmp r3, #0 <== NOT EXECUTED 300188cc: 1affffed bne 30018888 <_Objects_Get_next+0x38> <== NOT EXECUTED
*next_id_p = next_id;
300188d0: e5865000 str r5, [r6] <== NOT EXECUTED
return object;
300188d4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
300188d8: e1a00003 mov r0, r3 <== NOT EXECUTED
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
300188dc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f234 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000f234: e92d4031 push {r0, r4, r5, lr}
3000f238: e1a05001 mov r5, r1
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000f23c: e2501000 subs r1, r0, #0 3000f240: 059f3078 ldreq r3, [pc, #120] ; 3000f2c0 <_Objects_Id_to_name+0x8c> 3000f244: 05933008 ldreq r3, [r3, #8] 3000f248: 05931008 ldreq r1, [r3, #8] 3000f24c: e1a03c21 lsr r3, r1, #24 3000f250: 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 )
3000f254: e2432001 sub r2, r3, #1 3000f258: e3520002 cmp r2, #2
3000f25c: 8a000010 bhi 3000f2a4 <_Objects_Id_to_name+0x70>
3000f260: ea000011 b 3000f2ac <_Objects_Id_to_name+0x78>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000f264: 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 ];
3000f268: e7930102 ldr r0, [r3, r2, lsl #2]
if ( !information )
3000f26c: e3500000 cmp r0, #0
3000f270: 0a00000b beq 3000f2a4 <_Objects_Id_to_name+0x70>
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
3000f274: e5d04038 ldrb r4, [r0, #56] ; 0x38 3000f278: e3540000 cmp r4, #0
3000f27c: 1a000008 bne 3000f2a4 <_Objects_Id_to_name+0x70>
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
3000f280: e1a0200d mov r2, sp 3000f284: ebffffd0 bl 3000f1cc <_Objects_Get>
if ( !the_object )
3000f288: e3500000 cmp r0, #0
3000f28c: 0a000004 beq 3000f2a4 <_Objects_Id_to_name+0x70>
return OBJECTS_INVALID_ID;
*name = the_object->name;
3000f290: e590300c ldr r3, [r0, #12] 3000f294: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000f298: eb00037d bl 30010094 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000f29c: e1a00004 mov r0, r4 3000f2a0: ea000000 b 3000f2a8 <_Objects_Id_to_name+0x74>
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;
3000f2a4: e3a00003 mov r0, #3 <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
3000f2a8: e8bd8038 pop {r3, r4, r5, pc}
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
3000f2ac: e59f2010 ldr r2, [pc, #16] ; 3000f2c4 <_Objects_Id_to_name+0x90> 3000f2b0: e7923103 ldr r3, [r2, r3, lsl #2] 3000f2b4: e3530000 cmp r3, #0
3000f2b8: 1affffe9 bne 3000f264 <_Objects_Id_to_name+0x30>
3000f2bc: eafffff8 b 3000f2a4 <_Objects_Id_to_name+0x70> <== NOT EXECUTED
3000bb94 <_Objects_Name_to_id_u32>:
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000bb94: e3530000 cmp r3, #0
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
3000bb98: e92d4030 push {r4, r5, lr}
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
3000bb9c: 03a00002 moveq r0, #2
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000bba0: 08bd8030 popeq {r4, r5, pc}
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
3000bba4: e3510000 cmp r1, #0
3000bba8: 0a000017 beq 3000bc0c <_Objects_Name_to_id_u32+0x78>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
3000bbac: e1d041b0 ldrh r4, [r0, #16] 3000bbb0: e3540000 cmp r4, #0
3000bbb4: 0a000016 beq 3000bc14 <_Objects_Name_to_id_u32+0x80>
3000bbb8: e3720106 cmn r2, #-2147483647 ; 0x80000001 3000bbbc: 13520000 cmpne r2, #0 3000bbc0: 03a02001 moveq r2, #1
3000bbc4: 0a00000e beq 3000bc04 <_Objects_Name_to_id_u32+0x70>
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
3000bbc8: e3520001 cmp r2, #1 <== NOT EXECUTED 3000bbcc: 1a00000e bne 3000bc0c <_Objects_Name_to_id_u32+0x78> <== NOT EXECUTED 3000bbd0: ea00000b b 3000bc04 <_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 ];
3000bbd4: e590c01c ldr ip, [r0, #28] 3000bbd8: e79cc102 ldr ip, [ip, r2, lsl #2]
if ( !the_object )
3000bbdc: e35c0000 cmp ip, #0
3000bbe0: 0a000006 beq 3000bc00 <_Objects_Name_to_id_u32+0x6c>
continue;
if ( name == the_object->name.name_u32 ) {
3000bbe4: e59c500c ldr r5, [ip, #12] 3000bbe8: e1510005 cmp r1, r5
3000bbec: 1a000003 bne 3000bc00 <_Objects_Name_to_id_u32+0x6c>
*id = the_object->id;
3000bbf0: e59c2008 ldr r2, [ip, #8]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000bbf4: 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;
3000bbf8: e5832000 str r2, [r3]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000bbfc: 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++ ) {
3000bc00: e2822001 add r2, r2, #1 3000bc04: e1520004 cmp r2, r4
3000bc08: 9afffff1 bls 3000bbd4 <_Objects_Name_to_id_u32+0x40>
if ( !id )
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
return OBJECTS_INVALID_NAME;
3000bc0c: e3a00001 mov r0, #1 <== NOT EXECUTED
3000bc10: 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;
3000bc14: e3a00001 mov r0, #1
#endif }
3000bc18: e8bd8030 pop {r4, r5, pc}
3000bd44 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000bd44: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000bd48: e1a05000 mov r5, r0
3000bd4c: e1a06001 mov r6, r1
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000bd50: e1a00002 mov r0, r2 3000bd54: e1d513ba ldrh r1, [r5, #58] ; 0x3a
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000bd58: e1a08002 mov r8, r2
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000bd5c: eb001ed8 bl 300138c4 <strnlen>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000bd60: e5d53038 ldrb r3, [r5, #56] ; 0x38
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000bd64: e1a04000 mov r4, r0
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000bd68: e3530000 cmp r3, #0
3000bd6c: 0a00000e beq 3000bdac <_Objects_Set_name+0x68>
char *d;
d = _Workspace_Allocate( length + 1 );
3000bd70: e2800001 add r0, r0, #1 3000bd74: eb000703 bl 3000d988 <_Workspace_Allocate>
if ( !d )
3000bd78: e2505000 subs r5, r0, #0
3000bd7c: 0a00001d beq 3000bdf8 <_Objects_Set_name+0xb4>
return false;
_Workspace_Free( (void *)the_object->name.name_p );
3000bd80: e596000c ldr r0, [r6, #12] <== NOT EXECUTED
the_object->name.name_p = NULL;
3000bd84: e3a07000 mov r7, #0 <== NOT EXECUTED
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
_Workspace_Free( (void *)the_object->name.name_p );
3000bd88: eb000704 bl 3000d9a0 <_Workspace_Free> <== NOT EXECUTED
the_object->name.name_p = NULL;
3000bd8c: e586700c str r7, [r6, #12] <== NOT EXECUTED
strncpy( d, name, length );
3000bd90: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bd94: e1a01008 mov r1, r8 <== NOT EXECUTED 3000bd98: e1a02004 mov r2, r4 <== NOT EXECUTED 3000bd9c: eb001e93 bl 300137f0 <strncpy> <== NOT EXECUTED
d[length] = '\0';
3000bda0: e7c57004 strb r7, [r5, r4] <== NOT EXECUTED
the_object->name.name_p = d;
3000bda4: e586500c str r5, [r6, #12] <== NOT EXECUTED 3000bda8: ea000010 b 3000bdf0 <_Objects_Set_name+0xac> <== NOT EXECUTED
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000bdac: e3500001 cmp r0, #1 <== NOT EXECUTED 3000bdb0: 85d83001 ldrbhi r3, [r8, #1] <== NOT EXECUTED 3000bdb4: e5d82000 ldrb r2, [r8] <== NOT EXECUTED 3000bdb8: 81a03803 lslhi r3, r3, #16 <== NOT EXECUTED 3000bdbc: 93a03602 movls r3, #2097152 ; 0x200000 <== NOT EXECUTED 3000bdc0: e1a02c02 lsl r2, r2, #24 <== NOT EXECUTED 3000bdc4: e3500002 cmp r0, #2 <== NOT EXECUTED 3000bdc8: e1832002 orr r2, r3, r2 <== NOT EXECUTED 3000bdcc: 85d83002 ldrbhi r3, [r8, #2] <== NOT EXECUTED 3000bdd0: 93a03a02 movls r3, #8192 ; 0x2000 <== NOT EXECUTED 3000bdd4: 81a03403 lslhi r3, r3, #8 <== NOT EXECUTED 3000bdd8: e3500003 cmp r0, #3 <== NOT EXECUTED 3000bddc: e1822003 orr r2, r2, r3 <== NOT EXECUTED 3000bde0: 85d83003 ldrbhi r3, [r8, #3] <== NOT EXECUTED 3000bde4: 93a03020 movls r3, #32 <== NOT EXECUTED 3000bde8: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000bdec: e586300c str r3, [r6, #12] <== NOT EXECUTED
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
3000bdf0: e3a00001 mov r0, #1 <== NOT EXECUTED
3000bdf4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
3000bdf8: e1a00005 mov r0, r5
);
}
return true;
}
3000bdfc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000af00 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
3000af00: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000af04: e1a05000 mov r5, r0 <== NOT EXECUTED
3000af08: e1a04001 mov r4, r1 <== NOT EXECUTED
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
3000af0c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000af10: e1a0100d mov r1, sp <== NOT EXECUTED
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
3000af14: e1a07002 mov r7, r2 <== NOT EXECUTED 3000af18: e20380ff and r8, r3, #255 ; 0xff <== NOT EXECUTED
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
3000af1c: eb000055 bl 3000b078 <_POSIX_Mutex_Get> <== NOT EXECUTED 3000af20: e3500000 cmp r0, #0 <== NOT EXECUTED 3000af24: 0a000031 beq 3000aff0 <_POSIX_Condition_variables_Wait_support+0xf0><== 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;
3000af28: e59f30cc ldr r3, [pc, #204] ; 3000affc <_POSIX_Condition_variables_Wait_support+0xfc><== NOT EXECUTED
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000af2c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000af30: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000af34: e1a0100d mov r1, sp <== NOT EXECUTED
--level;
3000af38: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000af3c: e5832000 str r2, [r3] <== NOT EXECUTED 3000af40: ebffff7b bl 3000ad34 <_POSIX_Condition_variables_Get> <== NOT EXECUTED
switch ( location ) {
3000af44: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000af48: e1a0a000 mov sl, r0 <== NOT EXECUTED
switch ( location ) {
3000af4c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000af50: 1a000026 bne 3000aff0 <_POSIX_Condition_variables_Wait_support+0xf0><== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
3000af54: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000af58: e3530000 cmp r3, #0 <== NOT EXECUTED 3000af5c: 0a000004 beq 3000af74 <_POSIX_Condition_variables_Wait_support+0x74><== NOT EXECUTED 3000af60: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000af64: e1530002 cmp r3, r2 <== NOT EXECUTED 3000af68: 0a000001 beq 3000af74 <_POSIX_Condition_variables_Wait_support+0x74><== NOT EXECUTED
_Thread_Enable_dispatch();
3000af6c: eb000dc0 bl 3000e674 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000af70: ea00001e b 3000aff0 <_POSIX_Condition_variables_Wait_support+0xf0><== NOT EXECUTED
return EINVAL;
}
(void) pthread_mutex_unlock( mutex );
3000af74: e1a00004 mov r0, r4 <== NOT EXECUTED 3000af78: eb0000de bl 3000b2f8 <pthread_mutex_unlock> <== NOT EXECUTED
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
3000af7c: e3580000 cmp r8, #0 <== NOT EXECUTED 3000af80: 1a000013 bne 3000afd4 <_POSIX_Condition_variables_Wait_support+0xd4><== NOT EXECUTED
the_cond->Mutex = *mutex;
3000af84: e5943000 ldr r3, [r4] <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000af88: e59f6070 ldr r6, [pc, #112] ; 3000b000 <_POSIX_Condition_variables_Wait_support+0x100><== NOT EXECUTED
return EINVAL;
}
*/
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
3000af8c: e58a3014 str r3, [sl, #20] <== 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;
3000af90: e3a03001 mov r3, #1 <== NOT EXECUTED 3000af94: e58a3048 str r3, [sl, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000af98: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
3000af9c: e28a0018 add r0, sl, #24 <== NOT EXECUTED
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000afa0: e5838034 str r8, [r3, #52] ; 0x34 <== NOT EXECUTED
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
_Thread_Executing->Wait.id = *cond;
3000afa4: e5952000 ldr r2, [r5] <== NOT EXECUTED
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
3000afa8: e5830044 str r0, [r3, #68] ; 0x44 <== NOT EXECUTED
_Thread_Executing->Wait.id = *cond;
3000afac: e5832020 str r2, [r3, #32] <== NOT EXECUTED
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
3000afb0: e1a01007 mov r1, r7 <== NOT EXECUTED 3000afb4: e59f2048 ldr r2, [pc, #72] ; 3000b004 <_POSIX_Condition_variables_Wait_support+0x104><== NOT EXECUTED 3000afb8: eb000ed9 bl 3000eb24 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000afbc: eb000dac bl 3000e674 <_Thread_Enable_dispatch> <== NOT EXECUTED
* a POSIX signal, then pthread_cond_wait returns spuriously,
* according to the POSIX standard. It means that pthread_cond_wait
* returns a success status, except for the fact that it was not
* woken up a pthread_cond_signal or a pthread_cond_broadcast.
*/
status = _Thread_Executing->Wait.return_code;
3000afc0: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED 3000afc4: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
if ( status == EINTR )
status = 0;
3000afc8: e3550004 cmp r5, #4 <== NOT EXECUTED 3000afcc: 03a05000 moveq r5, #0 <== NOT EXECUTED 3000afd0: ea000001 b 3000afdc <_POSIX_Condition_variables_Wait_support+0xdc><== NOT EXECUTED
} else {
_Thread_Enable_dispatch();
3000afd4: eb000da6 bl 3000e674 <_Thread_Enable_dispatch> <== NOT EXECUTED
status = ETIMEDOUT;
3000afd8: e3a05074 mov r5, #116 ; 0x74 <== NOT EXECUTED
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
3000afdc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000afe0: eb0000a5 bl 3000b27c <pthread_mutex_lock> <== NOT EXECUTED
if ( mutex_status )
return EINVAL;
3000afe4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000afe8: 13a05016 movne r5, #22 <== NOT EXECUTED 3000afec: ea000000 b 3000aff4 <_POSIX_Condition_variables_Wait_support+0xf4><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000aff0: e3a05016 mov r5, #22 <== NOT EXECUTED
}
3000aff4: e1a00005 mov r0, r5 <== NOT EXECUTED
3000aff8: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30011250 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
30011250: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
30011254: e5906008 ldr r6, [r0, #8]
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
30011258: e59f5080 ldr r5, [pc, #128] ; 300112e0 <_POSIX_Keys_Run_destructors+0x90> 3001125c: e1a07c26 lsr r7, r6, #24
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
30011260: e1a06806 lsl r6, r6, #16 30011264: e2077007 and r7, r7, #7 30011268: e1a06726 lsr r6, r6, #14
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
3001126c: e3a04001 mov r4, #1
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
30011270: e1d5a1b0 ldrh sl, [r5, #16]
done = true;
30011274: e1a02004 mov r2, r4
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
if ( value != NULL ) {
key->Values [ thread_api ][ thread_index ] = NULL;
30011278: e3a08000 mov r8, #0
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
3001127c: ea000012 b 300112cc <_POSIX_Keys_Run_destructors+0x7c>
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
30011280: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 30011284: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
30011288: e3530000 cmp r3, #0 <== NOT EXECUTED 3001128c: 0a00000b beq 300112c0 <_POSIX_Keys_Run_destructors+0x70> <== NOT EXECUTED 30011290: e5931010 ldr r1, [r3, #16] <== NOT EXECUTED 30011294: e3510000 cmp r1, #0 <== NOT EXECUTED 30011298: 0a000008 beq 300112c0 <_POSIX_Keys_Run_destructors+0x70> <== NOT EXECUTED
void *value = key->Values [ thread_api ][ thread_index ];
3001129c: e2871005 add r1, r7, #5 <== NOT EXECUTED 300112a0: e7931101 ldr r1, [r3, r1, lsl #2] <== NOT EXECUTED 300112a4: e7910006 ldr r0, [r1, r6] <== NOT EXECUTED
if ( value != NULL ) {
300112a8: e3500000 cmp r0, #0 <== NOT EXECUTED 300112ac: 0a000003 beq 300112c0 <_POSIX_Keys_Run_destructors+0x70> <== NOT EXECUTED
key->Values [ thread_api ][ thread_index ] = NULL;
300112b0: e7818006 str r8, [r1, r6] <== NOT EXECUTED
(*key->destructor)( value );
300112b4: e1a0e00f mov lr, pc <== NOT EXECUTED 300112b8: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED
done = false;
300112bc: e3a02000 mov r2, #0 <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
300112c0: e2844001 add r4, r4, #1 <== NOT EXECUTED 300112c4: e1a04804 lsl r4, r4, #16 <== NOT EXECUTED 300112c8: e1a04824 lsr r4, r4, #16 <== NOT EXECUTED
300112cc: e154000a cmp r4, sl
300112d0: 9affffea bls 30011280 <_POSIX_Keys_Run_destructors+0x30>
* number of iterations. An infinite loop may happen if destructors set
* thread specific data. This can be considered dubious.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
300112d4: e3520000 cmp r2, #0
300112d8: 0affffe3 beq 3001126c <_POSIX_Keys_Run_destructors+0x1c>
done = false;
}
}
}
}
}
300112dc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30010a00 <_POSIX_Message_queue_Create_support>:
size_t name_len,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
30010a00: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
30010a04: e1a09002 mov r9, r2
*
* 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;
30010a08: e59f2124 ldr r2, [pc, #292] ; 30010b34 <_POSIX_Message_queue_Create_support+0x134> 30010a0c: e1a07001 mov r7, r1 30010a10: e5921000 ldr r1, [r2] 30010a14: e1a06000 mov r6, r0
++level;
30010a18: e2811001 add r1, r1, #1
_Thread_Dispatch_disable_level = level;
30010a1c: e5821000 str r1, [r2]
* There is no real basis for the default values. They will work
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
30010a20: e3530000 cmp r3, #0
30010a24: 0a000009 beq 30010a50 <_POSIX_Message_queue_Create_support+0x50>
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
30010a28: e593a004 ldr sl, [r3, #4] 30010a2c: e35a0000 cmp sl, #0
30010a30: da000002 ble 30010a40 <_POSIX_Message_queue_Create_support+0x40>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
30010a34: e5938008 ldr r8, [r3, #8] 30010a38: e3580000 cmp r8, #0
30010a3c: ca000005 bgt 30010a58 <_POSIX_Message_queue_Create_support+0x58>
_Thread_Enable_dispatch();
30010a40: ebfff668 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30010a44: eb000b38 bl 3001372c <__errno> <== NOT EXECUTED 30010a48: e3a03016 mov r3, #22 <== NOT EXECUTED 30010a4c: ea00002c b 30010b04 <_POSIX_Message_queue_Create_support+0x104><== NOT EXECUTED
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
30010a50: e3a08010 mov r8, #16 <== NOT EXECUTED
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
30010a54: e3a0a00a mov sl, #10 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE
POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void )
{
return (POSIX_Message_queue_Control *)
30010a58: e59f50d8 ldr r5, [pc, #216] ; 30010b38 <_POSIX_Message_queue_Create_support+0x138> 30010a5c: e1a00005 mov r0, r5 30010a60: ebfff19a bl 3000d0d0 <_Objects_Allocate>
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
30010a64: e2504000 subs r4, r0, #0
30010a68: 1a000003 bne 30010a7c <_POSIX_Message_queue_Create_support+0x7c>
_Thread_Enable_dispatch();
30010a6c: ebfff65d bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
30010a70: eb000b2d bl 3001372c <__errno> <== NOT EXECUTED 30010a74: e3a03017 mov r3, #23 <== NOT EXECUTED 30010a78: ea000021 b 30010b04 <_POSIX_Message_queue_Create_support+0x104><== NOT EXECUTED
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
name = _Workspace_String_duplicate( name_arg, name_len );
30010a7c: e1a01007 mov r1, r7 30010a80: e1a00006 mov r0, r6 30010a84: eb0005d0 bl 300121cc <_Workspace_String_duplicate>
if ( !name ) {
30010a88: e2507000 subs r7, r0, #0
30010a8c: 1a000006 bne 30010aac <_POSIX_Message_queue_Create_support+0xac>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
30010a90: e1a00005 mov r0, r5 <== NOT EXECUTED 30010a94: e1a01004 mov r1, r4 <== NOT EXECUTED 30010a98: ebfff25b bl 3000d40c <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
30010a9c: ebfff651 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
30010aa0: eb000b21 bl 3001372c <__errno> <== NOT EXECUTED 30010aa4: e3a0300c mov r3, #12 <== NOT EXECUTED 30010aa8: ea000015 b 30010b04 <_POSIX_Message_queue_Create_support+0x104><== NOT EXECUTED
}
the_mq->process_shared = pshared;
the_mq->named = true;
30010aac: e3a03001 mov r3, #1
* * Joel: Cite POSIX or OpenGroup on above statement so we can determine * if it is a real requirement. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
30010ab0: e3a06000 mov r6, #0
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
the_mq->process_shared = pshared;
the_mq->named = true;
30010ab4: e5c43014 strb r3, [r4, #20]
the_mq->open_count = 1;
30010ab8: e5843018 str r3, [r4, #24]
the_mq->linked = true;
30010abc: e5c43015 strb r3, [r4, #21]
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
the_mq->process_shared = pshared;
30010ac0: e5849010 str r9, [r4, #16]
* * Joel: Cite POSIX or OpenGroup on above statement so we can determine * if it is a real requirement. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
30010ac4: e584605c str r6, [r4, #92] ; 0x5c
if ( !_CORE_message_queue_Initialize(
30010ac8: e284001c add r0, r4, #28 30010acc: e284105c add r1, r4, #92 ; 0x5c 30010ad0: e1a0200a mov r2, sl 30010ad4: e1a03008 mov r3, r8 30010ad8: eb0002f6 bl 300116b8 <_CORE_message_queue_Initialize> 30010adc: e1500006 cmp r0, r6
30010ae0: 1a00000a bne 30010b10 <_POSIX_Message_queue_Create_support+0x110>
30010ae4: e1a01004 mov r1, r4 <== NOT EXECUTED 30010ae8: e1a00005 mov r0, r5 <== NOT EXECUTED 30010aec: ebfff246 bl 3000d40c <_Objects_Free> <== NOT EXECUTED
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
30010af0: e1a00007 mov r0, r7 <== NOT EXECUTED 30010af4: ebfffa36 bl 3000f3d4 <_Workspace_Free> <== NOT EXECUTED
_Thread_Enable_dispatch();
30010af8: ebfff63a bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
30010afc: eb000b0a bl 3001372c <__errno> <== NOT EXECUTED
30010b00: e3a0301c mov r3, #28 <== NOT EXECUTED
30010b04: e5803000 str r3, [r0] <== NOT EXECUTED
30010b08: e3e00000 mvn r0, #0 <== NOT EXECUTED
30010b0c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30010b10: e595301c ldr r3, [r5, #28]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
30010b14: e1d420b8 ldrh r2, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30010b18: e7834102 str r4, [r3, r2, lsl #2]
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
30010b1c: e59d3020 ldr r3, [sp, #32]
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
30010b20: e584700c str r7, [r4, #12] 30010b24: e5834000 str r4, [r3]
_Thread_Enable_dispatch();
30010b28: ebfff62e bl 3000e3e8 <_Thread_Enable_dispatch>
return 0;
30010b2c: e1a00006 mov r0, r6
}
30010b30: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
3000f028 <_POSIX_Message_queue_Notify_handler>:
*/
static void _POSIX_Message_queue_Notify_handler(
void *user_data
)
{
3000f028: e92d4010 push {r4, lr} <== NOT EXECUTED
3000f02c: e1a04000 mov r4, r0 <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
the_mq = user_data;
kill( getpid(), the_mq->notification.sigev_signo );
3000f030: eb001818 bl 30015098 <getpid> <== NOT EXECUTED 3000f034: e5941094 ldr r1, [r4, #148] ; 0x94 <== NOT EXECUTED 3000f038: eb001a16 bl 30015898 <kill> <== NOT EXECUTED
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
3000f03c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000f040: e584307c str r3, [r4, #124] ; 0x7c <== NOT EXECUTED
the_message_queue->notify_argument = the_argument;
3000f044: e5843080 str r3, [r4, #128] ; 0x80 <== NOT EXECUTED
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
}
3000f048: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000f29c <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000f29c: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr}
3000f2a0: e1a05000 mov r5, r0
3000f2a4: e1a06001 mov r6, r1
3000f2a8: e1a07002 mov r7, r2
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000f2ac: e59f0100 ldr r0, [pc, #256] ; 3000f3b4 <_POSIX_Message_queue_Receive_support+0x118> 3000f2b0: e1a01005 mov r1, r5 3000f2b4: e28d2008 add r2, sp, #8 3000f2b8: e1a04003 mov r4, r3 3000f2bc: e5dd8028 ldrb r8, [sp, #40] ; 0x28 3000f2c0: eb000c33 bl 30012394 <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000f2c4: e59d3008 ldr r3, [sp, #8] 3000f2c8: e3530000 cmp r3, #0
3000f2cc: 1a000032 bne 3000f39c <_POSIX_Message_queue_Receive_support+0x100>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
3000f2d0: e5903014 ldr r3, [r0, #20] 3000f2d4: e2032003 and r2, r3, #3 3000f2d8: e3520001 cmp r2, #1
3000f2dc: 1a000001 bne 3000f2e8 <_POSIX_Message_queue_Receive_support+0x4c>
_Thread_Enable_dispatch();
3000f2e0: eb000fb9 bl 300131cc <_Thread_Enable_dispatch> <== NOT EXECUTED 3000f2e4: ea00002c b 3000f39c <_POSIX_Message_queue_Receive_support+0x100><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
3000f2e8: e5900010 ldr r0, [r0, #16]
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
3000f2ec: e5902068 ldr r2, [r0, #104] ; 0x68 3000f2f0: e1570002 cmp r7, r2
3000f2f4: 2a000003 bcs 3000f308 <_POSIX_Message_queue_Receive_support+0x6c>
_Thread_Enable_dispatch();
3000f2f8: eb000fb3 bl 300131cc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMSGSIZE );
3000f2fc: eb0025aa bl 300189ac <__errno> <== NOT EXECUTED 3000f300: e3a0307a mov r3, #122 ; 0x7a <== NOT EXECUTED 3000f304: ea000026 b 3000f3a4 <_POSIX_Message_queue_Receive_support+0x108><== NOT EXECUTED
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
3000f308: e3e02000 mvn r2, #0
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000f30c: e3580000 cmp r8, #0
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
3000f310: e58d200c str r2, [sp, #12]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000f314: 0a000002 beq 3000f324 <_POSIX_Message_queue_Receive_support+0x88>
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
3000f318: e3130901 tst r3, #16384 ; 0x4000 3000f31c: 13a08000 movne r8, #0 3000f320: 03a08001 moveq r8, #1
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
3000f324: e59d302c ldr r3, [sp, #44] ; 0x2c 3000f328: e280001c add r0, r0, #28 3000f32c: e58d3004 str r3, [sp, #4] 3000f330: e1a01005 mov r1, r5 3000f334: e28d300c add r3, sp, #12 3000f338: e1a02006 mov r2, r6 3000f33c: e58d8000 str r8, [sp] 3000f340: eb00080b bl 30011374 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
3000f344: eb000fa0 bl 300131cc <_Thread_Enable_dispatch>
if (msg_prio) {
3000f348: e3540000 cmp r4, #0 3000f34c: e59f3064 ldr r3, [pc, #100] ; 3000f3b8 <_POSIX_Message_queue_Receive_support+0x11c>
3000f350: 0a000004 beq 3000f368 <_POSIX_Message_queue_Receive_support+0xcc>
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
3000f354: e5932008 ldr r2, [r3, #8]
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return (unsigned int) ((priority >= 0) ? priority : -priority);
3000f358: e5922024 ldr r2, [r2, #36] ; 0x24 3000f35c: e3520000 cmp r2, #0 3000f360: b2622000 rsblt r2, r2, #0
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
3000f364: e5842000 str r2, [r4]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
3000f368: e5933008 ldr r3, [r3, #8] 3000f36c: e5933034 ldr r3, [r3, #52] ; 0x34 3000f370: e3530000 cmp r3, #0
return length_out;
3000f374: 059d000c ldreq r0, [sp, #12]
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
3000f378: 0a00000b beq 3000f3ac <_POSIX_Message_queue_Receive_support+0x110>
return length_out;
rtems_set_errno_and_return_minus_one(
3000f37c: eb00258a bl 300189ac <__errno> <== NOT EXECUTED 3000f380: e59f3030 ldr r3, [pc, #48] ; 3000f3b8 <_POSIX_Message_queue_Receive_support+0x11c><== NOT EXECUTED 3000f384: e1a04000 mov r4, r0 <== NOT EXECUTED 3000f388: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000f38c: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000f390: eb00009c bl 3000f608 <_POSIX_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED 3000f394: e5840000 str r0, [r4] <== NOT EXECUTED 3000f398: ea000002 b 3000f3a8 <_POSIX_Message_queue_Receive_support+0x10c><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f39c: eb002582 bl 300189ac <__errno> <== NOT EXECUTED 3000f3a0: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f3a4: e5803000 str r3, [r0] <== NOT EXECUTED 3000f3a8: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000f3ac: e28dd010 add sp, sp, #16
3000f3b0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000f3d4 <_POSIX_Message_queue_Send_support>:
size_t msg_len,
unsigned int msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000f3d4: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
3000f3d8: e3530020 cmp r3, #32
size_t msg_len,
unsigned int msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000f3dc: e24dd014 sub sp, sp, #20 3000f3e0: e1a04000 mov r4, r0 3000f3e4: e1a06001 mov r6, r1 3000f3e8: e1a05002 mov r5, r2 3000f3ec: e1a07003 mov r7, r3 3000f3f0: e5dd802c ldrb r8, [sp, #44] ; 0x2c
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
3000f3f4: 9a000002 bls 3000f404 <_POSIX_Message_queue_Send_support+0x30>
rtems_set_errno_and_return_minus_one( EINVAL );
3000f3f8: eb00256b bl 300189ac <__errno> <== NOT EXECUTED 3000f3fc: e3a03016 mov r3, #22 <== NOT EXECUTED 3000f400: ea00002d b 3000f4bc <_POSIX_Message_queue_Send_support+0xe8><== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000f404: e59f00c0 ldr r0, [pc, #192] ; 3000f4cc <_POSIX_Message_queue_Send_support+0xf8> 3000f408: e1a01004 mov r1, r4 3000f40c: e28d2010 add r2, sp, #16 3000f410: eb000bdf bl 30012394 <_Objects_Get>
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000f414: e59d3010 ldr r3, [sp, #16] 3000f418: e3530000 cmp r3, #0
3000f41c: 1a000024 bne 3000f4b4 <_POSIX_Message_queue_Send_support+0xe0>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
3000f420: e5903014 ldr r3, [r0, #20] 3000f424: e3130003 tst r3, #3
3000f428: 1a000001 bne 3000f434 <_POSIX_Message_queue_Send_support+0x60>
_Thread_Enable_dispatch();
3000f42c: eb000f66 bl 300131cc <_Thread_Enable_dispatch> <== NOT EXECUTED 3000f430: ea00001f b 3000f4b4 <_POSIX_Message_queue_Send_support+0xe0><== NOT EXECUTED
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000f434: e3580000 cmp r8, #0
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
3000f438: e5900010 ldr r0, [r0, #16]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000f43c: 0a000002 beq 3000f44c <_POSIX_Message_queue_Send_support+0x78>
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
3000f440: e3130901 tst r3, #16384 ; 0x4000 3000f444: 13a08000 movne r8, #0 3000f448: 03a08001 moveq r8, #1
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
3000f44c: e3a03000 mov r3, #0 3000f450: e58d3000 str r3, [sp] 3000f454: e59d3030 ldr r3, [sp, #48] ; 0x30 3000f458: e1a01006 mov r1, r6 3000f45c: e58d300c str r3, [sp, #12] 3000f460: e1a02005 mov r2, r5 3000f464: e1a03004 mov r3, r4
RTEMS_INLINE_ROUTINE CORE_message_queue_Submit_types _POSIX_Message_queue_Priority_to_core(
unsigned int priority
)
{
return (CORE_message_queue_Submit_types) priority * -1;
3000f468: e2677000 rsb r7, r7, #0
3000f46c: e280001c add r0, r0, #28
3000f470: e98d0180 stmib sp, {r7, r8}
3000f474: eb000808 bl 3001149c <_CORE_message_queue_Submit>
3000f478: e1a04000 mov r4, r0
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
3000f47c: eb000f52 bl 300131cc <_Thread_Enable_dispatch>
* after it wakes up. The returned status is correct for
* non-blocking operations but if we blocked, then we need
* to look at the status in our TCB.
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
3000f480: e3540007 cmp r4, #7
msg_status = _Thread_Executing->Wait.return_code;
3000f484: 059f3044 ldreq r3, [pc, #68] ; 3000f4d0 <_POSIX_Message_queue_Send_support+0xfc> 3000f488: 05933008 ldreq r3, [r3, #8] 3000f48c: 05934034 ldreq r4, [r3, #52] ; 0x34
if ( !msg_status )
3000f490: e3540000 cmp r4, #0
return msg_status;
3000f494: 01a00004 moveq r0, r4
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
3000f498: 0a000009 beq 3000f4c4 <_POSIX_Message_queue_Send_support+0xf0>
return msg_status;
rtems_set_errno_and_return_minus_one(
3000f49c: eb002542 bl 300189ac <__errno> <== NOT EXECUTED 3000f4a0: e1a05000 mov r5, r0 <== NOT EXECUTED 3000f4a4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f4a8: eb000056 bl 3000f608 <_POSIX_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED 3000f4ac: e5850000 str r0, [r5] <== NOT EXECUTED 3000f4b0: ea000002 b 3000f4c0 <_POSIX_Message_queue_Send_support+0xec><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f4b4: eb00253c bl 300189ac <__errno> <== NOT EXECUTED 3000f4b8: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f4bc: e5803000 str r3, [r0] <== NOT EXECUTED 3000f4c0: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000f4c4: e28dd014 add sp, sp, #20
3000f4c8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000f608 <_POSIX_Message_queue_Translate_core_message_queue_return_code>:
#if defined(RTEMS_DEBUG)
if ( the_message_queue_status > CORE_MESSAGE_QUEUE_STATUS_LAST )
return EINVAL;
#endif
return _POSIX_Message_queue_Return_codes[the_message_queue_status];
}
3000f608: e59f3004 ldr r3, [pc, #4] ; 3000f614 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0xc><== NOT EXECUTED 3000f60c: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000f610: e12fff1e bx lr <== NOT EXECUTED
3000a984 <_POSIX_Name_to_id>:
Objects_Information *information,
const char *name,
Objects_Id *id,
size_t *len
)
{
3000a984: e92d41f0 push {r4, r5, r6, r7, r8, lr}
int eno = EINVAL;
size_t n = 0;
if ( name != NULL && name [0] != '\0' ) {
3000a988: e2518000 subs r8, r1, #0
Objects_Information *information,
const char *name,
Objects_Id *id,
size_t *len
)
{
3000a98c: e1a04000 mov r4, r0 3000a990: e1a07002 mov r7, r2 3000a994: e1a06003 mov r6, r3
int eno = EINVAL;
size_t n = 0;
if ( name != NULL && name [0] != '\0' ) {
3000a998: 0a000011 beq 3000a9e4 <_POSIX_Name_to_id+0x60>
3000a99c: e5d85000 ldrb r5, [r8] 3000a9a0: e3550000 cmp r5, #0
3000a9a4: 0a00000f beq 3000a9e8 <_POSIX_Name_to_id+0x64>
n = strnlen( name, NAME_MAX );
3000a9a8: e1a00008 mov r0, r8 3000a9ac: e3a010ff mov r1, #255 ; 0xff 3000a9b0: eb002981 bl 30014fbc <strnlen>
if ( n < NAME_MAX ) {
3000a9b4: e35000fe cmp r0, #254 ; 0xfe
{
int eno = EINVAL;
size_t n = 0;
if ( name != NULL && name [0] != '\0' ) {
n = strnlen( name, NAME_MAX );
3000a9b8: e1a05000 mov r5, r0
eno = 0;
} else {
eno = ENOENT;
}
} else {
eno = ENAMETOOLONG;
3000a9bc: 83a0005b movhi r0, #91 ; 0x5b
size_t n = 0;
if ( name != NULL && name [0] != '\0' ) {
n = strnlen( name, NAME_MAX );
if ( n < NAME_MAX ) {
3000a9c0: 8a000009 bhi 3000a9ec <_POSIX_Name_to_id+0x68>
Objects_Name_or_id_lookup_errors status = _Objects_Name_to_id_string(
3000a9c4: e1a00004 mov r0, r4 3000a9c8: e1a01008 mov r1, r8 3000a9cc: e1a02007 mov r2, r7 3000a9d0: eb000b38 bl 3000d6b8 <_Objects_Name_to_id_string>
name,
id
);
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) {
eno = 0;
3000a9d4: e3500000 cmp r0, #0 3000a9d8: 13a00002 movne r0, #2 3000a9dc: 03a00000 moveq r0, #0 3000a9e0: ea000001 b 3000a9ec <_POSIX_Name_to_id+0x68>
Objects_Id *id,
size_t *len
)
{
int eno = EINVAL;
size_t n = 0;
3000a9e4: e1a05008 mov r5, r8 <== NOT EXECUTED
const char *name,
Objects_Id *id,
size_t *len
)
{
int eno = EINVAL;
3000a9e8: e3a00016 mov r0, #22 <== NOT EXECUTED
} else {
eno = ENAMETOOLONG;
}
}
*len = n;
3000a9ec: e5865000 str r5, [r6]
return eno;
}
3000a9f0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
300100d4 <_POSIX_Priority_Is_valid>:
bool _POSIX_Priority_Is_valid(
int priority
)
{
return ((priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY) &&
300100d4: e3500000 cmp r0, #0
300100d8: da000005 ble 300100f4 <_POSIX_Priority_Is_valid+0x20>
(priority <= POSIX_SCHEDULER_MAXIMUM_PRIORITY));
300100dc: e59f3018 ldr r3, [pc, #24] ; 300100fc <_POSIX_Priority_Is_valid+0x28> 300100e0: e5d33000 ldrb r3, [r3]
#endif
#include <rtems/system.h>
#include <rtems/posix/priority.h>
bool _POSIX_Priority_Is_valid(
300100e4: e1530000 cmp r3, r0 300100e8: d3a00000 movle r0, #0 300100ec: c3a00001 movgt r0, #1 300100f0: e12fff1e bx lr
int priority
)
{
return ((priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY) &&
300100f4: e3a00000 mov r0, #0 <== NOT EXECUTED
(priority <= POSIX_SCHEDULER_MAXIMUM_PRIORITY));
}
300100f8: e12fff1e bx lr <== NOT EXECUTED
30011098 <_POSIX_Semaphore_Create_support>:
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
30011098: e3520000 cmp r2, #0
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
3001109c: e92d40f0 push {r4, r5, r6, r7, lr}
300110a0: e1a04000 mov r4, r0
300110a4: e1a06001 mov r6, r1
300110a8: e1a07003 mov r7, r3
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
300110ac: 0a000002 beq 300110bc <_POSIX_Semaphore_Create_support+0x24>
rtems_set_errno_and_return_minus_one( ENOSYS );
300110b0: eb00099d bl 3001372c <__errno> <== NOT EXECUTED 300110b4: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300110b8: ea000018 b 30011120 <_POSIX_Semaphore_Create_support+0x88> <== 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;
300110bc: e59f30d8 ldr r3, [pc, #216] ; 3001119c <_POSIX_Semaphore_Create_support+0x104> 300110c0: e5932000 ldr r2, [r3]
++level;
300110c4: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
300110c8: e5832000 str r2, [r3]
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
300110cc: e59f00cc ldr r0, [pc, #204] ; 300111a0 <_POSIX_Semaphore_Create_support+0x108> 300110d0: ebffeffe bl 3000d0d0 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
300110d4: e2505000 subs r5, r0, #0
300110d8: 1a000003 bne 300110ec <_POSIX_Semaphore_Create_support+0x54>
_Thread_Enable_dispatch();
300110dc: ebfff4c1 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
300110e0: eb000991 bl 3001372c <__errno> <== NOT EXECUTED 300110e4: e3a0301c mov r3, #28 <== NOT EXECUTED 300110e8: ea00000c b 30011120 <_POSIX_Semaphore_Create_support+0x88> <== NOT EXECUTED
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
300110ec: e3540000 cmp r4, #0
300110f0: 0a00000d beq 3001112c <_POSIX_Semaphore_Create_support+0x94>
name = _Workspace_String_duplicate( name_arg, name_len );
300110f4: e1a00004 mov r0, r4 300110f8: e1a01006 mov r1, r6 300110fc: eb000432 bl 300121cc <_Workspace_String_duplicate>
if ( !name ) {
30011100: e2504000 subs r4, r0, #0
30011104: 1a000008 bne 3001112c <_POSIX_Semaphore_Create_support+0x94>
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
30011108: e59f0090 ldr r0, [pc, #144] ; 300111a0 <_POSIX_Semaphore_Create_support+0x108><== NOT EXECUTED 3001110c: e1a01005 mov r1, r5 <== NOT EXECUTED 30011110: ebfff0bd bl 3000d40c <_Objects_Free> <== NOT EXECUTED
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
30011114: ebfff4b3 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
30011118: eb000983 bl 3001372c <__errno> <== NOT EXECUTED
3001111c: e3a0300c mov r3, #12 <== NOT EXECUTED
30011120: e5803000 str r3, [r0] <== NOT EXECUTED
30011124: e3e00000 mvn r0, #0 <== NOT EXECUTED
30011128: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
3001112c: e3a03000 mov r3, #0
if ( name ) {
30011130: e1540003 cmp r4, r3
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
30011134: e5853010 str r3, [r5, #16]
if ( name ) {
the_semaphore->named = true;
30011138: 13a03001 movne r3, #1 3001113c: 15c53014 strbne r3, [r5, #20]
the_semaphore->open_count = 1;
30011140: 15853018 strne r3, [r5, #24]
the_semaphore->linked = true;
30011144: 15c53015 strbne r3, [r5, #21]
* blocking tasks on this semaphore should be. It could somehow * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
30011148: e3a06000 mov r6, #0
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
3001114c: e3e03000 mvn r3, #0
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
30011150: e285001c add r0, r5, #28
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
the_semaphore->linked = true;
} else {
the_semaphore->named = false;
30011154: 05c54014 strbeq r4, [r5, #20]
the_semaphore->open_count = 0;
30011158: 05854018 streq r4, [r5, #24]
the_semaphore->linked = false;
3001115c: 05c54015 strbeq r4, [r5, #21]
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
30011160: e585305c str r3, [r5, #92] ; 0x5c
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
30011164: e285105c add r1, r5, #92 ; 0x5c 30011168: e1a02007 mov r2, r7
* blocking tasks on this semaphore should be. It could somehow * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
3001116c: e5856060 str r6, [r5, #96] ; 0x60
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
30011170: ebffee57 bl 3000cad4 <_CORE_semaphore_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30011174: e59f3024 ldr r3, [pc, #36] ; 300111a0 <_POSIX_Semaphore_Create_support+0x108>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
30011178: e1d520b8 ldrh r2, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3001117c: e593301c ldr r3, [r3, #28] 30011180: e7835102 str r5, [r3, r2, lsl #2]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
30011184: e59d3014 ldr r3, [sp, #20]
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
30011188: e585400c str r4, [r5, #12] 3001118c: e5835000 str r5, [r3]
_Thread_Enable_dispatch();
30011190: ebfff494 bl 3000e3e8 <_Thread_Enable_dispatch>
return 0;
30011194: e1a00006 mov r0, r6
}
30011198: e8bd80f0 pop {r4, r5, r6, r7, pc}
3001017c <_POSIX_Semaphore_Wait_support>:
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
3001017c: e92d4031 push {r0, r4, r5, lr}
30010180: e1a03000 mov r3, r0
30010184: e1a04002 mov r4, r2
30010188: e20150ff and r5, r1, #255 ; 0xff
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
3001018c: e1a0200d mov r2, sp 30010190: e5931000 ldr r1, [r3] 30010194: e59f006c ldr r0, [pc, #108] ; 30010208 <_POSIX_Semaphore_Wait_support+0x8c> 30010198: ebfff0ca bl 3000c4c8 <_Objects_Get>
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3001019c: e59d2000 ldr r2, [sp] 300101a0: e1a03000 mov r3, r0 300101a4: e3520000 cmp r2, #0
300101a8: 1a000011 bne 300101f4 <_POSIX_Semaphore_Wait_support+0x78>
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
300101ac: e5931008 ldr r1, [r3, #8] 300101b0: e1a03004 mov r3, r4
blocking,
timeout
);
_Thread_Enable_dispatch();
if ( !_Thread_Executing->Wait.return_code )
300101b4: e59f4050 ldr r4, [pc, #80] ; 3001020c <_POSIX_Semaphore_Wait_support+0x90>
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
300101b8: e280001c add r0, r0, #28 300101bc: e1a02005 mov r2, r5 300101c0: eb000188 bl 300107e8 <_CORE_semaphore_Seize>
&the_semaphore->Semaphore,
the_semaphore->Object.id,
blocking,
timeout
);
_Thread_Enable_dispatch();
300101c4: ebfff42a bl 3000d274 <_Thread_Enable_dispatch>
if ( !_Thread_Executing->Wait.return_code )
300101c8: e5943008 ldr r3, [r4, #8] 300101cc: e5930034 ldr r0, [r3, #52] ; 0x34 300101d0: e3500000 cmp r0, #0
300101d4: 0a00000a beq 30010204 <_POSIX_Semaphore_Wait_support+0x88>
return 0;
rtems_set_errno_and_return_minus_one(
300101d8: eb0008fd bl 300125d4 <__errno> 300101dc: e5943008 ldr r3, [r4, #8] 300101e0: e1a05000 mov r5, r0 300101e4: e5930034 ldr r0, [r3, #52] ; 0x34 300101e8: eb000831 bl 300122b4 <_POSIX_Semaphore_Translate_core_semaphore_return_code> 300101ec: e5850000 str r0, [r5] 300101f0: ea000002 b 30010200 <_POSIX_Semaphore_Wait_support+0x84>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
300101f4: eb0008f6 bl 300125d4 <__errno> <== NOT EXECUTED 300101f8: e3a03016 mov r3, #22 <== NOT EXECUTED 300101fc: e5803000 str r3, [r0] <== NOT EXECUTED
30010200: e3e00000 mvn r0, #0
}
30010204: e8bd8038 pop {r3, r4, r5, pc}
3000a364 <_POSIX_Spinlock_Translate_core_spinlock_return_code>:
#if defined(RTEMS_DEBUG)
if ( the_spinlock_status > CORE_SPINLOCK_STATUS_LAST )
return EINVAL;
#endif
return _POSIX_Spinlock_Return_codes[the_spinlock_status];
}
3000a364: e59f3004 ldr r3, [pc, #4] ; 3000a370 <_POSIX_Spinlock_Translate_core_spinlock_return_code+0xc><== NOT EXECUTED 3000a368: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000a36c: e12fff1e bx lr <== NOT EXECUTED
3000edb4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
Thread_Control *the_thread
)
{
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000edb4: e59030f4 ldr r3, [r0, #244] ; 0xf4 <== NOT EXECUTED
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
3000edb8: e59320d8 ldr r2, [r3, #216] ; 0xd8 <== NOT EXECUTED 3000edbc: e3520000 cmp r2, #0 <== NOT EXECUTED 3000edc0: 1a00000b bne 3000edf4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x40><== NOT EXECUTED 3000edc4: e59320dc ldr r2, [r3, #220] ; 0xdc <== NOT EXECUTED 3000edc8: e3520001 cmp r2, #1 <== NOT EXECUTED 3000edcc: 1a000008 bne 3000edf4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x40><== NOT EXECUTED
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
3000edd0: e59330e0 ldr r3, [r3, #224] ; 0xe0 <== NOT EXECUTED 3000edd4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000edd8: 0a000005 beq 3000edf4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x40><== 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;
3000eddc: e59f3014 ldr r3, [pc, #20] ; 3000edf8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NOT EXECUTED
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
3000ede0: e3e01000 mvn r1, #0 <== NOT EXECUTED 3000ede4: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000ede8: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000edec: e5832000 str r2, [r3] <== NOT EXECUTED 3000edf0: ea0001b5 b 3000f4cc <_POSIX_Thread_Exit> <== NOT EXECUTED
} else
_Thread_Enable_dispatch();
3000edf4: eafff6ef b 3000c9b8 <_Thread_Enable_dispatch> <== NOT EXECUTED
300114e0 <_POSIX_Thread_Exit>:
void _POSIX_Thread_Exit(
Thread_Control *the_thread,
void *value_ptr
)
{
300114e0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
300114e4: e1a04000 mov r4, r0
Objects_Information *the_information;
Thread_Control *unblocked;
POSIX_API_Control *api;
the_information = _Objects_Get_information_id( the_thread->Object.id );
300114e8: e5900008 ldr r0, [r0, #8]
void _POSIX_Thread_Exit(
Thread_Control *the_thread,
void *value_ptr
)
{
300114ec: e1a0a001 mov sl, r1
Objects_Information *the_information;
Thread_Control *unblocked;
POSIX_API_Control *api;
the_information = _Objects_Get_information_id( the_thread->Object.id );
300114f0: ebffe919 bl 3000b95c <_Objects_Get_information_id>
* are ready to be switched out. Otherwise, an ISR could
* occur and preempt us out while we still hold the
* allocator mutex.
*/
_RTEMS_Lock_allocator();
300114f4: e59f60b4 ldr r6, [pc, #180] ; 300115b0 <_POSIX_Thread_Exit+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;
300114f8: e59f50b4 ldr r5, [pc, #180] ; 300115b4 <_POSIX_Thread_Exit+0xd4>
{
Objects_Information *the_information;
Thread_Control *unblocked;
POSIX_API_Control *api;
the_information = _Objects_Get_information_id( the_thread->Object.id );
300114fc: e1a07000 mov r7, r0
* are ready to be switched out. Otherwise, an ISR could
* occur and preempt us out while we still hold the
* allocator mutex.
*/
_RTEMS_Lock_allocator();
30011500: e5960000 ldr r0, [r6]
Thread_Control *unblocked;
POSIX_API_Control *api;
the_information = _Objects_Get_information_id( the_thread->Object.id );
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
30011504: e59480f4 ldr r8, [r4, #244] ; 0xf4
* are ready to be switched out. Otherwise, an ISR could
* occur and preempt us out while we still hold the
* allocator mutex.
*/
_RTEMS_Lock_allocator();
30011508: ebffe59b bl 3000ab7c <_API_Mutex_Lock> 3001150c: e5953000 ldr r3, [r5]
++level;
30011510: e2833001 add r3, r3, #1
_Thread_Dispatch_disable_level = level;
30011514: e5853000 str r3, [r5]
the_thread->Wait.return_argument = value_ptr;
/*
* Process join
*/
if ( api->detachstate == PTHREAD_CREATE_JOINABLE ) {
30011518: e5983040 ldr r3, [r8, #64] ; 0x40
*/
_RTEMS_Lock_allocator();
_Thread_Disable_dispatch();
the_thread->Wait.return_argument = value_ptr;
3001151c: e584a028 str sl, [r4, #40] ; 0x28
/*
* Process join
*/
if ( api->detachstate == PTHREAD_CREATE_JOINABLE ) {
30011520: e3530001 cmp r3, #1
30011524: 1a000016 bne 30011584 <_POSIX_Thread_Exit+0xa4>
unblocked = _Thread_queue_Dequeue( &api->Join_List );
30011528: e2888044 add r8, r8, #68 ; 0x44 3001152c: e1a00008 mov r0, r8 30011530: ebffeda2 bl 3000cbc0 <_Thread_queue_Dequeue>
if ( unblocked ) {
30011534: e3500000 cmp r0, #0
30011538: 0a000006 beq 30011558 <_POSIX_Thread_Exit+0x78>
do {
*(void **)unblocked->Wait.return_argument = value_ptr;
3001153c: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
} while ( (unblocked = _Thread_queue_Dequeue( &api->Join_List )) );
30011540: e1a00008 mov r0, r8 <== NOT EXECUTED
*/
if ( api->detachstate == PTHREAD_CREATE_JOINABLE ) {
unblocked = _Thread_queue_Dequeue( &api->Join_List );
if ( unblocked ) {
do {
*(void **)unblocked->Wait.return_argument = value_ptr;
30011544: e583a000 str sl, [r3] <== NOT EXECUTED
} while ( (unblocked = _Thread_queue_Dequeue( &api->Join_List )) );
30011548: ebffed9c bl 3000cbc0 <_Thread_queue_Dequeue> <== NOT EXECUTED 3001154c: e3500000 cmp r0, #0 <== NOT EXECUTED 30011550: 1afffff9 bne 3001153c <_POSIX_Thread_Exit+0x5c> <== NOT EXECUTED 30011554: ea00000a b 30011584 <_POSIX_Thread_Exit+0xa4> <== NOT EXECUTED
} else {
_Thread_Set_state(
30011558: e59f1058 ldr r1, [pc, #88] ; 300115b8 <_POSIX_Thread_Exit+0xd8> 3001155c: e1a00004 mov r0, r4 30011560: ebffeed4 bl 3000d0b8 <_Thread_Set_state>
the_thread,
STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT
);
_RTEMS_Unlock_allocator();
30011564: e5960000 ldr r0, [r6] 30011568: ebffe59c bl 3000abe0 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
3001156c: ebffecbf bl 3000c870 <_Thread_Enable_dispatch>
/* now waiting for thread to arrive */
_RTEMS_Lock_allocator();
30011570: e5960000 ldr r0, [r6] <== NOT EXECUTED 30011574: ebffe580 bl 3000ab7c <_API_Mutex_Lock> <== 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;
30011578: e5953000 ldr r3, [r5] <== NOT EXECUTED
++level;
3001157c: e2833001 add r3, r3, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30011580: e5853000 str r3, [r5] <== NOT EXECUTED
}
/*
* Now shut down the thread
*/
_Thread_Close( the_information, the_thread );
30011584: e1a00007 mov r0, r7 <== NOT EXECUTED 30011588: e1a01004 mov r1, r4 <== NOT EXECUTED 3001158c: ebffebec bl 3000c544 <_Thread_Close> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
30011590: e1a01004 mov r1, r4 <== NOT EXECUTED 30011594: e59f0020 ldr r0, [pc, #32] ; 300115bc <_POSIX_Thread_Exit+0xdc><== NOT EXECUTED 30011598: ebffe8d2 bl 3000b8e8 <_Objects_Free> <== NOT EXECUTED
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
3001159c: e59f300c ldr r3, [pc, #12] ; 300115b0 <_POSIX_Thread_Exit+0xd0><== NOT EXECUTED 300115a0: e5930000 ldr r0, [r3] <== NOT EXECUTED 300115a4: ebffe58d bl 3000abe0 <_API_Mutex_Unlock> <== NOT EXECUTED
_Thread_Enable_dispatch(); }
300115a8: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
_Thread_Close( the_information, the_thread );
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
_Thread_Enable_dispatch();
300115ac: eaffecaf b 3000c870 <_Thread_Enable_dispatch> <== NOT EXECUTED
30010100 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
30010100: e92d40f0 push {r4, r5, r6, r7, lr}
30010104: e1a04000 mov r4, r0
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
30010108: e5910000 ldr r0, [r1]
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
3001010c: e1a05001 mov r5, r1 30010110: e1a06002 mov r6, r2 30010114: e1a07003 mov r7, r3
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
30010118: ebffffed bl 300100d4 <_POSIX_Priority_Is_valid> 3001011c: e3500000 cmp r0, #0
30010120: 0a00002b beq 300101d4 <_POSIX_Thread_Translate_sched_param+0xd4>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
30010124: e3a00000 mov r0, #0
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
30010128: e1540000 cmp r4, r0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
3001012c: 03a03001 moveq r3, #1
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
30010130: e5860000 str r0, [r6]
*budget_callout = NULL;
30010134: e5870000 str r0, [r7]
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
30010138: 05863000 streq r3, [r6]
return 0;
3001013c: 01a00004 moveq r0, r4
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
30010140: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
30010144: e3540001 cmp r4, #1
30010148: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
3001014c: e3540002 cmp r4, #2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
30010150: 05864000 streq r4, [r6]
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
30010154: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
30010158: e3540004 cmp r4, #4 <== NOT EXECUTED 3001015c: 1a00001c bne 300101d4 <_POSIX_Thread_Translate_sched_param+0xd4><== NOT EXECUTED
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
30010160: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 30010164: e3530000 cmp r3, #0 <== NOT EXECUTED 30010168: 1a000002 bne 30010178 <_POSIX_Thread_Translate_sched_param+0x78><== NOT EXECUTED 3001016c: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 30010170: e3530000 cmp r3, #0 <== NOT EXECUTED 30010174: 0a000016 beq 300101d4 <_POSIX_Thread_Translate_sched_param+0xd4><== NOT EXECUTED
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
30010178: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED 3001017c: e3530000 cmp r3, #0 <== NOT EXECUTED 30010180: 1a000002 bne 30010190 <_POSIX_Thread_Translate_sched_param+0x90><== NOT EXECUTED 30010184: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 30010188: e3530000 cmp r3, #0 <== NOT EXECUTED 3001018c: 0a000010 beq 300101d4 <_POSIX_Thread_Translate_sched_param+0xd4><== NOT EXECUTED
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
30010190: e2850008 add r0, r5, #8 <== NOT EXECUTED 30010194: ebfff7ea bl 3000e144 <_Timespec_To_ticks> <== NOT EXECUTED 30010198: e1a04000 mov r4, r0 <== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
3001019c: e2850010 add r0, r5, #16 <== NOT EXECUTED 300101a0: ebfff7e7 bl 3000e144 <_Timespec_To_ticks> <== NOT EXECUTED
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
300101a4: e1540000 cmp r4, r0 <== NOT EXECUTED 300101a8: 3a000009 bcc 300101d4 <_POSIX_Thread_Translate_sched_param+0xd4><== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
300101ac: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 300101b0: ebffffc7 bl 300100d4 <_POSIX_Priority_Is_valid> <== NOT EXECUTED 300101b4: e3500000 cmp r0, #0 <== NOT EXECUTED 300101b8: 0a000007 beq 300101dc <_POSIX_Thread_Translate_sched_param+0xdc><== NOT EXECUTED
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
300101bc: e3a03003 mov r3, #3 <== NOT EXECUTED 300101c0: e5863000 str r3, [r6] <== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
300101c4: e59f3018 ldr r3, [pc, #24] ; 300101e4 <_POSIX_Thread_Translate_sched_param+0xe4><== NOT EXECUTED
return 0;
300101c8: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
300101cc: e5873000 str r3, [r7] <== NOT EXECUTED
return 0;
300101d0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
300101d4: e3a00016 mov r0, #22 <== NOT EXECUTED
300101d8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
300101dc: e3a00016 mov r0, #22 <== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
300101e0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f060 <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
3000f060: e92d40f0 push {r4, r5, r6, r7, lr}
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
3000f064: e1a00001 mov r0, r1
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
3000f068: e1a04001 mov r4, r1
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
3000f06c: e59150f4 ldr r5, [r1, #244] ; 0xf4
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
3000f070: eb00085f bl 300111f4 <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
3000f074: e1a00004 mov r0, r4 3000f078: eb000874 bl 30011250 <_POSIX_Keys_Run_destructors>
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
3000f07c: e2856044 add r6, r5, #68 ; 0x44
_POSIX_Keys_Run_destructors( deleted );
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
3000f080: e5947028 ldr r7, [r4, #40] ; 0x28
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
3000f084: ea000001 b 3000f090 <_POSIX_Threads_Delete_extension+0x30>
*(void **)the_thread->Wait.return_argument = value_ptr;
3000f088: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 3000f08c: e5837000 str r7, [r3] <== NOT EXECUTED
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
3000f090: e1a00006 mov r0, r6 3000f094: ebfff6c9 bl 3000cbc0 <_Thread_queue_Dequeue> 3000f098: e3500000 cmp r0, #0
3000f09c: 1afffff9 bne 3000f088 <_POSIX_Threads_Delete_extension+0x28>
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
3000f0a0: e5953084 ldr r3, [r5, #132] ; 0x84 3000f0a4: e3530004 cmp r3, #4
(void) _Watchdog_Remove( &api->Sporadic_timer );
3000f0a8: 028500a8 addeq r0, r5, #168 ; 0xa8 3000f0ac: 0bfff932 bleq 3000d57c <_Watchdog_Remove>
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
3000f0b0: e3a03000 mov r3, #0
_Workspace_Free( api );
3000f0b4: e1a00005 mov r0, r5
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
3000f0b8: e58430f4 str r3, [r4, #244] ; 0xf4
_Workspace_Free( api );
}
3000f0bc: e8bd40f0 pop {r4, r5, r6, r7, lr}
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
_Workspace_Free( api );
3000f0c0: eafff9bd b 3000d7bc <_Workspace_Free>
3000f1e0 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
3000f1e0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000f1e4: e59140f4 ldr r4, [r1, #244] ; 0xf4 <== NOT EXECUTED
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
3000f1e8: e1a05001 mov r5, r1 <== NOT EXECUTED
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
3000f1ec: e2840098 add r0, r4, #152 ; 0x98 <== NOT EXECUTED 3000f1f0: eb0003e9 bl 3001019c <_Timespec_To_ticks> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000f1f4: e59f304c ldr r3, [pc, #76] ; 3000f248 <_POSIX_Threads_Sporadic_budget_TSR+0x68><== NOT EXECUTED
the_thread->cpu_time_budget = ticks;
3000f1f8: e5850074 str r0, [r5, #116] ; 0x74 <== NOT EXECUTED 3000f1fc: e5d31000 ldrb r1, [r3] <== NOT EXECUTED 3000f200: e5943088 ldr r3, [r4, #136] ; 0x88 <== NOT EXECUTED 3000f204: e0631001 rsb r1, r3, r1 <== NOT EXECUTED
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
3000f208: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
the_thread->cpu_time_budget = ticks;
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
3000f20c: e5851018 str r1, [r5, #24] <== NOT EXECUTED
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
3000f210: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f214: 1a000004 bne 3000f22c <_POSIX_Threads_Sporadic_budget_TSR+0x4c><== NOT EXECUTED
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
3000f218: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3000f21c: e1530001 cmp r3, r1 <== NOT EXECUTED
_Thread_Change_priority( the_thread, new_priority, true );
3000f220: 81a00005 movhi r0, r5 <== NOT EXECUTED 3000f224: 83a02001 movhi r2, #1 <== NOT EXECUTED 3000f228: 8bfff477 blhi 3000c40c <_Thread_Change_priority> <== NOT EXECUTED
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
3000f22c: e2840090 add r0, r4, #144 ; 0x90 <== NOT EXECUTED 3000f230: eb0003d9 bl 3001019c <_Timespec_To_ticks> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000f234: e58400b4 str r0, [r4, #180] ; 0xb4 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000f238: e59f000c ldr r0, [pc, #12] ; 3000f24c <_POSIX_Threads_Sporadic_budget_TSR+0x6c><== NOT EXECUTED 3000f23c: e28410a8 add r1, r4, #168 ; 0xa8 <== NOT EXECUTED
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
3000f240: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3000f244: eafff875 b 3000d420 <_Watchdog_Insert> <== NOT EXECUTED
3000f250 <_POSIX_Threads_Sporadic_budget_callout>:
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
3000f250: e3e01000 mvn r1, #0 <== NOT EXECUTED
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000f254: e59020f4 ldr r2, [r0, #244] ; 0xf4 <== NOT EXECUTED
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
3000f258: e5801074 str r1, [r0, #116] ; 0x74 <== NOT EXECUTED 3000f25c: e59f102c ldr r1, [pc, #44] ; 3000f290 <_POSIX_Threads_Sporadic_budget_callout+0x40><== NOT EXECUTED 3000f260: e592208c ldr r2, [r2, #140] ; 0x8c <== NOT EXECUTED 3000f264: e5d11000 ldrb r1, [r1] <== NOT EXECUTED 3000f268: e0621001 rsb r1, r2, r1 <== NOT EXECUTED
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
3000f26c: e590201c ldr r2, [r0, #28] <== NOT EXECUTED
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
3000f270: e5801018 str r1, [r0, #24] <== NOT EXECUTED
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
3000f274: e3520000 cmp r2, #0 <== NOT EXECUTED 3000f278: 112fff1e bxne lr <== NOT EXECUTED
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
3000f27c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000f280: e1530001 cmp r3, r1 <== NOT EXECUTED 3000f284: 212fff1e bxcs lr <== NOT EXECUTED
_Thread_Change_priority( the_thread, new_priority, true );
3000f288: e3a02001 mov r2, #1 <== NOT EXECUTED 3000f28c: eafff45e b 3000c40c <_Thread_Change_priority> <== NOT EXECUTED
300111f4 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
300111f4: e92d4070 push {r4, r5, r6, lr}
POSIX_Cancel_Handler_control *handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
300111f8: e59050f4 ldr r5, [r0, #244] ; 0xf4
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
300111fc: e3a03001 mov r3, #1 30011200: e58530d8 str r3, [r5, #216] ; 0xd8
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30011204: e28560e8 add r6, r5, #232 ; 0xe8
while ( !_Chain_Is_empty( handler_stack ) ) {
30011208: ea00000c b 30011240 <_POSIX_Threads_cancel_run+0x4c>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001120c: e10f1000 mrs r1, CPSR <== NOT EXECUTED 30011210: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 30011214: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Disable( level );
handler = (POSIX_Cancel_Handler_control *)
30011218: e59540ec ldr r4, [r5, #236] ; 0xec <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3001121c: e894000c ldm r4, {r2, r3} <== NOT EXECUTED
next->previous = previous;
30011220: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
30011224: e5832000 str r2, [r3] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30011228: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
(*handler->routine)( handler->arg );
3001122c: e594000c ldr r0, [r4, #12] <== NOT EXECUTED 30011230: e1a0e00f mov lr, pc <== NOT EXECUTED 30011234: e594f008 ldr pc, [r4, #8] <== NOT EXECUTED
_Workspace_Free( handler );
30011238: e1a00004 mov r0, r4 <== NOT EXECUTED 3001123c: ebfff15e bl 3000d7bc <_Workspace_Free> <== NOT EXECUTED
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
30011240: e59530e4 ldr r3, [r5, #228] ; 0xe4 30011244: e1530006 cmp r3, r6
30011248: 1affffef bne 3001120c <_POSIX_Threads_cancel_run+0x18>
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
3001124c: e8bd8070 pop {r4, r5, r6, pc}
3000fa74 <_POSIX_Timer_Insert_helper>:
Watchdog_Interval ticks,
Objects_Id id,
Watchdog_Service_routine_entry TSR,
void *arg
)
{
3000fa74: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000fa78: e1a04000 mov r4, r0 <== NOT EXECUTED
3000fa7c: e1a05001 mov r5, r1 <== NOT EXECUTED
3000fa80: e1a07002 mov r7, r2 <== NOT EXECUTED
3000fa84: e1a08003 mov r8, r3 <== NOT EXECUTED
ISR_Level level;
(void) _Watchdog_Remove( timer );
3000fa88: ebfff843 bl 3000db9c <_Watchdog_Remove> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000fa8c: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000fa90: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000fa94: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( timer->state != WATCHDOG_INACTIVE ) {
3000fa98: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000fa9c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000faa0: 0a000002 beq 3000fab0 <_POSIX_Timer_Insert_helper+0x3c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000faa4: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
return false;
3000faa8: e3a00000 mov r0, #0 <== NOT EXECUTED
3000faac: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000fab0: e5843008 str r3, [r4, #8] <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3000fab4: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000fab8: e584801c str r8, [r4, #28] <== NOT EXECUTED
the_watchdog->id = id;
3000fabc: e5847020 str r7, [r4, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000fac0: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000fac4: e584500c str r5, [r4, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000fac8: e59f0010 ldr r0, [pc, #16] ; 3000fae0 <_POSIX_Timer_Insert_helper+0x6c><== NOT EXECUTED 3000facc: e1a01004 mov r1, r4 <== NOT EXECUTED 3000fad0: ebfff7da bl 3000da40 <_Watchdog_Insert> <== NOT EXECUTED 3000fad4: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
* so we can atomically initialize it as in use.
*/
_Watchdog_Initialize( timer, TSR, id, arg );
_Watchdog_Insert_ticks( timer, ticks );
_ISR_Enable( level );
return true;
3000fad8: e3a00001 mov r0, #1 <== NOT EXECUTED
}
3000fadc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30009f60 <_POSIX_Timer_TSR>:
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
30009f60: e5913068 ldr r3, [r1, #104] ; 0x68 <== NOT EXECUTED
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
30009f64: e92d40d7 push {r0, r1, r2, r4, r6, r7, lr} <== NOT EXECUTED
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
30009f68: e2833001 add r3, r3, #1 <== NOT EXECUTED 30009f6c: e5813068 str r3, [r1, #104] ; 0x68 <== NOT EXECUTED
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
30009f70: e5913054 ldr r3, [r1, #84] ; 0x54 <== NOT EXECUTED
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
30009f74: e1a04001 mov r4, r1 <== NOT EXECUTED
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
30009f78: e3530000 cmp r3, #0 <== NOT EXECUTED 30009f7c: 1a000003 bne 30009f90 <_POSIX_Timer_TSR+0x30> <== NOT EXECUTED 30009f80: e5913058 ldr r3, [r1, #88] ; 0x58 <== NOT EXECUTED 30009f84: e3530000 cmp r3, #0 <== NOT EXECUTED
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
30009f88: 03a03004 moveq r3, #4 <== NOT EXECUTED
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
30009f8c: 0a000018 beq 30009ff4 <_POSIX_Timer_TSR+0x94> <== NOT EXECUTED
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
30009f90: e2840010 add r0, r4, #16 <== NOT EXECUTED 30009f94: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 30009f98: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 30009f9c: e59f306c ldr r3, [pc, #108] ; 3000a010 <_POSIX_Timer_TSR+0xb0><== NOT EXECUTED 30009fa0: e58d4000 str r4, [sp] <== NOT EXECUTED 30009fa4: eb0016b2 bl 3000fa74 <_POSIX_Timer_Insert_helper> <== NOT EXECUTED
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
30009fa8: e3500000 cmp r0, #0 <== NOT EXECUTED 30009fac: 0a000016 beq 3000a00c <_POSIX_Timer_TSR+0xac> <== NOT EXECUTED
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
30009fb0: e59f105c ldr r1, [pc, #92] ; 3000a014 <_POSIX_Timer_TSR+0xb4><== NOT EXECUTED 30009fb4: e28d0004 add r0, sp, #4 <== NOT EXECUTED 30009fb8: eb000583 bl 3000b5cc <_TOD_Get_with_nanoseconds> <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30009fbc: e59f2054 ldr r2, [pc, #84] ; 3000a018 <_POSIX_Timer_TSR+0xb8><== NOT EXECUTED
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
30009fc0: e89000c0 ldm r0, {r6, r7} <== NOT EXECUTED
30009fc4: e3a03000 mov r3, #0 <== NOT EXECUTED
30009fc8: e1a00006 mov r0, r6 <== NOT EXECUTED
30009fcc: e1a01007 mov r1, r7 <== NOT EXECUTED
30009fd0: eb004829 bl 3001c07c <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30009fd4: e3a03000 mov r3, #0 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30009fd8: e584006c str r0, [r4, #108] ; 0x6c <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30009fdc: e1a01007 mov r1, r7 <== NOT EXECUTED 30009fe0: e1a00006 mov r0, r6 <== NOT EXECUTED 30009fe4: e59f202c ldr r2, [pc, #44] ; 3000a018 <_POSIX_Timer_TSR+0xb8><== NOT EXECUTED 30009fe8: eb00495e bl 3001c568 <__moddi3> <== NOT EXECUTED
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
30009fec: e3a03003 mov r3, #3 <== NOT EXECUTED 30009ff0: e5840070 str r0, [r4, #112] ; 0x70 <== NOT EXECUTED
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
30009ff4: e5c4303c strb r3, [r4, #60] ; 0x3c <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
30009ff8: e5940038 ldr r0, [r4, #56] ; 0x38 <== NOT EXECUTED 30009ffc: e5941044 ldr r1, [r4, #68] ; 0x44 <== NOT EXECUTED 3000a000: eb00158f bl 3000f644 <pthread_kill> <== NOT EXECUTED
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
3000a004: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a008: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
}
3000a00c: e8bd80de pop {r1, r2, r3, r4, r6, r7, pc} <== NOT EXECUTED
3000eee0 <_POSIX_signals_Abnormal_termination_handler>:
sigset_t _POSIX_signals_Pending;
void _POSIX_signals_Abnormal_termination_handler(
int signo __attribute__((unused)) )
{
3000eee0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
exit( 1 );
3000eee4: e3a00001 mov r0, #1 <== NOT EXECUTED 3000eee8: eb000aa3 bl 3001197c <exit> <== NOT EXECUTED
3000bbf0 <_POSIX_signals_Alarm_TSR>:
static void _POSIX_signals_Alarm_TSR(
Objects_Id id __attribute__((unused)),
void *argument __attribute__((unused))
)
{
3000bbf0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
kill( getpid(), SIGALRM );
3000bbf4: ebfff293 bl 30008648 <getpid> <== NOT EXECUTED 3000bbf8: e3a0100e mov r1, #14 <== NOT EXECUTED
/* XXX can't print from an ISR, should this be fatal? */ }
3000bbfc: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
static void _POSIX_signals_Alarm_TSR(
Objects_Id id __attribute__((unused)),
void *argument __attribute__((unused))
)
{
kill( getpid(), SIGALRM );
3000bc00: ea00004c b 3000bd38 <kill> <== NOT EXECUTED
300112e4 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
300112e4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
300112e8: e20230ff and r3, r2, #255 ; 0xff <== NOT EXECUTED
300112ec: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
300112f0: e3a02001 mov r2, #1 <== NOT EXECUTED 300112f4: e58d2000 str r2, [sp] <== NOT EXECUTED 300112f8: e28d202c add r2, sp, #44 ; 0x2c <== NOT EXECUTED
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
300112fc: e1a04000 mov r4, r0 <== NOT EXECUTED 30011300: e1a05001 mov r5, r1 <== NOT EXECUTED
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
30011304: eb000031 bl 300113d0 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 30011308: e3500000 cmp r0, #0 <== NOT EXECUTED 3001130c: 0a00002b beq 300113c0 <_POSIX_signals_Check_signal+0xdc> <== NOT EXECUTED
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
30011310: e3a0a00c mov sl, #12 <== NOT EXECUTED 30011314: e00a0a95 mul sl, r5, sl <== NOT EXECUTED 30011318: e59f80a8 ldr r8, [pc, #168] ; 300113c8 <_POSIX_signals_Check_signal+0xe4><== NOT EXECUTED 3001131c: e088300a add r3, r8, sl <== NOT EXECUTED 30011320: e593c008 ldr ip, [r3, #8] <== NOT EXECUTED 30011324: e35c0001 cmp ip, #1 <== NOT EXECUTED
return false;
30011328: 03a00000 moveq r0, #0 <== NOT EXECUTED
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
3001132c: 0a000023 beq 300113c0 <_POSIX_signals_Check_signal+0xdc> <== NOT EXECUTED
/* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
30011330: e59f7094 ldr r7, [pc, #148] ; 300113cc <_POSIX_signals_Check_signal+0xe8><== NOT EXECUTED
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
30011334: e59490d0 ldr r9, [r4, #208] ; 0xd0 <== NOT EXECUTED
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
30011338: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
/* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
3001133c: e5976008 ldr r6, [r7, #8] <== NOT EXECUTED
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
30011340: e1833009 orr r3, r3, r9 <== NOT EXECUTED 30011344: e58430d0 str r3, [r4, #208] ; 0xd0 <== NOT EXECUTED
/* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
30011348: e28de004 add lr, sp, #4 <== NOT EXECUTED
3001134c: e2866020 add r6, r6, #32 <== NOT EXECUTED
30011350: e8b6000f ldm r6!, {r0, r1, r2, r3} <== NOT EXECUTED
30011354: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30011358: e8b6000f ldm r6!, {r0, r1, r2, r3} <== NOT EXECUTED
3001135c: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30011360: e8960003 ldm r6, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
30011364: e798300a ldr r3, [r8, sl] <== NOT EXECUTED
/* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
30011368: e88e0003 stm lr, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
3001136c: e3530002 cmp r3, #2 <== NOT EXECUTED
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
30011370: e1a00005 mov r0, r5 <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
30011374: 1a000004 bne 3001138c <_POSIX_signals_Check_signal+0xa8> <== NOT EXECUTED
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
30011378: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 3001137c: e3a02000 mov r2, #0 <== NOT EXECUTED 30011380: e1a0e00f mov lr, pc <== NOT EXECUTED 30011384: e12fff1c bx ip <== NOT EXECUTED
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
30011388: ea000001 b 30011394 <_POSIX_signals_Check_signal+0xb0> <== NOT EXECUTED
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
3001138c: e1a0e00f mov lr, pc <== NOT EXECUTED 30011390: e12fff1c bx ip <== NOT EXECUTED
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
30011394: e597c008 ldr ip, [r7, #8] <== NOT EXECUTED
30011398: e28d5004 add r5, sp, #4 <== NOT EXECUTED
3001139c: e28cc020 add ip, ip, #32 <== NOT EXECUTED
300113a0: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
300113a4: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
300113a8: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
300113ac: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
300113b0: e8950003 ldm r5, {r0, r1} <== NOT EXECUTED
300113b4: e88c0003 stm ip, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
300113b8: e58490d0 str r9, [r4, #208] ; 0xd0 <== NOT EXECUTED
return true;
300113bc: e3a00001 mov r0, #1 <== NOT EXECUTED
}
300113c0: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
300113c4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
300118dc <_POSIX_signals_Clear_process_signals>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
300118dc: e10f1000 mrs r1, CPSR <== NOT EXECUTED 300118e0: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 300118e4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
300118e8: e3a0300c mov r3, #12 <== NOT EXECUTED 300118ec: e0030390 mul r3, r0, r3 <== NOT EXECUTED 300118f0: e59f2040 ldr r2, [pc, #64] ; 30011938 <_POSIX_signals_Clear_process_signals+0x5c><== NOT EXECUTED 300118f4: e7922003 ldr r2, [r2, r3] <== NOT EXECUTED 300118f8: e3520002 cmp r2, #2 <== NOT EXECUTED 300118fc: 1a000005 bne 30011918 <_POSIX_signals_Clear_process_signals+0x3c><== NOT EXECUTED
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
30011900: e59f2034 ldr r2, [pc, #52] ; 3001193c <_POSIX_signals_Clear_process_signals+0x60><== NOT EXECUTED 30011904: e083c002 add ip, r3, r2 <== NOT EXECUTED 30011908: e7933002 ldr r3, [r3, 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 );
3001190c: e28cc004 add ip, ip, #4 <== NOT EXECUTED 30011910: e153000c cmp r3, ip <== NOT EXECUTED 30011914: 1a000005 bne 30011930 <_POSIX_signals_Clear_process_signals+0x54><== NOT EXECUTED
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
30011918: e59f3020 ldr r3, [pc, #32] ; 30011940 <_POSIX_signals_Clear_process_signals+0x64><== NOT EXECUTED 3001191c: e2400001 sub r0, r0, #1 <== NOT EXECUTED 30011920: e5932000 ldr r2, [r3] <== NOT EXECUTED 30011924: e3a0c001 mov ip, #1 <== NOT EXECUTED 30011928: e1c2001c bic r0, r2, ip, lsl r0 <== NOT EXECUTED 3001192c: e5830000 str r0, [r3] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30011930: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
}
_ISR_Enable( level );
}
30011934: e12fff1e bx lr <== NOT EXECUTED
300113d0 <_POSIX_signals_Clear_signals>:
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
300113d0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
300113d4: e5ddc014 ldrb ip, [sp, #20] <== NOT EXECUTED
300113d8: e1a04001 mov r4, r1 <== NOT EXECUTED
/* set blocked signals based on if checking for them, SIGNAL_ALL_MASK
* insures that no signals are blocked and all are checked.
*/
if ( check_blocked )
300113dc: e35c0000 cmp ip, #0 <== NOT EXECUTED
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
300113e0: e1a05002 mov r5, r2 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
300113e4: e2412001 sub r2, r1, #1 <== NOT EXECUTED 300113e8: e3a01001 mov r1, #1 <== NOT EXECUTED 300113ec: e1a01211 lsl r1, r1, r2 <== NOT EXECUTED
/* set blocked signals based on if checking for them, SIGNAL_ALL_MASK
* insures that no signals are blocked and all are checked.
*/
if ( check_blocked )
signals_blocked = ~api->signals_blocked;
300113f0: 159020d0 ldrne r2, [r0, #208] ; 0xd0 <== NOT EXECUTED
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
300113f4: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED
/* set blocked signals based on if checking for them, SIGNAL_ALL_MASK
* insures that no signals are blocked and all are checked.
*/
if ( check_blocked )
signals_blocked = ~api->signals_blocked;
300113f8: 11e02002 mvnne r2, r2 <== NOT EXECUTED
else
signals_blocked = SIGNAL_ALL_MASK;
300113fc: 03e02000 mvneq r2, #0 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30011400: e10f7000 mrs r7, CPSR <== NOT EXECUTED 30011404: e387c080 orr ip, r7, #128 ; 0x80 <== NOT EXECUTED 30011408: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
/* XXX is this right for siginfo type signals? */
/* XXX are we sure they can be cleared the same way? */
_ISR_Disable( level );
if ( is_global ) {
3001140c: e3530000 cmp r3, #0 <== NOT EXECUTED 30011410: 0a000024 beq 300114a8 <_POSIX_signals_Clear_signals+0xd8> <== NOT EXECUTED
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
30011414: e59f30b4 ldr r3, [pc, #180] ; 300114d0 <_POSIX_signals_Clear_signals+0x100><== NOT EXECUTED 30011418: e5930000 ldr r0, [r3] <== NOT EXECUTED 3001141c: e0011000 and r1, r1, r0 <== NOT EXECUTED 30011420: e0110002 ands r0, r1, r2 <== NOT EXECUTED 30011424: 0a000027 beq 300114c8 <_POSIX_signals_Clear_signals+0xf8> <== NOT EXECUTED
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
30011428: e3a0300c mov r3, #12 <== NOT EXECUTED 3001142c: e0030394 mul r3, r4, r3 <== NOT EXECUTED 30011430: e59f209c ldr r2, [pc, #156] ; 300114d4 <_POSIX_signals_Clear_signals+0x104><== NOT EXECUTED 30011434: e7922003 ldr r2, [r2, r3] <== NOT EXECUTED 30011438: e3520002 cmp r2, #2 <== NOT EXECUTED 3001143c: 1a000016 bne 3001149c <_POSIX_signals_Clear_signals+0xcc> <== NOT EXECUTED
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
30011440: e59f2090 ldr r2, [pc, #144] ; 300114d8 <_POSIX_signals_Clear_signals+0x108><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
30011444: e7926003 ldr r6, [r2, r3] <== NOT EXECUTED 30011448: e0820003 add r0, r2, r3 <== 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 );
3001144c: e2801004 add r1, r0, #4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
30011450: e1560001 cmp r6, r1 <== 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;
30011454: 15961000 ldrne r1, [r6] <== NOT EXECUTED
)
{
if ( !_Chain_Is_empty(the_chain))
return _Chain_Get_first_unprotected(the_chain);
else
return NULL;
30011458: 03a06000 moveq r6, #0 <== 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;
new_first->previous = head;
3001145c: 15810004 strne r0, [r1, #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;
30011460: 17821003 strne r1, [r2, r3] <== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
30011464: e1a00004 mov r0, r4 <== NOT EXECUTED 30011468: eb00011b bl 300118dc <_POSIX_signals_Clear_process_signals><== NOT EXECUTED
/*
* It may be impossible to get here with an empty chain
* BUT until that is proven we need to be defensive and
* protect against it.
*/
if ( psiginfo ) {
3001146c: e3560000 cmp r6, #0 <== NOT EXECUTED 30011470: 0a000009 beq 3001149c <_POSIX_signals_Clear_signals+0xcc> <== NOT EXECUTED
*info = psiginfo->Info;
30011474: e2863008 add r3, r6, #8 <== NOT EXECUTED
30011478: e8930007 ldm r3, {r0, r1, r2} <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3001147c: e59f3058 ldr r3, [pc, #88] ; 300114dc <_POSIX_signals_Clear_signals+0x10c><== NOT EXECUTED
30011480: e8850007 stm r5, {r0, r1, r2} <== NOT EXECUTED
30011484: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
the_node->next = tail;
30011488: e2831004 add r1, r3, #4 <== NOT EXECUTED 3001148c: e5861000 str r1, [r6] <== NOT EXECUTED
tail->previous = the_node;
30011490: e5836008 str r6, [r3, #8] <== NOT EXECUTED
old_last->next = the_node;
30011494: e5826000 str r6, [r2] <== NOT EXECUTED
the_node->previous = old_last;
30011498: e5862004 str r2, [r6, #4] <== NOT EXECUTED
&psiginfo->Node
);
} else
do_callout = false;
}
_POSIX_signals_Clear_process_signals( signo );
3001149c: e1a00004 mov r0, r4 <== NOT EXECUTED 300114a0: eb00010d bl 300118dc <_POSIX_signals_Clear_process_signals><== NOT EXECUTED 300114a4: ea000006 b 300114c4 <_POSIX_signals_Clear_signals+0xf4> <== NOT EXECUTED
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
300114a8: e590c0d4 ldr ip, [r0, #212] ; 0xd4 <== NOT EXECUTED 300114ac: e001400c and r4, r1, ip <== NOT EXECUTED 300114b0: e1140002 tst r4, r2 <== NOT EXECUTED
bool do_callout;
POSIX_signals_Siginfo_node *psiginfo;
mask = signo_to_mask( signo );
do_callout = false;
300114b4: 01a00003 moveq r0, r3 <== NOT EXECUTED
}
_POSIX_signals_Clear_process_signals( signo );
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
300114b8: 0a000002 beq 300114c8 <_POSIX_signals_Clear_signals+0xf8> <== NOT EXECUTED
api->signals_pending &= ~mask;
300114bc: e1cc1001 bic r1, ip, r1 <== NOT EXECUTED 300114c0: e58010d4 str r1, [r0, #212] ; 0xd4 <== NOT EXECUTED
do_callout = true;
300114c4: e3a00001 mov r0, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300114c8: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
}
}
_ISR_Enable( level );
return do_callout;
}
300114cc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000ad08 <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000ad08: e3a0301b mov r3, #27 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3000ad0c: e3a02001 mov r2, #1 <== NOT EXECUTED
#include <rtems/posix/psignalimpl.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
3000ad10: e2431001 sub r1, r3, #1 <== NOT EXECUTED
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
3000ad14: e0101112 ands r1, r0, r2, lsl r1 <== NOT EXECUTED 3000ad18: 1a00000a bne 3000ad48 <_POSIX_signals_Get_lowest+0x40> <== NOT EXECUTED
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000ad1c: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000ad20: e3530020 cmp r3, #32 <== NOT EXECUTED 3000ad24: 1afffff9 bne 3000ad10 <_POSIX_signals_Get_lowest+0x8> <== NOT EXECUTED 3000ad28: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ad2c: e1a02003 mov r2, r3 <== NOT EXECUTED
#include <rtems/posix/psignalimpl.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
3000ad30: e2431001 sub r1, r3, #1 <== NOT EXECUTED
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
3000ad34: e0101112 ands r1, r0, r2, lsl r1 <== NOT EXECUTED 3000ad38: 1a000002 bne 3000ad48 <_POSIX_signals_Get_lowest+0x40> <== NOT EXECUTED
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
3000ad3c: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000ad40: e353001b cmp r3, #27 <== NOT EXECUTED 3000ad44: 1afffff9 bne 3000ad30 <_POSIX_signals_Get_lowest+0x28> <== NOT EXECUTED
* a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; }
3000ad48: e1a00003 mov r0, r3 <== NOT EXECUTED 3000ad4c: e12fff1e bx lr <== NOT EXECUTED
3000ee1c <_POSIX_signals_Post_switch_hook>:
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
3000ee1c: e59f30b4 ldr r3, [pc, #180] ; 3000eed8 <_POSIX_signals_Post_switch_hook+0xbc>
*/
static void _POSIX_signals_Post_switch_hook(
Thread_Control *the_thread
)
{
3000ee20: e92d40f0 push {r4, r5, r6, r7, lr}
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000ee24: e59040f4 ldr r4, [r0, #244] ; 0xf4
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
3000ee28: e5933008 ldr r3, [r3, #8]
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
3000ee2c: e3540000 cmp r4, #0
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
3000ee30: e5936034 ldr r6, [r3, #52] ; 0x34
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
3000ee34: 08bd80f0 popeq {r4, r5, r6, r7, pc}
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
3000ee38: e59f709c ldr r7, [pc, #156] ; 3000eedc <_POSIX_signals_Post_switch_hook+0xc0>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ee3c: e10f3000 mrs r3, CPSR 3000ee40: e3832080 orr r2, r3, #128 ; 0x80 3000ee44: e129f002 msr CPSR_fc, r2 3000ee48: e5971000 ldr r1, [r7] 3000ee4c: e59420d4 ldr r2, [r4, #212] ; 0xd4 3000ee50: e1812002 orr r2, r1, r2
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
3000ee54: e59410d0 ldr r1, [r4, #208] ; 0xd0
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ee58: e129f003 msr CPSR_fc, r3 3000ee5c: e1d21001 bics r1, r2, r1
3000ee60: 1a000003 bne 3000ee74 <_POSIX_signals_Post_switch_hook+0x58>
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
}
_Thread_Executing->Wait.return_code = hold_errno;
3000ee64: e59f306c ldr r3, [pc, #108] ; 3000eed8 <_POSIX_signals_Post_switch_hook+0xbc>
3000ee68: e5933008 ldr r3, [r3, #8]
3000ee6c: e5836034 str r6, [r3, #52] ; 0x34
3000ee70: e8bd80f0 pop {r4, r5, r6, r7, pc}
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000ee74: e3a0501b mov r5, #27 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
3000ee78: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ee7c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000ee80: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ee84: eb000916 bl 300112e4 <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
3000ee88: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ee8c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ee90: e3a02001 mov r2, #1 <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000ee94: e2855001 add r5, r5, #1 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
3000ee98: eb000911 bl 300112e4 <_POSIX_signals_Check_signal> <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000ee9c: e3550020 cmp r5, #32 <== NOT EXECUTED 3000eea0: 1afffff4 bne 3000ee78 <_POSIX_signals_Post_switch_hook+0x5c><== NOT EXECUTED 3000eea4: e3a05001 mov r5, #1 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
3000eea8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000eeac: e3a02000 mov r2, #0 <== NOT EXECUTED 3000eeb0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000eeb4: eb00090a bl 300112e4 <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
3000eeb8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000eebc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000eec0: e3a02001 mov r2, #1 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
3000eec4: e2855001 add r5, r5, #1 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
3000eec8: eb000905 bl 300112e4 <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
3000eecc: e355001b cmp r5, #27 <== NOT EXECUTED 3000eed0: 1afffff4 bne 3000eea8 <_POSIX_signals_Post_switch_hook+0x8c><== NOT EXECUTED 3000eed4: eaffffd8 b 3000ee3c <_POSIX_signals_Post_switch_hook+0x20> <== NOT EXECUTED
30009e98 <_POSIX_signals_Ualarm_TSR>:
static void _POSIX_signals_Ualarm_TSR(
Objects_Id id __attribute__((unused)),
void *argument __attribute__((unused))
)
{
30009e98: e92d4010 push {r4, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Reset(
Watchdog_Control *the_watchdog
)
{
(void) _Watchdog_Remove( the_watchdog );
30009e9c: e59f4020 ldr r4, [pc, #32] ; 30009ec4 <_POSIX_signals_Ualarm_TSR+0x2c><== NOT EXECUTED
/* * Send a SIGALRM but if there is a problem, ignore it. * It's OK, there isn't a way this should fail. */ (void) kill( getpid(), SIGALRM );
30009ea0: ebfff1f1 bl 3000666c <getpid> <== NOT EXECUTED 30009ea4: e3a0100e mov r1, #14 <== NOT EXECUTED 30009ea8: ebffff81 bl 30009cb4 <kill> <== NOT EXECUTED 30009eac: e1a00004 mov r0, r4 <== NOT EXECUTED 30009eb0: eb000eda bl 3000da20 <_Watchdog_Remove> <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30009eb4: e59f000c ldr r0, [pc, #12] ; 30009ec8 <_POSIX_signals_Ualarm_TSR+0x30><== NOT EXECUTED 30009eb8: e1a01004 mov r1, r4 <== NOT EXECUTED
/*
* If the reset interval is non-zero, reschedule ourselves.
*/
_Watchdog_Reset( &_POSIX_signals_Ualarm_timer );
}
30009ebc: e8bd4010 pop {r4, lr} <== NOT EXECUTED
30009ec0: ea000e7f b 3000d8c4 <_Watchdog_Insert> <== NOT EXECUTED
3001cee8 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
3001cee8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
3001ceec: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 3001cef0: e59f50f4 ldr r5, [pc, #244] ; 3001cfec <_POSIX_signals_Unblock_thread+0x104><== NOT EXECUTED 3001cef4: e59f80f0 ldr r8, [pc, #240] ; 3001cfec <_POSIX_signals_Unblock_thread+0x104><== NOT EXECUTED 3001cef8: e0035005 and r5, r3, r5 <== NOT EXECUTED 3001cefc: e241c001 sub ip, r1, #1 <== NOT EXECUTED 3001cf00: e3a06001 mov r6, #1 <== NOT EXECUTED 3001cf04: e1550008 cmp r5, r8 <== NOT EXECUTED
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
3001cf08: e1a04000 mov r4, r0 <== NOT EXECUTED
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3001cf0c: e59070f4 ldr r7, [r0, #244] ; 0xf4 <== NOT EXECUTED 3001cf10: e1a0cc16 lsl ip, r6, ip <== NOT EXECUTED
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
3001cf14: 1a000012 bne 3001cf64 <_POSIX_signals_Unblock_thread+0x7c> <== NOT EXECUTED
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
3001cf18: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3001cf1c: e11c0003 tst ip, r3 <== NOT EXECUTED 3001cf20: 1a000002 bne 3001cf30 <_POSIX_signals_Unblock_thread+0x48> <== NOT EXECUTED 3001cf24: e59750d0 ldr r5, [r7, #208] ; 0xd0 <== NOT EXECUTED 3001cf28: e1dc5005 bics r5, ip, r5 <== NOT EXECUTED 3001cf2c: 0a00002c beq 3001cfe4 <_POSIX_signals_Unblock_thread+0xfc> <== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
3001cf30: e3a03004 mov r3, #4 <== NOT EXECUTED 3001cf34: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
the_info = (siginfo_t *) the_thread->Wait.return_argument;
3001cf38: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
if ( !info ) {
3001cf3c: e3520000 cmp r2, #0 <== NOT EXECUTED
the_info->si_signo = signo;
3001cf40: 05831000 streq r1, [r3] <== NOT EXECUTED
the_info->si_code = SI_USER;
3001cf44: 03a01001 moveq r1, #1 <== NOT EXECUTED
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
3001cf48: 18920007 ldmne r2, {r0, r1, r2} <== NOT EXECUTED
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
3001cf4c: 09830006 stmibeq r3, {r1, r2} <== NOT EXECUTED
} else {
*the_info = *info;
3001cf50: 18830007 stmne r3, {r0, r1, r2} <== NOT EXECUTED
}
_Thread_queue_Extract_with_proxy( the_thread );
3001cf54: e1a00004 mov r0, r4 <== NOT EXECUTED 3001cf58: ebffbffc bl 3000cf50 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED
return true;
3001cf5c: e3a05001 mov r5, #1 <== NOT EXECUTED 3001cf60: ea00001f b 3001cfe4 <_POSIX_signals_Unblock_thread+0xfc> <== NOT EXECUTED
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
3001cf64: e59750d0 ldr r5, [r7, #208] ; 0xd0 <== NOT EXECUTED 3001cf68: e1dc5005 bics r5, ip, r5 <== NOT EXECUTED 3001cf6c: 0a00001c beq 3001cfe4 <_POSIX_signals_Unblock_thread+0xfc> <== NOT EXECUTED
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
3001cf70: e2135201 ands r5, r3, #268435456 ; 0x10000000 <== NOT EXECUTED 3001cf74: 0a000010 beq 3001cfbc <_POSIX_signals_Unblock_thread+0xd4> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3001cf78: e59f5070 ldr r5, [pc, #112] ; 3001cff0 <_POSIX_signals_Unblock_thread+0x108><== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
3001cf7c: e3a02004 mov r2, #4 <== NOT EXECUTED 3001cf80: e0035005 and r5, r3, r5 <== NOT EXECUTED
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
3001cf84: e3550000 cmp r5, #0 <== NOT EXECUTED
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
the_thread->Wait.return_code = EINTR;
3001cf88: e5802034 str r2, [r0, #52] ; 0x34 <== NOT EXECUTED
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
3001cf8c: 0a000002 beq 3001cf9c <_POSIX_signals_Unblock_thread+0xb4> <== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
3001cf90: ebffbfee bl 3000cf50 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
3001cf94: e3a05000 mov r5, #0 <== NOT EXECUTED 3001cf98: ea000011 b 3001cfe4 <_POSIX_signals_Unblock_thread+0xfc> <== NOT EXECUTED
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
3001cf9c: e2133008 ands r3, r3, #8 <== NOT EXECUTED 3001cfa0: 0a00000e beq 3001cfe0 <_POSIX_signals_Unblock_thread+0xf8> <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
3001cfa4: e2800048 add r0, r0, #72 ; 0x48 <== NOT EXECUTED 3001cfa8: ebffc173 bl 3000d57c <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3001cfac: e1a00004 mov r0, r4 <== NOT EXECUTED 3001cfb0: e59f103c ldr r1, [pc, #60] ; 3001cff4 <_POSIX_signals_Unblock_thread+0x10c><== NOT EXECUTED 3001cfb4: ebffbd52 bl 3000c504 <_Thread_Clear_state> <== NOT EXECUTED 3001cfb8: ea000009 b 3001cfe4 <_POSIX_signals_Unblock_thread+0xfc> <== NOT EXECUTED
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
3001cfbc: e3530000 cmp r3, #0 <== NOT EXECUTED 3001cfc0: 1a000007 bne 3001cfe4 <_POSIX_signals_Unblock_thread+0xfc> <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
3001cfc4: e59f202c ldr r2, [pc, #44] ; 3001cff8 <_POSIX_signals_Unblock_thread+0x110><== NOT EXECUTED 3001cfc8: e5925000 ldr r5, [r2] <== NOT EXECUTED 3001cfcc: e3550000 cmp r5, #0 <== NOT EXECUTED 3001cfd0: 0a000003 beq 3001cfe4 <_POSIX_signals_Unblock_thread+0xfc> <== NOT EXECUTED 3001cfd4: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED 3001cfd8: e1500001 cmp r0, r1 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3001cfdc: 05c26004 strbeq r6, [r2, #4] <== NOT EXECUTED
}
}
return false;
3001cfe0: e1a05003 mov r5, r3 <== NOT EXECUTED
}
3001cfe4: e1a00005 mov r0, r5 <== NOT EXECUTED
3001cfe8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000bcf8 <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000bcf8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000bcfc: e59f403c ldr r4, [pc, #60] ; 3000bd40 <_Protected_heap_Extend+0x48><== NOT EXECUTED
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000bd00: e1a05000 mov r5, r0 <== NOT EXECUTED 3000bd04: e1a07001 mov r7, r1 <== NOT EXECUTED 3000bd08: e1a06002 mov r6, r2 <== NOT EXECUTED
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000bd0c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000bd10: ebfffbb0 bl 3000abd8 <_API_Mutex_Lock> <== NOT EXECUTED
amount_extended = _Heap_Extend( the_heap, starting_address, size, 0 );
3000bd14: e1a01007 mov r1, r7 <== NOT EXECUTED 3000bd18: e1a02006 mov r2, r6 <== NOT EXECUTED 3000bd1c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000bd20: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bd24: eb000fa1 bl 3000fbb0 <_Heap_Extend> <== NOT EXECUTED 3000bd28: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
3000bd2c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000bd30: ebfffbc1 bl 3000ac3c <_API_Mutex_Unlock> <== NOT EXECUTED
return amount_extended != 0;
}
3000bd34: e2950000 adds r0, r5, #0 <== NOT EXECUTED
3000bd38: 13a00001 movne r0, #1 <== NOT EXECUTED
3000bd3c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30010bbc <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
30010bbc: e92d4070 push {r4, r5, r6, lr}
if ( !the_heap )
30010bc0: e2506000 subs r6, r0, #0
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
30010bc4: e1a05001 mov r5, r1
if ( !the_heap )
return false;
30010bc8: 01a00006 moveq r0, r6
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
if ( !the_heap )
30010bcc: 08bd8070 popeq {r4, r5, r6, pc}
return false;
if ( !the_info )
30010bd0: e3510000 cmp r1, #0
30010bd4: 0a000009 beq 30010c00 <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
30010bd8: e59f4028 ldr r4, [pc, #40] ; 30010c08 <_Protected_heap_Get_information+0x4c> 30010bdc: e5940000 ldr r0, [r4] 30010be0: ebfff830 bl 3000eca8 <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
30010be4: e1a00006 mov r0, r6 30010be8: e1a01005 mov r1, r5 30010bec: eb001018 bl 30014c54 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
30010bf0: e5940000 ldr r0, [r4] 30010bf4: ebfff844 bl 3000ed0c <_API_Mutex_Unlock>
return true;
30010bf8: e3a00001 mov r0, #1
30010bfc: e8bd8070 pop {r4, r5, r6, pc}
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
30010c00: e1a00001 mov r0, r1 <== NOT EXECUTED
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
30010c04: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30010c68 <_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 )
30010c68: e59f3054 ldr r3, [pc, #84] ; 30010cc4 <_Protected_heap_Walk+0x5c><== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30010c6c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30010c70: e5933000 ldr r3, [r3] <== NOT EXECUTED
30010c74: e1a06000 mov r6, r0 <== NOT EXECUTED
30010c78: e3530000 cmp r3, #0 <== NOT EXECUTED
30010c7c: e1a05001 mov r5, r1 <== NOT EXECUTED
30010c80: e20270ff and r7, r2, #255 ; 0xff <== NOT EXECUTED
30010c84: 1a00000b bne 30010cb8 <_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();
30010c88: e59f4038 ldr r4, [pc, #56] ; 30010cc8 <_Protected_heap_Walk+0x60><== NOT EXECUTED 30010c8c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010c90: ebfff804 bl 3000eca8 <_API_Mutex_Lock> <== NOT EXECUTED
status = _Heap_Walk( the_heap, source, do_dump );
30010c94: e1a01005 mov r1, r5 <== NOT EXECUTED 30010c98: e1a02007 mov r2, r7 <== NOT EXECUTED 30010c9c: e1a00006 mov r0, r6 <== NOT EXECUTED 30010ca0: ebfffc29 bl 3000fd4c <_Heap_Walk> <== NOT EXECUTED 30010ca4: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
30010ca8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010cac: ebfff816 bl 3000ed0c <_API_Mutex_Unlock> <== NOT EXECUTED
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
30010cb0: e1a00005 mov r0, r5 <== NOT EXECUTED
30010cb4: 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 );
30010cb8: e1a02007 mov r2, r7 <== NOT EXECUTED
} return status; }
30010cbc: 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 );
30010cc0: eafffc21 b 3000fd4c <_Heap_Walk> <== NOT EXECUTED
3000cef4 <_RBTree_Iterate_unprotected>:
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
3000cef4: e3510000 cmp r1, #0 <== NOT EXECUTED
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
3000cef8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000cefc: e1a07003 mov r7, r3 <== NOT EXECUTED
3000cf00: 13a03002 movne r3, #2 <== NOT EXECUTED
3000cf04: 03a03003 moveq r3, #3 <== NOT EXECUTED
3000cf08: e1a04002 mov r4, r2 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000cf0c: 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];
3000cf10: e7905103 ldr r5, [r0, r3, lsl #2] <== NOT EXECUTED 3000cf14: ea00000b b 3000cf48 <_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 );
3000cf18: e1a00005 mov r0, r5 <== NOT EXECUTED 3000cf1c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000cf20: e1a02007 mov r2, r7 <== NOT EXECUTED 3000cf24: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cf28: e12fff14 bx r4 <== NOT EXECUTED
current = _RBTree_Next_unprotected( current, dir );
3000cf2c: 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 );
3000cf30: e1a08000 mov r8, r0 <== NOT EXECUTED
current = _RBTree_Next_unprotected( current, dir );
3000cf34: e1a00005 mov r0, r5 <== NOT EXECUTED 3000cf38: eb000005 bl 3000cf54 <_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 ) {
3000cf3c: e3580000 cmp r8, #0 <== NOT EXECUTED
stop = (*visitor)( current, dir, visitor_arg );
current = _RBTree_Next_unprotected( current, dir );
3000cf40: 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 ) {
3000cf44: 18bd81f0 popne {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000cf48: e3550000 cmp r5, #0 <== NOT EXECUTED
3000cf4c: 1afffff1 bne 3000cf18 <_RBTree_Iterate_unprotected+0x24> <== NOT EXECUTED
3000cf50: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000cf54 <_RBTree_Next_unprotected>:
const RBTree_Node *node,
RBTree_Direction dir
)
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
RBTree_Node *current = node->child [dir];
3000cf54: e2813001 add r3, r1, #1 3000cf58: 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);
3000cf5c: e2712001 rsbs r2, r1, #1 3000cf60: 33a02000 movcc r2, #0
RBTree_Node *next = NULL;
if ( current != NULL ) {
3000cf64: e3530000 cmp r3, #0
3000cf68: 1a000001 bne 3000cf74 <_RBTree_Next_unprotected+0x20>
3000cf6c: ea000005 b 3000cf88 <_RBTree_Next_unprotected+0x34>
next = current;
while ( (current = current->child [opp_dir]) != NULL ) {
3000cf70: e1a03001 mov r3, r1 <== NOT EXECUTED
3000cf74: e2821001 add r1, r2, #1 3000cf78: e7931101 ldr r1, [r3, r1, lsl #2] 3000cf7c: e3510000 cmp r1, #0
3000cf80: 1afffffa bne 3000cf70 <_RBTree_Next_unprotected+0x1c>
3000cf84: ea000013 b 3000cfd8 <_RBTree_Next_unprotected+0x84>
next = current;
}
} else {
RBTree_Node *parent = node->parent;
3000cf88: e5903000 ldr r3, [r0]
if ( parent->parent && node == parent->child [opp_dir] ) {
3000cf8c: e593c000 ldr ip, [r3] 3000cf90: e35c0000 cmp ip, #0
3000cf94: 0a000006 beq 3000cfb4 <_RBTree_Next_unprotected+0x60>
3000cf98: e2822001 add r2, r2, #1 3000cf9c: e7932102 ldr r2, [r3, r2, lsl #2] 3000cfa0: e1500002 cmp r0, r2
3000cfa4: 1a000002 bne 3000cfb4 <_RBTree_Next_unprotected+0x60>
3000cfa8: ea00000a b 3000cfd8 <_RBTree_Next_unprotected+0x84>
next = parent;
} else {
while ( parent->parent && node == parent->child [dir] ) {
3000cfac: e1a00003 mov r0, r3 3000cfb0: e1a03002 mov r3, r2 3000cfb4: e5932000 ldr r2, [r3] 3000cfb8: e3520000 cmp r2, #0
3000cfbc: 0a000004 beq 3000cfd4 <_RBTree_Next_unprotected+0x80>
3000cfc0: e281c001 add ip, r1, #1 3000cfc4: e793c10c ldr ip, [r3, ip, lsl #2] 3000cfc8: e150000c cmp r0, ip
3000cfcc: 0afffff6 beq 3000cfac <_RBTree_Next_unprotected+0x58>
3000cfd0: ea000000 b 3000cfd8 <_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;
3000cfd4: e1a03002 mov r3, r2
}
}
}
return next;
}
3000cfd8: e1a00003 mov r0, r3 3000cfdc: e12fff1e bx lr
3000c928 <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
3000c928: e2502000 subs r2, r0, #0 3000c92c: 01a00002 moveq r0, r2 3000c930: 012fff1e bxeq lr
if(!(the_node->parent)) return NULL;
3000c934: e5923000 ldr r3, [r2] 3000c938: e3530000 cmp r3, #0
3000c93c: 0a000006 beq 3000c95c <_RBTree_Sibling+0x34> if(!(the_node->parent->parent)) return NULL;
3000c940: e5930000 ldr r0, [r3] 3000c944: e3500000 cmp r0, #0 3000c948: 012fff1e bxeq lr
if(the_node == the_node->parent->child[RBT_LEFT])
3000c94c: e5930004 ldr r0, [r3, #4] 3000c950: e1520000 cmp r2, r0
return the_node->parent->child[RBT_RIGHT];
3000c954: 05930008 ldreq r0, [r3, #8] 3000c958: 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;
3000c95c: 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];
}
3000c960: e12fff1e bx lr <== NOT EXECUTED
3000f600 <_RTEMS_tasks_Delete_extension>:
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000f600: e3a03000 mov r3, #0
static void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000f604: e92d4070 push {r4, r5, r6, lr}
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
3000f608: e59160fc ldr r6, [r1, #252] ; 0xfc
static void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000f60c: e1a04001 mov r4, r1
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000f610: e58130fc str r3, [r1, #252] ; 0xfc
while (tvp) {
3000f614: ea000004 b 3000f62c <_RTEMS_tasks_Delete_extension+0x2c>
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000f618: e1a01006 mov r1, r6 <== NOT EXECUTED 3000f61c: e1a00004 mov r0, r4 <== NOT EXECUTED
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
3000f620: e5965000 ldr r5, [r6] <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000f624: eb00003d bl 3000f720 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
tvp = next;
3000f628: e1a06005 mov r6, r5 <== NOT EXECUTED
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
3000f62c: e3560000 cmp r6, #0
3000f630: 1afffff8 bne 3000f618 <_RTEMS_tasks_Delete_extension+0x18>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
3000f634: e59400f0 ldr r0, [r4, #240] ; 0xf0 3000f638: ebfff85f bl 3000d7bc <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
3000f63c: e58460f0 str r6, [r4, #240] ; 0xf0
}
3000f640: e8bd8070 pop {r4, r5, r6, pc}
3000f588 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
3000f588: e59030fc ldr r3, [r0, #252] ; 0xfc
while (tvp) {
3000f58c: ea000005 b 3000f5a8 <_RTEMS_tasks_Switch_extension+0x20>
tvp->tval = *tvp->ptr;
3000f590: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000f594: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000f598: e583000c str r0, [r3, #12] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
3000f59c: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3000f5a0: e5820000 str r0, [r2] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
3000f5a4: e5933000 ldr r3, [r3] <== NOT EXECUTED
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
3000f5a8: e3530000 cmp r3, #0
3000f5ac: 1afffff7 bne 3000f590 <_RTEMS_tasks_Switch_extension+0x8>
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
3000f5b0: e59130fc ldr r3, [r1, #252] ; 0xfc
while (tvp) {
3000f5b4: ea000005 b 3000f5d0 <_RTEMS_tasks_Switch_extension+0x48>
tvp->gval = *tvp->ptr;
3000f5b8: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000f5bc: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000f5c0: e5831008 str r1, [r3, #8] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
3000f5c4: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3000f5c8: e5821000 str r1, [r2] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
3000f5cc: e5933000 ldr r3, [r3] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
3000f5d0: e3530000 cmp r3, #0
3000f5d4: 1afffff7 bne 3000f5b8 <_RTEMS_tasks_Switch_extension+0x30>
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
3000f5d8: e12fff1e bx lr
30032818 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
30032818: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3003281c: e1a01000 mov r1, r0 <== NOT EXECUTED
30032820: e1a0200d mov r2, sp <== NOT EXECUTED
30032824: e59f0088 ldr r0, [pc, #136] ; 300328b4 <_Rate_monotonic_Timeout+0x9c><== NOT EXECUTED
30032828: ebff6698 bl 3000c290 <_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 ) {
3003282c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30032830: e1a04000 mov r4, r0 <== NOT EXECUTED 30032834: e3530000 cmp r3, #0 <== NOT EXECUTED 30032838: 1a00001c bne 300328b0 <_Rate_monotonic_Timeout+0x98> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_thread = the_period->owner;
3003283c: 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);
30032840: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
30032844: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 30032848: 0a000006 beq 30032868 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED 3003284c: e5902020 ldr r2, [r0, #32] <== NOT EXECUTED 30032850: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30032854: e1520003 cmp r2, r3 <== NOT EXECUTED 30032858: 1a000002 bne 30032868 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3003285c: e59f1054 ldr r1, [pc, #84] ; 300328b8 <_Rate_monotonic_Timeout+0xa0><== NOT EXECUTED 30032860: ebff691a bl 3000ccd0 <_Thread_Clear_state> <== NOT EXECUTED 30032864: ea000006 b 30032884 <_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 ) {
30032868: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 3003286c: 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;
30032870: 13a03004 movne r3, #4 <== NOT EXECUTED 30032874: 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 ) {
30032878: 1a000008 bne 300328a0 <_Rate_monotonic_Timeout+0x88> <== NOT EXECUTED
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
3003287c: e3a03003 mov r3, #3 <== NOT EXECUTED 30032880: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
30032884: e1a00004 mov r0, r4 <== NOT EXECUTED 30032888: ebffff55 bl 300325e4 <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3003288c: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30032890: e59f0024 ldr r0, [pc, #36] ; 300328bc <_Rate_monotonic_Timeout+0xa4><== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30032894: e584301c str r3, [r4, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30032898: e2841010 add r1, r4, #16 <== NOT EXECUTED 3003289c: ebff6cd2 bl 3000dbec <_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;
300328a0: e59f3018 ldr r3, [pc, #24] ; 300328c0 <_Rate_monotonic_Timeout+0xa8><== NOT EXECUTED 300328a4: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
300328a8: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
300328ac: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
300328b0: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000d5c0 <_Scheduler_CBS_Attach_thread>:
{
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d5c0: e59f3094 ldr r3, [pc, #148] ; 3000d65c <_Scheduler_CBS_Attach_thread+0x9c><== NOT EXECUTED
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000d5c4: 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 )
3000d5c8: e5933000 ldr r3, [r3] <== NOT EXECUTED
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000d5cc: 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 )
3000d5d0: e1500003 cmp r0, r3 <== NOT EXECUTED
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000d5d4: 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 )
3000d5d8: 2a00001b bcs 3000d64c <_Scheduler_CBS_Attach_thread+0x8c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
the_thread = _Thread_Get(task_id, &location);
3000d5dc: e1a00001 mov r0, r1 <== NOT EXECUTED 3000d5e0: e1a0100d mov r1, sp <== NOT EXECUTED 3000d5e4: eb0003b7 bl 3000e4c8 <_Thread_Get> <== NOT EXECUTED
/* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread )
3000d5e8: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000d5ec: 0a000016 beq 3000d64c <_Scheduler_CBS_Attach_thread+0x8c> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000d5f0: eb0003ac bl 3000e4a8 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
3000d5f4: e5962088 ldr r2, [r6, #136] ; 0x88 <== NOT EXECUTED
/* Thread is already attached to a server. */
if ( sched_info->cbs_server )
3000d5f8: e5920018 ldr r0, [r2, #24] <== NOT EXECUTED 3000d5fc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d600: 1a000013 bne 3000d654 <_Scheduler_CBS_Attach_thread+0x94> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d604: e59f3054 ldr r3, [pc, #84] ; 3000d660 <_Scheduler_CBS_Attach_thread+0xa0><== NOT EXECUTED 3000d608: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d60c: e7933105 ldr r3, [r3, r5, lsl #2] <== NOT EXECUTED 3000d610: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d614: 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] )
3000d618: 0a00000e beq 3000d658 <_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 )
3000d61c: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000d620: e3710001 cmn r1, #1 <== NOT EXECUTED 3000d624: 1a00000a bne 3000d654 <_Scheduler_CBS_Attach_thread+0x94> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
_Scheduler_CBS_Server_list[server_id]->task_id = task_id;
3000d628: e5834000 str r4, [r3] <== NOT EXECUTED
sched_info->cbs_server = (void *) _Scheduler_CBS_Server_list[server_id];
3000d62c: e5823018 str r3, [r2, #24] <== NOT EXECUTED
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
3000d630: e59f302c ldr r3, [pc, #44] ; 3000d664 <_Scheduler_CBS_Attach_thread+0xa4><== NOT EXECUTED 3000d634: e586307c str r3, [r6, #124] ; 0x7c <== NOT EXECUTED
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
3000d638: e3a03003 mov r3, #3 <== NOT EXECUTED 3000d63c: e5863078 str r3, [r6, #120] ; 0x78 <== NOT EXECUTED
the_thread->is_preemptible = true;
3000d640: e3a03001 mov r3, #1 <== NOT EXECUTED 3000d644: e5c63070 strb r3, [r6, #112] ; 0x70 <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d648: ea000002 b 3000d658 <_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;
3000d64c: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000d650: ea000000 b 3000d658 <_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;
3000d654: 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;
}
3000d658: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000da8c <_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;
3000da8c: e59010ac ldr r1, [r0, #172] ; 0xac <== NOT EXECUTED
if ( the_thread->real_priority != new_priority )
3000da90: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
3000da94: 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 )
3000da98: e1530001 cmp r3, r1 <== NOT EXECUTED
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
3000da9c: 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;
3000daa0: 15801018 strne r1, [r0, #24] <== NOT EXECUTED
if ( the_thread->current_priority != new_priority )
3000daa4: e1530001 cmp r3, r1 <== NOT EXECUTED
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
3000daa8: 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);
3000daac: 13a02001 movne r2, #1 <== NOT EXECUTED 3000dab0: 1b000163 blne 3000e044 <_Thread_Change_priority> <== NOT EXECUTED
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
3000dab4: e5944088 ldr r4, [r4, #136] ; 0x88 <== NOT EXECUTED
if ( sched_info->cbs_server->cbs_budget_overrun ) {
3000dab8: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 3000dabc: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000dac0: e3520000 cmp r2, #0 <== NOT EXECUTED 3000dac4: 0a000006 beq 3000dae4 <_Scheduler_CBS_Budget_callout+0x58> <== NOT EXECUTED
_Scheduler_CBS_Get_server_id(
3000dac8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000dacc: e1a0100d mov r1, sp <== NOT EXECUTED 3000dad0: ebffffd6 bl 3000da30 <_Scheduler_CBS_Get_server_id> <== NOT EXECUTED
sched_info->cbs_server->task_id,
&server_id
);
sched_info->cbs_server->cbs_budget_overrun( server_id );
3000dad4: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 3000dad8: e59d0000 ldr r0, [sp] <== NOT EXECUTED 3000dadc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000dae0: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
} }
3000dae4: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000d668 <_Scheduler_CBS_Cleanup>:
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Cleanup (void)
{
3000d668: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000d66c: e3a04000 mov r4, #0 <== NOT EXECUTED 3000d670: e59f603c ldr r6, [pc, #60] ; 3000d6b4 <_Scheduler_CBS_Cleanup+0x4c><== NOT EXECUTED 3000d674: e59f503c ldr r5, [pc, #60] ; 3000d6b8 <_Scheduler_CBS_Cleanup+0x50><== NOT EXECUTED 3000d678: ea000005 b 3000d694 <_Scheduler_CBS_Cleanup+0x2c> <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[ i ] )
3000d67c: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d680: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d684: e3530000 cmp r3, #0 <== NOT EXECUTED
_Scheduler_CBS_Destroy_server( i );
3000d688: 11a00004 movne r0, r4 <== NOT EXECUTED 3000d68c: 1b00003b blne 3000d780 <_Scheduler_CBS_Destroy_server> <== NOT EXECUTED
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000d690: e2844001 add r4, r4, #1 <== NOT EXECUTED 3000d694: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000d698: e1540003 cmp r4, r3 <== NOT EXECUTED 3000d69c: 3afffff6 bcc 3000d67c <_Scheduler_CBS_Cleanup+0x14> <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
3000d6a0: e59f3010 ldr r3, [pc, #16] ; 3000d6b8 <_Scheduler_CBS_Cleanup+0x50><== NOT EXECUTED 3000d6a4: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000d6a8: eb000751 bl 3000f3f4 <_Workspace_Free> <== NOT EXECUTED
return SCHEDULER_CBS_OK; }
3000d6ac: e3a00000 mov r0, #0 <== NOT EXECUTED
3000d6b0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000d6bc <_Scheduler_CBS_Create_server>:
)
{
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
3000d6bc: 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
)
{
3000d6c0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
3000d6c4: 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
)
{
3000d6c8: e1a04000 mov r4, r0 <== NOT EXECUTED 3000d6cc: e1a05001 mov r5, r1 <== NOT EXECUTED 3000d6d0: e1a0a002 mov sl, r2 <== NOT EXECUTED
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
3000d6d4: da000023 ble 3000d768 <_Scheduler_CBS_Create_server+0xac> <== NOT EXECUTED 3000d6d8: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000d6dc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d6e0: da000020 ble 3000d768 <_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++ ) {
3000d6e4: e59f308c ldr r3, [pc, #140] ; 3000d778 <_Scheduler_CBS_Create_server+0xbc><== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[i] )
3000d6e8: 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++ ) {
3000d6ec: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d6f0: e59f3084 ldr r3, [pc, #132] ; 3000d77c <_Scheduler_CBS_Create_server+0xc0><== NOT EXECUTED 3000d6f4: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d6f8: ea00000f b 3000d73c <_Scheduler_CBS_Create_server+0x80> <== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[i] )
3000d6fc: e4937004 ldr r7, [r3], #4 <== NOT EXECUTED 3000d700: e3570000 cmp r7, #0 <== NOT EXECUTED 3000d704: 1a00000b bne 3000d738 <_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 *)
3000d708: e59f806c ldr r8, [pc, #108] ; 3000d77c <_Scheduler_CBS_Create_server+0xc0><== NOT EXECUTED
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
3000d70c: e58a6000 str r6, [sl] <== NOT EXECUTED
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
3000d710: 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 *)
3000d714: e5989000 ldr r9, [r8] <== NOT EXECUTED
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
3000d718: eb00072f bl 3000f3dc <_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 *)
3000d71c: e7890106 str r0, [r9, r6, lsl #2] <== NOT EXECUTED
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
3000d720: e59a2000 ldr r2, [sl] <== NOT EXECUTED 3000d724: e5983000 ldr r3, [r8] <== NOT EXECUTED 3000d728: e7933102 ldr r3, [r3, r2, lsl #2] <== NOT EXECUTED
if ( !the_server )
3000d72c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d730: 1a000005 bne 3000d74c <_Scheduler_CBS_Create_server+0x90> <== NOT EXECUTED 3000d734: ea00000d b 3000d770 <_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++ ) {
3000d738: e2866001 add r6, r6, #1 <== NOT EXECUTED 3000d73c: e1560002 cmp r6, r2 <== NOT EXECUTED 3000d740: 1affffed bne 3000d6fc <_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;
3000d744: e3e00019 mvn r0, #25 <== NOT EXECUTED
3000d748: 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;
3000d74c: 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;
3000d750: e8940003 ldm r4, {r0, r1} <== NOT EXECUTED
the_server->task_id = -1;
3000d754: 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;
3000d758: e9830003 stmib r3, {r0, r1} <== NOT EXECUTED
the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback;
3000d75c: e583500c str r5, [r3, #12] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d760: e1a00007 mov r0, r7 <== NOT EXECUTED
3000d764: 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;
3000d768: e3e00011 mvn r0, #17 <== NOT EXECUTED
3000d76c: 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;
3000d770: 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;
}
3000d774: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000d780 <_Scheduler_CBS_Destroy_server>:
)
{
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d780: e59f3064 ldr r3, [pc, #100] ; 3000d7ec <_Scheduler_CBS_Destroy_server+0x6c><== NOT EXECUTED
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
3000d784: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d788: e5933000 ldr r3, [r3] <== NOT EXECUTED
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
3000d78c: e1a04000 mov r4, r0 <== NOT EXECUTED
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d790: e1500003 cmp r0, r3 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d794: 23e06011 mvncs r6, #17 <== NOT EXECUTED
)
{
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d798: 2a000011 bcs 3000d7e4 <_Scheduler_CBS_Destroy_server+0x64> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d79c: e59f504c ldr r5, [pc, #76] ; 3000d7f0 <_Scheduler_CBS_Destroy_server+0x70><== NOT EXECUTED 3000d7a0: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d7a4: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d7a8: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d7ac: 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] )
3000d7b0: 0a00000b beq 3000d7e4 <_Scheduler_CBS_Destroy_server+0x64> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( (tid = _Scheduler_CBS_Server_list[server_id]->task_id) != -1 )
3000d7b4: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000d7b8: e3710001 cmn r1, #1 <== NOT EXECUTED
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
int ret = SCHEDULER_CBS_OK;
3000d7bc: 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 )
3000d7c0: 0a000001 beq 3000d7cc <_Scheduler_CBS_Destroy_server+0x4c> <== NOT EXECUTED
ret = _Scheduler_CBS_Detach_thread ( server_id, tid );
3000d7c4: eb00000a bl 3000d7f4 <_Scheduler_CBS_Detach_thread> <== NOT EXECUTED 3000d7c8: e1a06000 mov r6, r0 <== NOT EXECUTED
_Workspace_Free( _Scheduler_CBS_Server_list[server_id] );
3000d7cc: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d7d0: e7930104 ldr r0, [r3, r4, lsl #2] <== NOT EXECUTED 3000d7d4: eb000706 bl 3000f3f4 <_Workspace_Free> <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id] = NULL;
3000d7d8: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d7dc: e3a02000 mov r2, #0 <== NOT EXECUTED 3000d7e0: e7832104 str r2, [r3, r4, lsl #2] <== NOT EXECUTED
return ret; }
3000d7e4: e1a00006 mov r0, r6 <== NOT EXECUTED
3000d7e8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000d7f4 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000d7f4: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
3000d7f8: e1a05000 mov r5, r0 <== NOT EXECUTED
3000d7fc: 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);
3000d800: e1a00001 mov r0, r1 <== NOT EXECUTED 3000d804: e1a0100d mov r1, sp <== NOT EXECUTED 3000d808: eb00032e bl 3000e4c8 <_Thread_Get> <== NOT EXECUTED
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
3000d80c: e2506000 subs r6, r0, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000d810: 1b000324 blne 3000e4a8 <_Thread_Enable_dispatch> <== NOT EXECUTED
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d814: e59f306c ldr r3, [pc, #108] ; 3000d888 <_Scheduler_CBS_Detach_thread+0x94><== NOT EXECUTED 3000d818: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d81c: e1550003 cmp r5, r3 <== NOT EXECUTED 3000d820: 2a000016 bcs 3000d880 <_Scheduler_CBS_Detach_thread+0x8c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
3000d824: e3560000 cmp r6, #0 <== NOT EXECUTED 3000d828: 0a000014 beq 3000d880 <_Scheduler_CBS_Detach_thread+0x8c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d82c: e59f3058 ldr r3, [pc, #88] ; 3000d88c <_Scheduler_CBS_Detach_thread+0x98><== NOT EXECUTED 3000d830: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d834: e7933105 ldr r3, [r3, r5, lsl #2] <== NOT EXECUTED 3000d838: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d83c: 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] )
3000d840: 0a00000f beq 3000d884 <_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 )
3000d844: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d848: e1520004 cmp r2, r4 <== NOT EXECUTED 3000d84c: 1a00000b bne 3000d880 <_Scheduler_CBS_Detach_thread+0x8c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
3000d850: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000d854: e5832000 str r2, [r3] <== NOT EXECUTED
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL;
3000d858: e5963088 ldr r3, [r6, #136] ; 0x88 <== NOT EXECUTED 3000d85c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000d860: e5830018 str r0, [r3, #24] <== NOT EXECUTED
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
3000d864: e59630a0 ldr r3, [r6, #160] ; 0xa0 <== NOT EXECUTED 3000d868: e5863078 str r3, [r6, #120] ; 0x78 <== NOT EXECUTED
the_thread->budget_callout = the_thread->Start.budget_callout;
3000d86c: e59630a4 ldr r3, [r6, #164] ; 0xa4 <== NOT EXECUTED 3000d870: e586307c str r3, [r6, #124] ; 0x7c <== NOT EXECUTED
the_thread->is_preemptible = the_thread->Start.is_preemptible;
3000d874: e5d6309c ldrb r3, [r6, #156] ; 0x9c <== NOT EXECUTED 3000d878: e5c63070 strb r3, [r6, #112] ; 0x70 <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d87c: ea000000 b 3000d884 <_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;
3000d880: 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;
}
3000d884: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000d890 <_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 )
3000d890: e59f3030 ldr r3, [pc, #48] ; 3000d8c8 <_Scheduler_CBS_Get_approved_budget+0x38><== NOT EXECUTED 3000d894: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d898: e1500003 cmp r0, r3 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d89c: 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 )
3000d8a0: 212fff1e bxcs lr <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d8a4: e59f3020 ldr r3, [pc, #32] ; 3000d8cc <_Scheduler_CBS_Get_approved_budget+0x3c><== NOT EXECUTED 3000d8a8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d8ac: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d8b0: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
*approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000d8b4: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d8b8: 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;
3000d8bc: 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;
3000d8c0: 03e00018 mvneq r0, #24 <== NOT EXECUTED
*approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
return SCHEDULER_CBS_OK;
}
3000d8c4: e12fff1e bx lr <== NOT EXECUTED
3000d8d0 <_Scheduler_CBS_Get_execution_time>:
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d8d0: e59f3090 ldr r3, [pc, #144] ; 3000d968 <_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
)
{
3000d8d4: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d8d8: 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
)
{
3000d8dc: e1a04000 mov r4, r0 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d8e0: 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
)
{
3000d8e4: 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;
3000d8e8: 23e00011 mvncs r0, #17 <== NOT EXECUTED
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d8ec: 2a00001c bcs 3000d964 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d8f0: e59f6074 ldr r6, [pc, #116] ; 3000d96c <_Scheduler_CBS_Get_execution_time+0x9c><== NOT EXECUTED 3000d8f4: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000d8f8: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d8fc: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d900: 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] )
3000d904: 0a000016 beq 3000d964 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) {
3000d908: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000d90c: e3700001 cmn r0, #1 <== NOT EXECUTED
*exec_time = 0;
3000d910: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000d914: 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 ) {
3000d918: 0a000011 beq 3000d964 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED
*exec_time = 0;
return SCHEDULER_CBS_OK;
}
the_thread = _Thread_Get(
3000d91c: e1a0100d mov r1, sp <== NOT EXECUTED 3000d920: eb0002e8 bl 3000e4c8 <_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 ) {
3000d924: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000d928: 0a000008 beq 3000d950 <_Scheduler_CBS_Get_execution_time+0x80><== NOT EXECUTED
_Thread_Enable_dispatch();
3000d92c: eb0002dd bl 3000e4a8 <_Thread_Enable_dispatch> <== NOT EXECUTED
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget -
3000d930: 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;
3000d934: 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 -
3000d938: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d93c: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 3000d940: e5973074 ldr r3, [r7, #116] ; 0x74 <== NOT EXECUTED 3000d944: e0633002 rsb r3, r3, r2 <== NOT EXECUTED 3000d948: e5853000 str r3, [r5] <== NOT EXECUTED 3000d94c: ea000004 b 3000d964 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED
the_thread->cpu_time_budget;
}
else {
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000d950: e5963000 ldr r3, [r6] <== NOT EXECUTED
} return SCHEDULER_CBS_OK;
3000d954: 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;
3000d958: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d95c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000d960: e5853000 str r3, [r5] <== NOT EXECUTED
} return SCHEDULER_CBS_OK; }
3000d964: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000d970 <_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 )
3000d970: e59f3038 ldr r3, [pc, #56] ; 3000d9b0 <_Scheduler_CBS_Get_parameters+0x40><== NOT EXECUTED 3000d974: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d978: e1500003 cmp r0, r3 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d97c: 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 )
3000d980: 212fff1e bxcs lr <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d984: e59f3028 ldr r3, [pc, #40] ; 3000d9b4 <_Scheduler_CBS_Get_parameters+0x44><== NOT EXECUTED 3000d988: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d98c: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d990: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d994: 0a000003 beq 3000d9a8 <_Scheduler_CBS_Get_parameters+0x38> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
*params = _Scheduler_CBS_Server_list[server_id]->parameters;
3000d998: e993000c ldmib r3, {r2, r3} <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d99c: 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;
3000d9a0: e881000c stm r1, {r2, r3} <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d9a4: 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;
3000d9a8: e3e00018 mvn r0, #24 <== NOT EXECUTED
*params = _Scheduler_CBS_Server_list[server_id]->parameters;
return SCHEDULER_CBS_OK;
}
3000d9ac: e12fff1e bx lr <== NOT EXECUTED
3000d9b8 <_Scheduler_CBS_Get_remaining_budget>:
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d9b8: e59f3068 ldr r3, [pc, #104] ; 3000da28 <_Scheduler_CBS_Get_remaining_budget+0x70><== NOT EXECUTED
int _Scheduler_CBS_Get_remaining_budget (
Scheduler_CBS_Server_id server_id,
time_t *remaining_budget
)
{
3000d9bc: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d9c0: e5933000 ldr r3, [r3] <== NOT EXECUTED
int _Scheduler_CBS_Get_remaining_budget (
Scheduler_CBS_Server_id server_id,
time_t *remaining_budget
)
{
3000d9c4: e1a04001 mov r4, r1 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d9c8: e1500003 cmp r0, r3 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d9cc: 23e00011 mvncs r0, #17 <== NOT EXECUTED
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d9d0: 2a000013 bcs 3000da24 <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d9d4: e59f3050 ldr r3, [pc, #80] ; 3000da2c <_Scheduler_CBS_Get_remaining_budget+0x74><== NOT EXECUTED 3000d9d8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d9dc: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d9e0: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d9e4: 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] )
3000d9e8: 0a00000d beq 3000da24 <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) {
3000d9ec: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000d9f0: e3700001 cmn r0, #1 <== NOT EXECUTED
*remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000d9f4: 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 ) {
3000d9f8: 0a000007 beq 3000da1c <_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(
3000d9fc: e1a0100d mov r1, sp <== NOT EXECUTED 3000da00: eb0002b0 bl 3000e4c8 <_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 ) {
3000da04: e2505000 subs r5, r0, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
*remaining_budget = the_thread->cpu_time_budget;
}
else {
*remaining_budget = 0;
3000da08: 05845000 streq r5, [r4] <== NOT EXECUTED
}
return SCHEDULER_CBS_OK;
3000da0c: 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 ) {
3000da10: 0a000003 beq 3000da24 <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
_Thread_Enable_dispatch();
3000da14: eb0002a3 bl 3000e4a8 <_Thread_Enable_dispatch> <== NOT EXECUTED
*remaining_budget = the_thread->cpu_time_budget;
3000da18: e5953074 ldr r3, [r5, #116] ; 0x74 <== NOT EXECUTED 3000da1c: e5843000 str r3, [r4] <== NOT EXECUTED
}
else {
*remaining_budget = 0;
}
return SCHEDULER_CBS_OK;
3000da20: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000da24: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000da30 <_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++ ) {
3000da30: e59f304c ldr r3, [pc, #76] ; 3000da84 <_Scheduler_CBS_Get_server_id+0x54><== NOT EXECUTED
int _Scheduler_CBS_Get_server_id (
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
3000da34: e92d4010 push {r4, lr} <== NOT EXECUTED
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000da38: e5934000 ldr r4, [r3] <== NOT EXECUTED 3000da3c: e59f3044 ldr r3, [pc, #68] ; 3000da88 <_Scheduler_CBS_Get_server_id+0x58><== NOT EXECUTED 3000da40: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000da44: e3a03000 mov r3, #0 <== NOT EXECUTED 3000da48: ea000009 b 3000da74 <_Scheduler_CBS_Get_server_id+0x44> <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[i] &&
3000da4c: e492c004 ldr ip, [r2], #4 <== NOT EXECUTED 3000da50: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000da54: 0a000005 beq 3000da70 <_Scheduler_CBS_Get_server_id+0x40> <== NOT EXECUTED 3000da58: e59cc000 ldr ip, [ip] <== NOT EXECUTED 3000da5c: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000da60: 1a000002 bne 3000da70 <_Scheduler_CBS_Get_server_id+0x40> <== NOT EXECUTED
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
3000da64: e5813000 str r3, [r1] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000da68: e3a00000 mov r0, #0 <== NOT EXECUTED
3000da6c: 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++ ) {
3000da70: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000da74: e1530004 cmp r3, r4 <== NOT EXECUTED 3000da78: 1afffff3 bne 3000da4c <_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;
3000da7c: e3e00018 mvn r0, #24 <== NOT EXECUTED
}
3000da80: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000dae8 <_Scheduler_CBS_Initialize>:
int _Scheduler_CBS_Initialize(void)
{
3000dae8: e92d4010 push {r4, lr} <== NOT EXECUTED
unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
3000daec: e59f4050 ldr r4, [pc, #80] ; 3000db44 <_Scheduler_CBS_Initialize+0x5c><== NOT EXECUTED 3000daf0: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000daf4: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED 3000daf8: eb000637 bl 3000f3dc <_Workspace_Allocate> <== NOT EXECUTED 3000dafc: e59f3044 ldr r3, [pc, #68] ; 3000db48 <_Scheduler_CBS_Initialize+0x60><== NOT EXECUTED
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
3000db00: e3500000 cmp r0, #0 <== NOT EXECUTED
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
3000db04: e5830000 str r0, [r3] <== NOT EXECUTED 3000db08: 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++) {
3000db0c: 13a03000 movne r3, #0 <== NOT EXECUTED 3000db10: 15941000 ldrne r1, [r4] <== NOT EXECUTED 3000db14: 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 )
3000db18: 1a000003 bne 3000db2c <_Scheduler_CBS_Initialize+0x44> <== NOT EXECUTED 3000db1c: ea000006 b 3000db3c <_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;
3000db20: e590c000 ldr ip, [r0] <== NOT EXECUTED 3000db24: 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++) {
3000db28: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000db2c: e1530001 cmp r3, r1 <== NOT EXECUTED 3000db30: 1afffffa bne 3000db20 <_Scheduler_CBS_Initialize+0x38> <== NOT EXECUTED
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
3000db34: e3a00000 mov r0, #0 <== NOT EXECUTED
3000db38: 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;
3000db3c: 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;
}
3000db40: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c768 <_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;
3000c768: e5903088 ldr r3, [r0, #136] ; 0x88 <== NOT EXECUTED
if (deadline) {
3000c76c: 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 =
3000c770: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
(Scheduler_CBS_Server *) sched_info->cbs_server;
if (deadline) {
3000c774: 0a00000a beq 3000c7a4 <_Scheduler_CBS_Release_job+0x3c> <== NOT EXECUTED 3000c778: e59f2044 ldr r2, [pc, #68] ; 3000c7c4 <_Scheduler_CBS_Release_job+0x5c><== NOT EXECUTED
/* Initializing or shifting deadline. */
if (serv_info)
3000c77c: 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)
3000c780: 05923000 ldreq r3, [r2] <== NOT EXECUTED 3000c784: 00811003 addeq r1, r1, r3 <== NOT EXECUTED 3000c788: 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)
3000c78c: 0a000009 beq 3000c7b8 <_Scheduler_CBS_Release_job+0x50> <== NOT EXECUTED
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
3000c790: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000c794: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000c798: e0811002 add r1, r1, r2 <== NOT EXECUTED 3000c79c: e3c11102 bic r1, r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000c7a0: ea000002 b 3000c7b0 <_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)
3000c7a4: 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;
3000c7a8: e59010ac ldr r1, [r0, #172] ; 0xac <== NOT EXECUTED
}
/* Budget replenishment for the next job. */
if (serv_info)
3000c7ac: 0a000001 beq 3000c7b8 <_Scheduler_CBS_Release_job+0x50> <== NOT EXECUTED
the_thread->cpu_time_budget = serv_info->parameters.budget;
3000c7b0: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c7b4: e5803074 str r3, [r0, #116] ; 0x74 <== NOT EXECUTED
the_thread->real_priority = new_priority;
_Thread_Change_priority(the_thread, new_priority, true);
3000c7b8: 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;
3000c7bc: e5801018 str r1, [r0, #24] <== NOT EXECUTED
_Thread_Change_priority(the_thread, new_priority, true);
3000c7c0: ea00010d b 3000cbfc <_Thread_Change_priority> <== NOT EXECUTED
3000dbac <_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 )
3000dbac: e59f3054 ldr r3, [pc, #84] ; 3000dc08 <_Scheduler_CBS_Set_parameters+0x5c><== NOT EXECUTED 3000dbb0: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000dbb4: e1500003 cmp r0, r3 <== NOT EXECUTED 3000dbb8: 2a00000e bcs 3000dbf8 <_Scheduler_CBS_Set_parameters+0x4c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( params->budget <= 0 ||
3000dbbc: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 3000dbc0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000dbc4: da00000b ble 3000dbf8 <_Scheduler_CBS_Set_parameters+0x4c> <== NOT EXECUTED 3000dbc8: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000dbcc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000dbd0: da000008 ble 3000dbf8 <_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] )
3000dbd4: e59f3030 ldr r3, [pc, #48] ; 3000dc0c <_Scheduler_CBS_Set_parameters+0x60><== NOT EXECUTED 3000dbd8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000dbdc: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000dbe0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000dbe4: 0a000005 beq 3000dc00 <_Scheduler_CBS_Set_parameters+0x54> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
_Scheduler_CBS_Server_list[server_id]->parameters = *params;
3000dbe8: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3000dbec: e9830003 stmib r3, {r0, r1} <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000dbf0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000dbf4: 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;
3000dbf8: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000dbfc: e12fff1e bx lr <== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
3000dc00: e3e00018 mvn r0, #24 <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id]->parameters = *params;
return SCHEDULER_CBS_OK;
}
3000dc04: e12fff1e bx lr <== NOT EXECUTED
3000c7c8 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
3000c7c8: e92d4030 push {r4, r5, lr}
3000c7cc: e1a04000 mov r4, r0
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server *serv_info;
Priority_Control new_priority;
_Scheduler_EDF_Enqueue(the_thread);
3000c7d0: eb00003d bl 3000c8cc <_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;
3000c7d4: e5943088 ldr r3, [r4, #136] ; 0x88 3000c7d8: 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) {
3000c7dc: e3530000 cmp r3, #0
3000c7e0: 0a000012 beq 3000c830 <_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 -
3000c7e4: e59f1094 ldr r1, [pc, #148] ; 3000c880 <_Scheduler_CBS_Unblock+0xb8><== NOT EXECUTED 3000c7e8: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED 3000c7ec: e5911000 ldr r1, [r1] <== NOT EXECUTED
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
3000c7f0: 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 -
3000c7f4: e0611002 rsb r1, r1, r2 <== NOT EXECUTED
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
3000c7f8: e0010190 mul r1, r0, r1 <== NOT EXECUTED 3000c7fc: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c800: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED 3000c804: e0030390 mul r3, r0, r3 <== NOT EXECUTED 3000c808: e1510003 cmp r1, r3 <== NOT EXECUTED 3000c80c: da000007 ble 3000c830 <_Scheduler_CBS_Unblock+0x68> <== NOT EXECUTED
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
3000c810: 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 )
3000c814: 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 )
3000c818: e1520001 cmp r2, r1 <== NOT EXECUTED
the_thread->real_priority = new_priority;
3000c81c: 15841018 strne r1, [r4, #24] <== NOT EXECUTED
if ( the_thread->current_priority != new_priority )
3000c820: e1530001 cmp r3, r1 <== NOT EXECUTED
_Thread_Change_priority(the_thread, new_priority, true);
3000c824: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c828: 13a02001 movne r2, #1 <== NOT EXECUTED 3000c82c: 1b0000f2 blne 3000cbfc <_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,
3000c830: e59f504c ldr r5, [pc, #76] ; 3000c884 <_Scheduler_CBS_Unblock+0xbc>
3000c834: e5940014 ldr r0, [r4, #20]
3000c838: e595300c ldr r3, [r5, #12]
3000c83c: e5931014 ldr r1, [r3, #20]
3000c840: e59f3040 ldr r3, [pc, #64] ; 3000c888 <_Scheduler_CBS_Unblock+0xc0>
3000c844: e1a0e00f mov lr, pc
3000c848: e593f030 ldr pc, [r3, #48] ; 0x30
3000c84c: e3500000 cmp r0, #0
3000c850: d8bd8030 pople {r4, r5, pc}
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000c854: 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;
3000c858: e585400c str r4, [r5, #12]
if ( _Thread_Executing->is_preemptible ||
3000c85c: e5d33070 ldrb r3, [r3, #112] ; 0x70 3000c860: e3530000 cmp r3, #0
3000c864: 1a000002 bne 3000c874 <_Scheduler_CBS_Unblock+0xac>
3000c868: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
3000c86c: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c870: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000c874: e3a03001 mov r3, #1
3000c878: e5c53004 strb r3, [r5, #4]
3000c87c: e8bd8030 pop {r4, r5, pc}
3000c88c <_Scheduler_EDF_Block>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Block(
Thread_Control *the_thread
)
{
3000c88c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000c890: e1a04000 mov r4, r0 <== NOT EXECUTED
_Scheduler_EDF_Extract( the_thread );
3000c894: eb000015 bl 3000c8f0 <_Scheduler_EDF_Extract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
3000c898: e59f3024 ldr r3, [pc, #36] ; 3000c8c4 <_Scheduler_EDF_Block+0x38><== NOT EXECUTED
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
3000c89c: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000c8a0: e1a05003 mov r5, r3 <== NOT EXECUTED 3000c8a4: e1540002 cmp r4, r2 <== NOT EXECUTED
_Scheduler_EDF_Schedule();
3000c8a8: 0b000040 bleq 3000c9b0 <_Scheduler_EDF_Schedule> <== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) )
3000c8ac: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c8b0: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000c8b4: 059f3008 ldreq r3, [pc, #8] ; 3000c8c4 <_Scheduler_EDF_Block+0x38><== NOT EXECUTED
3000c8b8: 03a02001 moveq r2, #1 <== NOT EXECUTED
3000c8bc: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED
3000c8c0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000c8c8 <_Scheduler_EDF_Enqueue_first>:
void _Scheduler_EDF_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler_EDF_Enqueue(the_thread);
3000c8c8: eaffffff b 3000c8cc <_Scheduler_EDF_Enqueue> <== NOT EXECUTED
3000c8f0 <_Scheduler_EDF_Extract>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Extract(
Thread_Control *the_thread
)
{
3000c8f0: e92d4010 push {r4, lr} <== NOT EXECUTED
Scheduler_EDF_Per_thread *sched_info =
3000c8f4: 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 );
3000c8f8: e59f0010 ldr r0, [pc, #16] ; 3000c910 <_Scheduler_EDF_Extract+0x20><== NOT EXECUTED 3000c8fc: e2841004 add r1, r4, #4 <== NOT EXECUTED 3000c900: eb00108e bl 30010b40 <_RBTree_Extract> <== NOT EXECUTED
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
3000c904: e3a03000 mov r3, #0 <== NOT EXECUTED 3000c908: e5843014 str r3, [r4, #20] <== NOT EXECUTED
}
3000c90c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c914 <_Scheduler_EDF_Free>:
void _Scheduler_EDF_Free(
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
3000c914: e5900088 ldr r0, [r0, #136] ; 0x88 <== NOT EXECUTED 3000c918: ea0005cb b 3000e04c <_Workspace_Free> <== NOT EXECUTED
3000c880 <_Scheduler_EDF_Release_job>:
uint32_t deadline
)
{
Priority_Control new_priority;
if (deadline) {
3000c880: e3510000 cmp r1, #0 <== NOT EXECUTED
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
3000c884: 159f3018 ldrne r3, [pc, #24] ; 3000c8a4 <_Scheduler_EDF_Release_job+0x24><== NOT EXECUTED
& ~SCHEDULER_EDF_PRIO_MSB;
}
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
3000c888: 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)
3000c88c: 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);
3000c890: e3a02001 mov r2, #1 <== NOT EXECUTED
{
Priority_Control new_priority;
if (deadline) {
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
3000c894: 10811003 addne r1, r1, r3 <== NOT EXECUTED 3000c898: 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;
3000c89c: e5801018 str r1, [r0, #24] <== NOT EXECUTED
_Thread_Change_priority(the_thread, new_priority, true);
3000c8a0: ea0000ac b 3000cb58 <_Thread_Change_priority> <== NOT EXECUTED
3000c9b0 <_Scheduler_EDF_Schedule>:
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
3000c9b0: e59f3010 ldr r3, [pc, #16] ; 3000c9c8 <_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;
3000c9b4: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c9b8: e5132004 ldr r2, [r3, #-4] <== NOT EXECUTED 3000c9bc: e59f3008 ldr r3, [pc, #8] ; 3000c9cc <_Scheduler_EDF_Schedule+0x1c><== NOT EXECUTED 3000c9c0: e583200c str r2, [r3, #12] <== NOT EXECUTED
}
3000c9c4: e12fff1e bx lr <== NOT EXECUTED
3000c8c8 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
3000c8c8: 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(
3000c8cc: e59f5050 ldr r5, [pc, #80] ; 3000c924 <_Scheduler_EDF_Unblock+0x5c>
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
3000c8d0: e1a04000 mov r4, r0
_Scheduler_EDF_Enqueue(the_thread);
3000c8d4: ebffffb0 bl 3000c79c <_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(
3000c8d8: e595300c ldr r3, [r5, #12]
3000c8dc: e5941014 ldr r1, [r4, #20]
3000c8e0: e5930014 ldr r0, [r3, #20]
3000c8e4: e59f303c ldr r3, [pc, #60] ; 3000c928 <_Scheduler_EDF_Unblock+0x60>
3000c8e8: e1a0e00f mov lr, pc
3000c8ec: e593f030 ldr pc, [r3, #48] ; 0x30
3000c8f0: e3500000 cmp r0, #0
3000c8f4: a8bd8030 popge {r4, r5, pc}
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000c8f8: 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;
3000c8fc: e585400c str r4, [r5, #12]
if ( _Thread_Executing->is_preemptible ||
3000c900: e5d33070 ldrb r3, [r3, #112] ; 0x70 3000c904: e3530000 cmp r3, #0
3000c908: 1a000002 bne 3000c918 <_Scheduler_EDF_Unblock+0x50>
3000c90c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
3000c910: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c914: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000c918: e3a03001 mov r3, #1
3000c91c: e5c53004 strb r3, [r5, #4]
3000c920: e8bd8030 pop {r4, r5, pc}
3000ca00 <_Scheduler_EDF_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
3000ca00: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000ca04: e59f5050 ldr r5, [pc, #80] ; 3000ca5c <_Scheduler_EDF_Yield+0x5c><== NOT EXECUTED
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
3000ca08: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
RBTree_Node *executing_node = &(executing_info->Node);
3000ca0c: e5936088 ldr r6, [r3, #136] ; 0x88 <== NOT EXECUTED 3000ca10: e2866004 add r6, r6, #4 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ca14: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000ca18: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000ca1c: 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 );
3000ca20: e59f7038 ldr r7, [pc, #56] ; 3000ca60 <_Scheduler_EDF_Yield+0x60><== NOT EXECUTED 3000ca24: e1a01006 mov r1, r6 <== NOT EXECUTED 3000ca28: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ca2c: eb001043 bl 30010b40 <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node );
3000ca30: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ca34: e1a01006 mov r1, r6 <== NOT EXECUTED 3000ca38: eb0010c5 bl 30010d54 <_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 (
3000ca3c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000ca40: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000ca44: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Flash( level );
_Scheduler_EDF_Schedule();
3000ca48: ebffffd8 bl 3000c9b0 <_Scheduler_EDF_Schedule> <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000ca4c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ca50: 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 (
3000ca54: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level );
}
3000ca58: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000c178 <_Scheduler_priority_Tick>:
void _Scheduler_priority_Tick( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
3000c178: e59f3090 ldr r3, [pc, #144] ; 3000c210 <_Scheduler_priority_Tick+0x98>
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
3000c17c: e92d4010 push {r4, lr}
Thread_Control *executing;
executing = _Thread_Executing;
3000c180: e5934008 ldr r4, [r3, #8]
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
3000c184: e5d43070 ldrb r3, [r4, #112] ; 0x70
3000c188: e3530000 cmp r3, #0
3000c18c: 08bd8010 popeq {r4, pc}
return;
if ( !_States_Is_ready( executing->current_state ) )
3000c190: e5943010 ldr r3, [r4, #16]
3000c194: e3530000 cmp r3, #0
3000c198: 18bd8010 popne {r4, pc}
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
3000c19c: e5943078 ldr r3, [r4, #120] ; 0x78
3000c1a0: e3530001 cmp r3, #1
3000c1a4: 38bd8010 popcc {r4, pc}
3000c1a8: e3530002 cmp r3, #2 <== NOT EXECUTED
3000c1ac: 9a000002 bls 3000c1bc <_Scheduler_priority_Tick+0x44> <== NOT EXECUTED
3000c1b0: e3530003 cmp r3, #3 <== NOT EXECUTED
3000c1b4: 18bd8010 popne {r4, pc} <== NOT EXECUTED
3000c1b8: ea00000b b 3000c1ec <_Scheduler_priority_Tick+0x74> <== 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 ) {
3000c1bc: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c1c0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000c1c4: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c1c8: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c1cc: 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();
3000c1d0: e59f303c ldr r3, [pc, #60] ; 3000c214 <_Scheduler_priority_Tick+0x9c><== NOT EXECUTED 3000c1d4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c1d8: 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;
3000c1dc: e59f3034 ldr r3, [pc, #52] ; 3000c218 <_Scheduler_priority_Tick+0xa0><== NOT EXECUTED
3000c1e0: e5933000 ldr r3, [r3] <== NOT EXECUTED
3000c1e4: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c1e8: 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 )
3000c1ec: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c1f0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000c1f4: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c1f8: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c1fc: 18bd8010 popne {r4, pc} <== NOT EXECUTED
(*executing->budget_callout)( executing );
3000c200: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c204: e1a0e00f mov lr, pc <== NOT EXECUTED
3000c208: e594f07c ldr pc, [r4, #124] ; 0x7c <== NOT EXECUTED
3000c20c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c79c <_Scheduler_simple_Block>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Block(
Thread_Control *the_thread
)
{
3000c79c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000c7a0: e1a04000 mov r4, r0 <== NOT EXECUTED
_Scheduler_simple_Extract(the_thread);
3000c7a4: eb00000d bl 3000c7e0 <_Scheduler_simple_Extract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
3000c7a8: e59f3024 ldr r3, [pc, #36] ; 3000c7d4 <_Scheduler_simple_Block+0x38><== NOT EXECUTED
if ( _Thread_Is_heir( the_thread ) )
3000c7ac: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000c7b0: e1a05003 mov r5, r3 <== NOT EXECUTED 3000c7b4: e1540002 cmp r4, r2 <== NOT EXECUTED
_Scheduler_simple_Schedule();
3000c7b8: 0b000042 bleq 3000c8c8 <_Scheduler_simple_Schedule> <== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) )
3000c7bc: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c7c0: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000c7c4: 059f3008 ldreq r3, [pc, #8] ; 3000c7d4 <_Scheduler_simple_Block+0x38><== NOT EXECUTED
3000c7c8: 03a02001 moveq r2, #1 <== NOT EXECUTED
3000c7cc: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED
3000c7d0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000c7dc <_Scheduler_simple_Enqueue>:
void _Scheduler_simple_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_enqueue( the_thread );
3000c7dc: ea000024 b 3000c874 <_Scheduler_simple_Ready_queue_enqueue><== NOT EXECUTED
3000c7d8 <_Scheduler_simple_Enqueue_first>:
void _Scheduler_simple_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_enqueue_first( the_thread );
3000c7d8: ea000014 b 3000c830 <_Scheduler_simple_Ready_queue_enqueue_first><== NOT EXECUTED
3000c7e0 <_Scheduler_simple_Extract>:
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000c7e0: e890000c ldm r0, {r2, r3} <== NOT EXECUTED
next->previous = previous;
3000c7e4: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000c7e8: e5832000 str r2, [r3] <== NOT EXECUTED
void _Scheduler_simple_Extract(
Thread_Control *the_thread
)
{
_Chain_Extract_unprotected( &the_thread->Object.Node );
}
3000c7ec: e12fff1e bx lr <== NOT EXECUTED
3000c7fc <_Scheduler_simple_Free>:
void _Scheduler_simple_Free(
Thread_Control *the_thread
)
{
}
3000c7fc: e12fff1e bx lr <== NOT EXECUTED
3000c874 <_Scheduler_simple_Ready_queue_enqueue>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000c874: e59f3048 ldr r3, [pc, #72] ; 3000c8c4 <_Scheduler_simple_Ready_queue_enqueue+0x50> 3000c878: e5933000 ldr r3, [r3]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000c87c: 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 ));
3000c880: 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 ) {
3000c884: ea000006 b 3000c8a4 <_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 ) {
3000c888: e590c014 ldr ip, [r0, #20] 3000c88c: e5923014 ldr r3, [r2, #20] 3000c890: e15c0003 cmp ip, r3
current = (Thread_Control *)current->Object.Node.previous;
3000c894: 35923004 ldrcc r3, [r2, #4]
break;
3000c898: 3a000003 bcc 3000c8ac <_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 ) {
3000c89c: e1a03002 mov r3, r2 <== NOT EXECUTED 3000c8a0: e5922000 ldr r2, [r2] <== NOT EXECUTED
3000c8a4: e1520001 cmp r2, r1
3000c8a8: 1afffff6 bne 3000c888 <_Scheduler_simple_Ready_queue_enqueue+0x14>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000c8ac: e5932000 ldr r2, [r3]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000c8b0: e5803004 str r3, [r0, #4]
before_node = after_node->next; after_node->next = the_node;
3000c8b4: e5830000 str r0, [r3]
the_node->next = before_node; before_node->previous = the_node;
3000c8b8: 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;
3000c8bc: e5802000 str r2, [r0]
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000c8c0: e12fff1e bx lr
3000c830 <_Scheduler_simple_Ready_queue_enqueue_first>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000c830: e59f3038 ldr r3, [pc, #56] ; 3000c870 <_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 ) {
3000c834: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000c838: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000c83c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000c840: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED 3000c844: e1520001 cmp r2, r1 <== NOT EXECUTED 3000c848: 8a000006 bhi 3000c868 <_Scheduler_simple_Ready_queue_enqueue_first+0x38><== NOT EXECUTED
current = (Thread_Control *)current->Object.Node.previous;
3000c84c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000c850: e5932000 ldr r2, [r3] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000c854: e5803004 str r3, [r0, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000c858: e5830000 str r0, [r3] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000c85c: 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;
3000c860: e5802000 str r2, [r0] <== NOT EXECUTED
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000c864: 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 ) {
3000c868: 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;
}
}
3000c86c: eafffff3 b 3000c840 <_Scheduler_simple_Ready_queue_enqueue_first+0x10><== NOT EXECUTED
3000c8c8 <_Scheduler_simple_Schedule>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Schedule(void)
{
_Thread_Heir = (Thread_Control *) _Chain_First(
(Chain_Control *) _Scheduler.information
3000c8c8: e59f3010 ldr r3, [pc, #16] ; 3000c8e0 <_Scheduler_simple_Schedule+0x18><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000c8cc: 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(
3000c8d0: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c8d4: e59f3008 ldr r3, [pc, #8] ; 3000c8e4 <_Scheduler_simple_Schedule+0x1c><== NOT EXECUTED 3000c8d8: e583200c str r2, [r3, #12] <== NOT EXECUTED
(Chain_Control *) _Scheduler.information
);
}
3000c8dc: e12fff1e bx lr <== NOT EXECUTED
3000c8e8 <_Scheduler_simple_Unblock>:
#include <rtems/score/thread.h>
void _Scheduler_simple_Unblock(
Thread_Control *the_thread
)
{
3000c8e8: e92d4010 push {r4, lr}
3000c8ec: e1a04000 mov r4, r0
_Scheduler_simple_Ready_queue_enqueue(the_thread);
3000c8f0: ebffffdf bl 3000c874 <_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 ) {
3000c8f4: e59f3038 ldr r3, [pc, #56] ; 3000c934 <_Scheduler_simple_Unblock+0x4c>
3000c8f8: e5942014 ldr r2, [r4, #20]
3000c8fc: e593100c ldr r1, [r3, #12]
3000c900: e5911014 ldr r1, [r1, #20]
3000c904: e1520001 cmp r2, r1
3000c908: 28bd8010 popcs {r4, pc}
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000c90c: 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;
3000c910: e583400c str r4, [r3, #12]
if ( _Thread_Executing->is_preemptible ||
3000c914: e5d11070 ldrb r1, [r1, #112] ; 0x70 3000c918: e3510000 cmp r1, #0
3000c91c: 1a000001 bne 3000c928 <_Scheduler_simple_Unblock+0x40>
3000c920: e3520000 cmp r2, #0 <== NOT EXECUTED
3000c924: 18bd8010 popne {r4, pc} <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000c928: e3a02001 mov r2, #1
3000c92c: e5c32004 strb r2, [r3, #4]
3000c930: e8bd8010 pop {r4, pc}
3000c938 <_Scheduler_simple_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/thread.h>
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Yield( void )
{
3000c938: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing;
executing = _Thread_Executing;
3000c93c: e59f5048 ldr r5, [pc, #72] ; 3000c98c <_Scheduler_simple_Yield+0x54><== NOT EXECUTED 3000c940: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c944: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000c948: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000c94c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000c950: e894000c ldm r4, {r2, r3} <== NOT EXECUTED
{
/* extract */
_Chain_Extract_unprotected( &the_thread->Object.Node );
/* enqueue */
_Scheduler_simple_Ready_queue_enqueue( the_thread );
3000c954: e1a00004 mov r0, r4 <== NOT EXECUTED
next->previous = previous;
3000c958: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000c95c: e5832000 str r2, [r3] <== NOT EXECUTED 3000c960: ebffffc3 bl 3000c874 <_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 (
3000c964: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000c968: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000c96c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_Scheduler_simple_Ready_queue_requeue(&_Scheduler, executing);
_ISR_Flash( level );
_Scheduler_simple_Schedule();
3000c970: ebffffd4 bl 3000c8c8 <_Scheduler_simple_Schedule> <== NOT EXECUTED
if ( !_Thread_Is_heir( executing ) )
3000c974: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000c978: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000c97c: 13a03001 movne r3, #1 <== NOT EXECUTED 3000c980: 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 (
3000c984: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
}
3000c988: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30004848 <_TOD_Get>:
);
static inline void _TOD_Get(
struct timespec *tod_as_timespec
)
{
30004848: e92d40d3 push {r0, r1, r4, r6, r7, lr} <== NOT EXECUTED
3000484c: e1a04000 mov r4, r0 <== NOT EXECUTED
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
30004850: e59f103c ldr r1, [pc, #60] ; 30004894 <_TOD_Get+0x4c> <== NOT EXECUTED 30004854: e1a0000d mov r0, sp <== NOT EXECUTED 30004858: eb001d70 bl 3000be20 <_TOD_Get_with_nanoseconds> <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
3000485c: e59f2034 ldr r2, [pc, #52] ; 30004898 <_TOD_Get+0x50> <== NOT EXECUTED
sleep(1);
puts( "*** END OF NANOSECOND CLOCK TEST ***" );
exit(0);
}
30004860: e89000c0 ldm r0, {r6, r7} <== NOT EXECUTED
30004864: e3a03000 mov r3, #0 <== NOT EXECUTED
30004868: e1a00006 mov r0, r6 <== NOT EXECUTED
3000486c: e1a01007 mov r1, r7 <== NOT EXECUTED
30004870: eb0000f1 bl 30004c3c <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30004874: 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);
30004878: e5840000 str r0, [r4] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000487c: e59f2014 ldr r2, [pc, #20] ; 30004898 <_TOD_Get+0x50> <== NOT EXECUTED 30004880: e1a00006 mov r0, r6 <== NOT EXECUTED 30004884: e3a03000 mov r3, #0 <== NOT EXECUTED 30004888: eb000226 bl 30005128 <__moddi3> <== NOT EXECUTED 3000488c: e5840004 str r0, [r4, #4] <== NOT EXECUTED
_TOD_Get_with_nanoseconds( &tod_as_timestamp, &_TOD.now );
_Timestamp_To_timespec( tod_as_timestamp_ptr, tod_as_timespec );
}
30004890: e8bd80dc pop {r2, r3, r4, r6, r7, pc} <== NOT EXECUTED
30027164 <_TOD_Get_uptime_as_timespec>:
#include <rtems/score/tod.h>
void _TOD_Get_uptime_as_timespec(
struct timespec *uptime
)
{
30027164: e92d40d3 push {r0, r1, r4, r6, r7, lr} <== NOT EXECUTED
30027168: e1a04000 mov r4, r0 <== NOT EXECUTED
3002716c: e59f103c ldr r1, [pc, #60] ; 300271b0 <_TOD_Get_uptime_as_timespec+0x4c><== NOT EXECUTED
30027170: e1a0000d mov r0, sp <== NOT EXECUTED
30027174: ebff91c8 bl 3000b89c <_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 );
30027178: 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);
3002717c: e59f2030 ldr r2, [pc, #48] ; 300271b4 <_TOD_Get_uptime_as_timespec+0x50><== NOT EXECUTED 30027180: e3a03000 mov r3, #0 <== NOT EXECUTED 30027184: e1a00006 mov r0, r6 <== NOT EXECUTED 30027188: e1a01007 mov r1, r7 <== NOT EXECUTED 3002718c: eb00a1fc bl 3004f984 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30027190: 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);
30027194: e5840000 str r0, [r4] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30027198: e59f2014 ldr r2, [pc, #20] ; 300271b4 <_TOD_Get_uptime_as_timespec+0x50><== NOT EXECUTED 3002719c: e1a00006 mov r0, r6 <== NOT EXECUTED 300271a0: e3a03000 mov r3, #0 <== NOT EXECUTED 300271a4: eb00a331 bl 3004fe70 <__moddi3> <== NOT EXECUTED 300271a8: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
300271ac: e8bd80dc pop {r2, r3, r4, r6, r7, pc} <== NOT EXECUTED
3000b0c4 <_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();
3000b0c4: e59f3074 ldr r3, [pc, #116] ; 3000b140 <_TOD_Tickle_ticks+0x7c>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
#include <rtems/config.h>
void _TOD_Tickle_ticks( void )
{
3000b0c8: e92d4030 push {r4, r5, lr}
Timestamp_Control tick;
uint32_t nanoseconds_per_tick;
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
3000b0cc: 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;
3000b0d0: e59f306c ldr r3, [pc, #108] ; 3000b144 <_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 );
3000b0d4: e3a01000 mov r1, #0
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000b0d8: e593c000 ldr ip, [r3] 3000b0dc: e28cc001 add ip, ip, #1 3000b0e0: e583c000 str ip, [r3]
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
3000b0e4: e59f305c ldr r3, [pc, #92] ; 3000b148 <_TOD_Tickle_ticks+0x84>
3000b0e8: e2835008 add r5, r3, #8
3000b0ec: e8950030 ldm r5, {r4, r5}
3000b0f0: e0944002 adds r4, r4, r2
3000b0f4: e0a55001 adc r5, r5, r1
3000b0f8: e5834008 str r4, [r3, #8]
3000b0fc: e583500c str r5, [r3, #12]
3000b100: e8930030 ldm r3, {r4, r5}
3000b104: e0944002 adds r4, r4, r2
3000b108: 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;
3000b10c: e5931010 ldr r1, [r3, #16]
3000b110: e8830030 stm r3, {r4, r5}
3000b114: e0821001 add r1, r2, r1
if ( _TOD.seconds_trigger >= 1000000000UL ) {
3000b118: e59f202c ldr r2, [pc, #44] ; 3000b14c <_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;
3000b11c: e5831010 str r1, [r3, #16]
if ( _TOD.seconds_trigger >= 1000000000UL ) {
3000b120: e1510002 cmp r1, r2
3000b124: 98bd8030 popls {r4, r5, pc}
_TOD.seconds_trigger -= 1000000000UL;
3000b128: e59f2020 ldr r2, [pc, #32] ; 3000b150 <_TOD_Tickle_ticks+0x8c><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
3000b12c: e59f0020 ldr r0, [pc, #32] ; 3000b154 <_TOD_Tickle_ticks+0x90><== NOT EXECUTED 3000b130: e0812002 add r2, r1, r2 <== NOT EXECUTED 3000b134: e5832010 str r2, [r3, #16] <== NOT EXECUTED
_Watchdog_Tickle_seconds();
}
}
3000b138: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3000b13c: ea000937 b 3000d620 <_Watchdog_Tickle> <== NOT EXECUTED
3000ada4 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
3000ada4: 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) ||
3000ada8: 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;
3000adac: 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) ||
3000adb0: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
3000adb4: e59f309c ldr r3, [pc, #156] ; 3000ae58 <_TOD_Validate+0xb4> 3000adb8: e59f009c ldr r0, [pc, #156] ; 3000ae5c <_TOD_Validate+0xb8> 3000adbc: e593100c ldr r1, [r3, #12] 3000adc0: eb004683 bl 3001c7d4 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
3000adc4: e5943018 ldr r3, [r4, #24] 3000adc8: e1530000 cmp r3, r0
3000adcc: 2a00001d bcs 3000ae48 <_TOD_Validate+0xa4>
(the_tod->ticks >= ticks_per_second) ||
3000add0: e5943014 ldr r3, [r4, #20] 3000add4: e353003b cmp r3, #59 ; 0x3b
3000add8: 8a00001a bhi 3000ae48 <_TOD_Validate+0xa4>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
3000addc: e5943010 ldr r3, [r4, #16] 3000ade0: e353003b cmp r3, #59 ; 0x3b
3000ade4: 8a000017 bhi 3000ae48 <_TOD_Validate+0xa4>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
3000ade8: e594300c ldr r3, [r4, #12] 3000adec: e3530017 cmp r3, #23
3000adf0: 8a000014 bhi 3000ae48 <_TOD_Validate+0xa4>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
3000adf4: 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) ||
3000adf8: 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;
3000adfc: 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) ||
3000ae00: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
3000ae04: e353000c cmp r3, #12
3000ae08: 8a00000e bhi 3000ae48 <_TOD_Validate+0xa4>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000ae0c: 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) ||
3000ae10: e59f1048 ldr r1, [pc, #72] ; 3000ae60 <_TOD_Validate+0xbc> 3000ae14: e1520001 cmp r2, r1
3000ae18: 9a00000c bls 3000ae50 <_TOD_Validate+0xac>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
3000ae1c: 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) ||
3000ae20: e3500000 cmp r0, #0
3000ae24: 08bd8010 popeq {r4, pc}
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
3000ae28: e3120003 tst r2, #3 3000ae2c: e59f2030 ldr r2, [pc, #48] ; 3000ae64 <_TOD_Validate+0xc0>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000ae30: 0283300d addeq r3, r3, #13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000ae34: 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(
3000ae38: e1500004 cmp r0, r4
3000ae3c: 83a00000 movhi r0, #0
3000ae40: 93a00001 movls r0, #1
3000ae44: 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;
3000ae48: e3a00000 mov r0, #0 <== NOT EXECUTED
3000ae4c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ae50: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
3000ae54: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c40c <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
3000c40c: e92d40f0 push {r4, r5, r6, r7, lr}
3000c410: e1a04000 mov r4, r0
3000c414: e1a05001 mov r5, r1
3000c418: e20260ff and r6, r2, #255 ; 0xff
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
3000c41c: 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 );
3000c420: eb000333 bl 3000d0f4 <_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 )
3000c424: e5943014 ldr r3, [r4, #20] 3000c428: e1530005 cmp r3, r5
_Thread_Set_priority( the_thread, new_priority );
3000c42c: 11a00004 movne r0, r4 3000c430: 11a01005 movne r1, r5 3000c434: 1b000318 blne 3000d09c <_Thread_Set_priority>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c438: e10f5000 mrs r5, CPSR 3000c43c: e3853080 orr r3, r5, #128 ; 0x80 3000c440: 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;
3000c444: e5942010 ldr r2, [r4, #16] 3000c448: e2077004 and r7, r7, #4
if ( state != STATES_TRANSIENT ) {
3000c44c: e3520004 cmp r2, #4
3000c450: 0a00000b beq 3000c484 <_Thread_Change_priority+0x78>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
3000c454: 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);
3000c458: 03c23004 biceq r3, r2, #4 <== NOT EXECUTED
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000c45c: 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 (
3000c460: 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);
3000c464: e59f308c ldr r3, [pc, #140] ; 3000c4f8 <_Thread_Change_priority+0xec><== NOT EXECUTED 3000c468: e0023003 and r3, r2, r3 <== NOT EXECUTED
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
3000c46c: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c470: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000c474: e5940044 ldr r0, [r4, #68] ; 0x44 <== NOT EXECUTED 3000c478: e1a01004 mov r1, r4 <== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
3000c47c: 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 );
3000c480: ea0002e0 b 3000d008 <_Thread_queue_Requeue> <== NOT EXECUTED
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
3000c484: e3570000 cmp r7, #0
3000c488: 1a000009 bne 3000c4b4 <_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 )
3000c48c: 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 );
3000c490: e5847010 str r7, [r4, #16]
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
3000c494: e1a00004 mov r0, r4 3000c498: e59f305c ldr r3, [pc, #92] ; 3000c4fc <_Thread_Change_priority+0xf0>
if ( prepend_it )
3000c49c: 0a000002 beq 3000c4ac <_Thread_Change_priority+0xa0>
3000c4a0: e1a0e00f mov lr, pc 3000c4a4: e593f028 ldr pc, [r3, #40] ; 0x28 3000c4a8: ea000001 b 3000c4b4 <_Thread_Change_priority+0xa8>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
3000c4ac: e1a0e00f mov lr, pc 3000c4b0: 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 (
3000c4b4: e10f3000 mrs r3, CPSR 3000c4b8: e129f005 msr CPSR_fc, r5 3000c4bc: 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();
3000c4c0: e59f3034 ldr r3, [pc, #52] ; 3000c4fc <_Thread_Change_priority+0xf0> 3000c4c4: e1a0e00f mov lr, pc 3000c4c8: 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 );
3000c4cc: e59f302c ldr r3, [pc, #44] ; 3000c500 <_Thread_Change_priority+0xf4> 3000c4d0: 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() &&
3000c4d4: e593100c ldr r1, [r3, #12] 3000c4d8: e1520001 cmp r2, r1
3000c4dc: 0a000003 beq 3000c4f0 <_Thread_Change_priority+0xe4>
3000c4e0: e5d22070 ldrb r2, [r2, #112] ; 0x70 3000c4e4: e3520000 cmp r2, #0
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
3000c4e8: 13a02001 movne r2, #1 3000c4ec: 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 (
3000c4f0: e129f005 msr CPSR_fc, r5
3000c4f4: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000c6d4 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000c6d4: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000c6d8: e1a0100d mov r1, sp <== NOT EXECUTED 3000c6dc: eb00006b bl 3000c890 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000c6e0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000c6e4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c6e8: 1a000005 bne 3000c704 <_Thread_Delay_ended+0x30> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
3000c6ec: e59f1014 ldr r1, [pc, #20] ; 3000c708 <_Thread_Delay_ended+0x34><== NOT EXECUTED 3000c6f0: ebffff83 bl 3000c504 <_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;
3000c6f4: e59f3010 ldr r3, [pc, #16] ; 3000c70c <_Thread_Delay_ended+0x38><== NOT EXECUTED 3000c6f8: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000c6fc: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000c700: e5832000 str r2, [r3] <== NOT EXECUTED
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
3000c704: e8bd8008 pop {r3, pc} <== NOT EXECUTED
3000c890 <_Thread_Get>:
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
3000c890: 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 ) ) {
3000c894: e2501000 subs r1, r0, #0
3000c898: 1a000007 bne 3000c8bc <_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;
3000c89c: e59f3074 ldr r3, [pc, #116] ; 3000c918 <_Thread_Get+0x88> 3000c8a0: e5930000 ldr r0, [r3]
++level;
3000c8a4: e2800001 add r0, r0, #1
_Thread_Dispatch_disable_level = level;
3000c8a8: e5830000 str r0, [r3]
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
tp = _Thread_Executing;
3000c8ac: e59f3068 ldr r3, [pc, #104] ; 3000c91c <_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;
3000c8b0: e5821000 str r1, [r2]
tp = _Thread_Executing;
3000c8b4: e5930008 ldr r0, [r3, #8]
goto done;
3000c8b8: 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);
3000c8bc: e1a00c21 lsr r0, r1, #24 3000c8c0: 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 )
3000c8c4: e2403001 sub r3, r0, #1 3000c8c8: e3530002 cmp r3, #2
3000c8cc: 9a00000d bls 3000c908 <_Thread_Get+0x78>
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
3000c8d0: e3a03001 mov r3, #1 3000c8d4: 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;
3000c8d8: e3a00000 mov r0, #0
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
3000c8dc: e12fff1e bx lr
}
api_information = _Objects_Information_table[ the_api ];
3000c8e0: e59fc038 ldr ip, [pc, #56] ; 3000c920 <_Thread_Get+0x90> 3000c8e4: 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 ) {
3000c8e8: e3500000 cmp r0, #0
3000c8ec: 0a000002 beq 3000c8fc <_Thread_Get+0x6c>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
3000c8f0: e5900004 ldr r0, [r0, #4]
if ( !information ) {
3000c8f4: e3500000 cmp r0, #0
3000c8f8: 1a000001 bne 3000c904 <_Thread_Get+0x74>
*location = OBJECTS_ERROR;
3000c8fc: e5823000 str r3, [r2] <== NOT EXECUTED
goto done;
3000c900: e12fff1e bx lr <== NOT EXECUTED
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
3000c904: eafffc4c b 3000ba3c <_Objects_Get>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000c908: 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 :) */
3000c90c: e3530001 cmp r3, #1
3000c910: 0afffff2 beq 3000c8e0 <_Thread_Get+0x50>
3000c914: eaffffed b 3000c8d0 <_Thread_Get+0x40> <== NOT EXECUTED
3000d1d0 <_Thread_Start>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
3000d1d0: e590c010 ldr ip, [r0, #16]
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000d1d4: e92d4010 push {r4, lr}
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000d1d8: e21cc001 ands ip, ip, #1
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000d1dc: e1a04000 mov r4, r0
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000d1e0: 0a00000c beq 3000d218 <_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;
3000d1e4: e5803094 str r3, [r0, #148] ; 0x94
the_thread->Start.numeric_argument = numeric_argument;
3000d1e8: 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;
3000d1ec: e580208c str r2, [r0, #140] ; 0x8c
the_thread->Start.prototype = the_prototype;
3000d1f0: e5801090 str r1, [r0, #144] ; 0x90
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
3000d1f4: e5803098 str r3, [r0, #152] ; 0x98
_Thread_Load_environment( the_thread );
3000d1f8: eb000b45 bl 3000ff14 <_Thread_Load_environment>
_Thread_Ready( the_thread );
3000d1fc: e1a00004 mov r0, r4 3000d200: eb000bd9 bl 3001016c <_Thread_Ready>
);
}
static inline void _User_extensions_Thread_start( Thread_Control *started )
{
_User_extensions_Iterate(
3000d204: e1a00004 mov r0, r4 3000d208: e59f1010 ldr r1, [pc, #16] ; 3000d220 <_Thread_Start+0x50> 3000d20c: eb000041 bl 3000d318 <_User_extensions_Iterate>
_User_extensions_Thread_start( the_thread );
return true;
3000d210: e3a00001 mov r0, #1
3000d214: e8bd8010 pop {r4, pc}
}
return false;
3000d218: e1a0000c mov r0, ip <== NOT EXECUTED
}
3000d21c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c3c0 <_Thread_blocking_operation_Cancel>:
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000c3c0: e3a03000 mov r3, #0 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000c3c4: e92d4010 push {r4, lr} <== NOT EXECUTED
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000c3c8: 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 ) ) {
3000c3cc: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000c3d0: 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 ) ) {
3000c3d4: e3530002 cmp r3, #2 <== NOT EXECUTED 3000c3d8: 1a000005 bne 3000c3f4 <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000c3dc: e3a03003 mov r3, #3 <== NOT EXECUTED 3000c3e0: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000c3e4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000c3e8: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000c3ec: eb000462 bl 3000d57c <_Watchdog_Remove> <== NOT EXECUTED 3000c3f0: ea000000 b 3000c3f8 <_Thread_blocking_operation_Cancel+0x38><== NOT EXECUTED 3000c3f4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000c3f8: e59f1008 ldr r1, [pc, #8] ; 3000c408 <_Thread_blocking_operation_Cancel+0x48><== NOT EXECUTED 3000c3fc: 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
}
3000c400: e8bd4010 pop {r4, lr} <== NOT EXECUTED
3000c404: ea00003e b 3000c504 <_Thread_Clear_state> <== NOT EXECUTED
3000ff60 <_Thread_queue_Dequeue_fifo>:
#include <rtems/score/tqdata.h>
Thread_Control *_Thread_queue_Dequeue_fifo(
Thread_queue_Control *the_thread_queue
)
{
3000ff60: e92d4010 push {r4, lr}
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ff64: e10f3000 mrs r3, CPSR 3000ff68: e3832080 orr r2, r3, #128 ; 0x80 3000ff6c: 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;
3000ff70: e1a02000 mov r2, r0 3000ff74: e4924004 ldr r4, [r2], #4
ISR_Level level;
Thread_Control *the_thread;
_ISR_Disable( level );
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
3000ff78: e1540002 cmp r4, r2
3000ff7c: 0a000012 beq 3000ffcc <_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;
3000ff80: e5942000 ldr r2, [r4]
head->next = new_first;
3000ff84: e5802000 str r2, [r0]
new_first->previous = head;
3000ff88: e5820004 str r0, [r2, #4]
the_thread = (Thread_Control *)
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
3000ff8c: e3a02000 mov r2, #0 3000ff90: e5842044 str r2, [r4, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000ff94: e5942050 ldr r2, [r4, #80] ; 0x50 3000ff98: e3520002 cmp r2, #2
3000ff9c: 0a000001 beq 3000ffa8 <_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 (
3000ffa0: e129f003 msr CPSR_fc, r3 3000ffa4: ea000004 b 3000ffbc <_Thread_queue_Dequeue_fifo+0x5c>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000ffa8: e3a02003 mov r2, #3 <== NOT EXECUTED 3000ffac: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 3000ffb0: 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 );
3000ffb4: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000ffb8: ebfff56f bl 3000d57c <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000ffbc: e1a00004 mov r0, r4 3000ffc0: e59f1014 ldr r1, [pc, #20] ; 3000ffdc <_Thread_queue_Dequeue_fifo+0x7c> 3000ffc4: ebfff14e bl 3000c504 <_Thread_Clear_state> 3000ffc8: ea000001 b 3000ffd4 <_Thread_queue_Dequeue_fifo+0x74> 3000ffcc: e129f003 msr CPSR_fc, r3
return the_thread;
}
_ISR_Enable( level );
return NULL;
3000ffd0: e3a04000 mov r4, #0
}
3000ffd4: e1a00004 mov r0, r4
3000ffd8: e8bd8010 pop {r4, pc}
3000cc28 <_Thread_queue_Dequeue_priority>:
#include <rtems/score/tqdata.h>
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
3000cc28: e92d4030 push {r4, r5, lr}
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000cc2c: e10f2000 mrs r2, CPSR 3000cc30: e3823080 orr r3, r2, #128 ; 0x80 3000cc34: e129f003 msr CPSR_fc, r3
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000cc38: e3a03000 mov r3, #0
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
3000cc3c: e3a0c00c mov ip, #12 3000cc40: 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;
3000cc44: e7904001 ldr r4, [r0, r1] 3000cc48: 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 );
3000cc4c: e2851004 add r1, r5, #4 3000cc50: e1540001 cmp r4, r1
3000cc54: 0a000008 beq 3000cc7c <_Thread_queue_Dequeue_priority+0x54>
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
3000cc58: e3a03000 mov r3, #0 3000cc5c: e5843044 str r3, [r4, #68] ; 0x44
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000cc60: 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 );
3000cc64: 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 ) ) {
3000cc68: 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;
3000cc6c: e5941000 ldr r1, [r4]
previous_node = the_thread->Object.Node.previous;
3000cc70: e5940004 ldr r0, [r4, #4]
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000cc74: 1a000006 bne 3000cc94 <_Thread_queue_Dequeue_priority+0x6c>
3000cc78: ea000016 b 3000ccd8 <_Thread_queue_Dequeue_priority+0xb0>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000cc7c: e2833001 add r3, r3, #1
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000cc80: e3530004 cmp r3, #4
3000cc84: 1affffed bne 3000cc40 <_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 (
3000cc88: e129f002 msr CPSR_fc, r2
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
return NULL;
3000cc8c: e3a04000 mov r4, #0 3000cc90: ea00001f b 3000cd14 <_Thread_queue_Dequeue_priority+0xec>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
3000cc94: 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;
3000cc98: e593e000 ldr lr, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000cc9c: 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;
3000cca0: e5803000 str r3, [r0] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000cca4: 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;
3000cca8: e5831000 str r1, [r3] <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000ccac: e5940038 ldr r0, [r4, #56] ; 0x38 <== NOT EXECUTED 3000ccb0: e5941040 ldr r1, [r4, #64] ; 0x40 <== NOT EXECUTED 3000ccb4: e1500001 cmp r0, r1 <== NOT EXECUTED 3000ccb8: 0a000008 beq 3000cce0 <_Thread_queue_Dequeue_priority+0xb8><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000ccbc: 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;
3000ccc0: 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;
3000ccc4: e58e1004 str r1, [lr, #4] <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
3000ccc8: 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 );
3000cccc: 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;
3000ccd0: e58c3000 str r3, [ip] <== NOT EXECUTED 3000ccd4: ea000001 b 3000cce0 <_Thread_queue_Dequeue_priority+0xb8> <== NOT EXECUTED
}
} else {
previous_node->next = next_node;
3000ccd8: e5801000 str r1, [r0]
next_node->previous = previous_node;
3000ccdc: e5810004 str r0, [r1, #4]
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000cce0: e5943050 ldr r3, [r4, #80] ; 0x50 3000cce4: e3530002 cmp r3, #2
3000cce8: 0a000001 beq 3000ccf4 <_Thread_queue_Dequeue_priority+0xcc>
3000ccec: e129f002 msr CPSR_fc, r2 3000ccf0: ea000004 b 3000cd08 <_Thread_queue_Dequeue_priority+0xe0>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000ccf4: e3a03003 mov r3, #3 <== NOT EXECUTED 3000ccf8: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000ccfc: 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 );
3000cd00: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000cd04: eb00021c bl 3000d57c <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000cd08: e1a00004 mov r0, r4 3000cd0c: e59f1008 ldr r1, [pc, #8] ; 3000cd1c <_Thread_queue_Dequeue_priority+0xf4> 3000cd10: ebfffdfb bl 3000c504 <_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 );
}
3000cd14: e1a00004 mov r0, r4
3000cd18: e8bd8030 pop {r4, r5, pc}
3000ffe0 <_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
)
{
3000ffe0: e92d4010 push {r4, lr}
3000ffe4: e1a03000 mov r3, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ffe8: e10fc000 mrs ip, CPSR 3000ffec: e38c0080 orr r0, ip, #128 ; 0x80 3000fff0: e129f000 msr CPSR_fc, r0
Thread_blocking_operation_States sync_state;
ISR_Level level;
_ISR_Disable( level );
sync_state = the_thread_queue->sync_state;
3000fff4: e5930030 ldr r0, [r3, #48] ; 0x30
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000fff8: e3a04000 mov r4, #0
if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
3000fffc: 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;
30010000: e5834030 str r4, [r3, #48] ; 0x30
if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
30010004: 1a000008 bne 3001002c <_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;
30010008: 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 );
3001000c: e2834004 add r4, r3, #4
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
30010010: e5831008 str r1, [r3, #8]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
30010014: e5814000 str r4, [r1]
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
30010018: 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;
3001001c: e5821000 str r1, [r2]
_Chain_Append_unprotected(
&the_thread_queue->Queues.Fifo,
&the_thread->Object.Node
);
the_thread->Wait.queue = the_thread_queue;
30010020: 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 (
30010024: e129f00c msr CPSR_fc, ip
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30010028: 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;
3001002c: e582c000 str ip, [r2] <== NOT EXECUTED
return sync_state; }
30010030: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cdc0 <_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 );
3000cdc0: e281c03c add ip, r1, #60 ; 0x3c
head->next = tail;
3000cdc4: e581c038 str ip, [r1, #56] ; 0x38
head->previous = NULL;
3000cdc8: e3a0c000 mov ip, #0 3000cdcc: 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;
3000cdd0: 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 );
3000cdd4: 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
)
{
3000cdd8: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
head->next = tail;
head->previous = NULL;
tail->previous = head;
3000cddc: 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 ];
3000cde0: 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);
3000cde4: e1a0332c lsr r3, ip, #6
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
3000cde8: 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 ];
3000cdec: e0250593 mla r5, r3, r5, r0
block_state = the_thread_queue->state;
3000cdf0: 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;
3000cdf4: 159fa150 ldrne sl, [pc, #336] ; 3000cf4c <_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 ) )
3000cdf8: 1a000022 bne 3000ce88 <_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 ));
3000cdfc: e285a004 add sl, r5, #4
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ce00: e10f4000 mrs r4, CPSR 3000ce04: e3843080 orr r3, r4, #128 ; 0x80 3000ce08: e129f003 msr CPSR_fc, r3 3000ce0c: e1a06004 mov r6, r4
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
3000ce10: e3e07000 mvn r7, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000ce14: e5953000 ldr r3, [r5]
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000ce18: ea00000b b 3000ce4c <_Thread_queue_Enqueue_priority+0x8c>
search_priority = search_thread->current_priority;
3000ce1c: e5937014 ldr r7, [r3, #20]
if ( priority <= search_priority )
3000ce20: e15c0007 cmp ip, r7
3000ce24: 9a00000a bls 3000ce54 <_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 (
3000ce28: e10f9000 mrs r9, CPSR 3000ce2c: e129f004 msr CPSR_fc, r4 3000ce30: 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);
3000ce34: 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) ) {
3000ce38: e1180009 tst r8, r9
3000ce3c: 1a000001 bne 3000ce48 <_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 (
3000ce40: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000ce44: eaffffed b 3000ce00 <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
3000ce48: 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 ) ) {
3000ce4c: e153000a cmp r3, sl
3000ce50: 1afffff1 bne 3000ce1c <_Thread_queue_Enqueue_priority+0x5c>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
3000ce54: e5905030 ldr r5, [r0, #48] ; 0x30 3000ce58: e3550001 cmp r5, #1
3000ce5c: 1a000037 bne 3000cf40 <_Thread_queue_Enqueue_priority+0x180>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000ce60: e3a02000 mov r2, #0
if ( priority == search_priority )
3000ce64: 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;
3000ce68: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
3000ce6c: 0a000029 beq 3000cf18 <_Thread_queue_Enqueue_priority+0x158>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
3000ce70: e5932004 ldr r2, [r3, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000ce74: e5813000 str r3, [r1]
the_node->previous = previous_node;
3000ce78: e5812004 str r2, [r1, #4]
previous_node->next = the_node;
3000ce7c: e5821000 str r1, [r2]
search_node->previous = the_node;
3000ce80: e5831004 str r1, [r3, #4] 3000ce84: ea000020 b 3000cf0c <_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;
3000ce88: e5da7000 ldrb r7, [sl] 3000ce8c: e2877001 add r7, r7, #1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ce90: e10f4000 mrs r4, CPSR 3000ce94: e3843080 orr r3, r4, #128 ; 0x80 3000ce98: e129f003 msr CPSR_fc, r3 3000ce9c: e1a06004 mov r6, r4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
3000cea0: e5953008 ldr r3, [r5, #8]
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
3000cea4: ea00000b b 3000ced8 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
3000cea8: e5937014 ldr r7, [r3, #20]
if ( priority >= search_priority )
3000ceac: e15c0007 cmp ip, r7
3000ceb0: 2a00000a bcs 3000cee0 <_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 (
3000ceb4: e10f9000 mrs r9, CPSR <== NOT EXECUTED 3000ceb8: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000cebc: e129f009 msr CPSR_fc, r9 <== NOT EXECUTED 3000cec0: 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) ) {
3000cec4: e1180009 tst r8, r9 <== NOT EXECUTED 3000cec8: 1a000001 bne 3000ced4 <_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 (
3000cecc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000ced0: eaffffec b 3000ce88 <_Thread_queue_Enqueue_priority+0xc8> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
3000ced4: 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 ) ) {
3000ced8: e1530005 cmp r3, r5
3000cedc: 1afffff1 bne 3000cea8 <_Thread_queue_Enqueue_priority+0xe8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
3000cee0: e5905030 ldr r5, [r0, #48] ; 0x30 3000cee4: e3550001 cmp r5, #1
3000cee8: 1a000014 bne 3000cf40 <_Thread_queue_Enqueue_priority+0x180>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000ceec: e3a02000 mov r2, #0
if ( priority == search_priority )
3000cef0: 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;
3000cef4: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
3000cef8: 0a000006 beq 3000cf18 <_Thread_queue_Enqueue_priority+0x158>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
3000cefc: e5932000 ldr r2, [r3]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
3000cf00: e881000c stm r1, {r2, r3}
search_node->next = the_node;
3000cf04: e5831000 str r1, [r3]
next_node->previous = the_node;
3000cf08: e5821004 str r1, [r2, #4]
the_thread->Wait.queue = the_thread_queue;
3000cf0c: e5810044 str r0, [r1, #68] ; 0x44 3000cf10: e129f004 msr CPSR_fc, r4 3000cf14: ea000007 b 3000cf38 <_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;
3000cf18: 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 );
3000cf1c: e283c03c add ip, r3, #60 ; 0x3c <== NOT EXECUTED
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000cf20: e581c000 str ip, [r1] <== NOT EXECUTED
the_node->previous = previous_node;
3000cf24: e5812004 str r2, [r1, #4] <== NOT EXECUTED
previous_node->next = the_node;
3000cf28: e5821000 str r1, [r2] <== NOT EXECUTED
search_node->previous = the_node;
3000cf2c: e5831040 str r1, [r3, #64] ; 0x40 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
3000cf30: e5810044 str r0, [r1, #68] ; 0x44 <== NOT EXECUTED 3000cf34: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000cf38: e3a00001 mov r0, #1
3000cf3c: 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;
3000cf40: e5826000 str r6, [r2] <== NOT EXECUTED
return the_thread_queue->sync_state;
3000cf44: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
}
3000cf48: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
30011828 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
30011828: e92d4010 push {r4, lr}
3001182c: e1a04001 mov r4, r1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30011830: e10f3000 mrs r3, CPSR 30011834: e3832080 orr r2, r3, #128 ; 0x80 30011838: e129f002 msr CPSR_fc, r2 3001183c: e59f2060 ldr r2, [pc, #96] ; 300118a4 <_Thread_queue_Extract_fifo+0x7c> 30011840: e5911010 ldr r1, [r1, #16] 30011844: e0012002 and r2, r1, r2
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
30011848: e3520000 cmp r2, #0
3001184c: 1a000001 bne 30011858 <_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 (
30011850: 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
}
30011854: e8bd8010 pop {r4, pc}
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
30011858: e8940006 ldm r4, {r1, r2}
next->previous = previous;
3001185c: e5812004 str r2, [r1, #4]
previous->next = next;
30011860: e5821000 str r1, [r2]
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
30011864: e3a02000 mov r2, #0 30011868: e5842044 str r2, [r4, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3001186c: e5942050 ldr r2, [r4, #80] ; 0x50 30011870: e3520002 cmp r2, #2
30011874: 0a000001 beq 30011880 <_Thread_queue_Extract_fifo+0x58>
30011878: e129f003 msr CPSR_fc, r3 3001187c: ea000004 b 30011894 <_Thread_queue_Extract_fifo+0x6c>
30011880: e3a02003 mov r2, #3 <== NOT EXECUTED 30011884: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 30011888: 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 );
3001188c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30011890: ebffef39 bl 3000d57c <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30011894: e59f100c ldr r1, [pc, #12] ; 300118a8 <_Thread_queue_Extract_fifo+0x80> 30011898: e1a00004 mov r0, r4
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3001189c: e8bd4010 pop {r4, lr}
300118a0: eaffeb17 b 3000c504 <_Thread_Clear_state>
3001004c <_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
)
{
3001004c: e92d4070 push {r4, r5, r6, lr}
30010050: e20220ff and r2, r2, #255 ; 0xff
30010054: e1a04001 mov r4, r1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30010058: e10f1000 mrs r1, CPSR 3001005c: e3813080 orr r3, r1, #128 ; 0x80 30010060: 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);
30010064: e59f30ac ldr r3, [pc, #172] ; 30010118 <_Thread_queue_Extract_priority_helper+0xcc> 30010068: e5940010 ldr r0, [r4, #16] 3001006c: 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 ) ) {
30010070: e3530000 cmp r3, #0
30010074: 0a000017 beq 300100d8 <_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;
30010078: 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 );
3001007c: 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 ) ) {
30010080: 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;
30010084: 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;
30010088: 058c0000 streq r0, [ip] <== NOT EXECUTED
next_node->previous = previous_node;
3001008c: 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 ) ) {
30010090: 0a00000e beq 300100d0 <_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;
30010094: 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;
30010098: e5936000 ldr r6, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3001009c: 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;
300100a0: e58c3000 str r3, [ip] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
300100a4: e8831001 stm r3, {r0, ip} <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
300100a8: e594c038 ldr ip, [r4, #56] ; 0x38 <== NOT EXECUTED 300100ac: e5940040 ldr r0, [r4, #64] ; 0x40 <== NOT EXECUTED 300100b0: e15c0000 cmp ip, r0 <== NOT EXECUTED 300100b4: 0a000005 beq 300100d0 <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
300100b8: 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;
300100bc: 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;
300100c0: e5860004 str r0, [r6, #4] <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
300100c4: 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 );
300100c8: 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;
300100cc: e5853000 str r3, [r5] <== NOT EXECUTED
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
300100d0: e3520000 cmp r2, #0 <== NOT EXECUTED 300100d4: 0a000001 beq 300100e0 <_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 (
300100d8: e129f001 msr CPSR_fc, r1
300100dc: e8bd8070 pop {r4, r5, r6, pc}
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
300100e0: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 300100e4: e3530002 cmp r3, #2 <== NOT EXECUTED 300100e8: 0a000001 beq 300100f4 <_Thread_queue_Extract_priority_helper+0xa8><== NOT EXECUTED 300100ec: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 300100f0: ea000004 b 30010108 <_Thread_queue_Extract_priority_helper+0xbc><== NOT EXECUTED 300100f4: e3a03003 mov r3, #3 <== NOT EXECUTED 300100f8: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 300100fc: 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 );
30010100: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30010104: ebfff51c bl 3000d57c <_Watchdog_Remove> <== NOT EXECUTED 30010108: e59f100c ldr r1, [pc, #12] ; 3001011c <_Thread_queue_Extract_priority_helper+0xd0><== NOT EXECUTED 3001010c: 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
}
30010110: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
30010114: eafff0fa b 3000c504 <_Thread_Clear_state> <== NOT EXECUTED
3000edb0 <_Thread_queue_First_priority>:
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3000edb0: 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 ] ) )
3000edb4: e3a0100c mov r1, #12 <== NOT EXECUTED 3000edb8: e0020391 mul r2, r1, r3 <== NOT EXECUTED 3000edbc: 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;
3000edc0: 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 );
3000edc4: e28cc004 add ip, ip, #4 <== NOT EXECUTED 3000edc8: e152000c cmp r2, ip <== NOT EXECUTED 3000edcc: 1a000003 bne 3000ede0 <_Thread_queue_First_priority+0x30> <== NOT EXECUTED
{
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000edd0: e2833001 add r3, r3, #1 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3000edd4: e3530004 cmp r3, #4 <== NOT EXECUTED 3000edd8: 1afffff6 bne 3000edb8 <_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;
3000eddc: e3a02000 mov r2, #0 <== NOT EXECUTED
}
3000ede0: e1a00002 mov r0, r2 <== NOT EXECUTED 3000ede4: e12fff1e bx lr <== NOT EXECUTED
30010120 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
30010120: e1a01000 mov r1, r0 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
30010124: 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 &&
30010128: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3001012c: e3530000 cmp r3, #0 <== NOT EXECUTED 30010130: 0a000009 beq 3001015c <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
30010134: e59f202c ldr r2, [pc, #44] ; 30010168 <_Thread_queue_Process_timeout+0x48><== NOT EXECUTED 30010138: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3001013c: e1510002 cmp r1, r2 <== NOT EXECUTED 30010140: 1a000005 bne 3001015c <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
30010144: e3530003 cmp r3, #3 <== NOT EXECUTED
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
30010148: 1590303c ldrne r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3001014c: 15813034 strne r3, [r1, #52] ; 0x34 <== NOT EXECUTED
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
30010150: 13a03002 movne r3, #2 <== NOT EXECUTED 30010154: 15803030 strne r3, [r0, #48] ; 0x30 <== NOT EXECUTED 30010158: e12fff1e bx lr <== NOT EXECUTED
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
3001015c: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 30010160: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
30010164: eaffffb2 b 30010034 <_Thread_queue_Extract> <== NOT EXECUTED
3000d008 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000d008: 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 )
3000d00c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000d010: 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 )
3000d014: 0a000011 beq 3000d060 <_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 ) {
3000d018: e5942034 ldr r2, [r4, #52] ; 0x34 <== NOT EXECUTED 3000d01c: e3520001 cmp r2, #1 <== NOT EXECUTED 3000d020: 1a00000e bne 3000d060 <_Thread_queue_Requeue+0x58> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d024: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000d028: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000d02c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3000d030: e59f302c ldr r3, [pc, #44] ; 3000d064 <_Thread_queue_Requeue+0x5c><== NOT EXECUTED 3000d034: e591c010 ldr ip, [r1, #16] <== NOT EXECUTED 3000d038: 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 ) ) {
3000d03c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d040: 0a000005 beq 3000d05c <_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;
3000d044: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
3000d048: eb000bff bl 3001004c <_Thread_queue_Extract_priority_helper><== NOT EXECUTED
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
3000d04c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d050: e1a01005 mov r1, r5 <== NOT EXECUTED 3000d054: e1a0200d mov r2, sp <== NOT EXECUTED 3000d058: ebffff58 bl 3000cdc0 <_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 (
3000d05c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
}
_ISR_Enable( level );
}
}
3000d060: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000d068 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000d068: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d06c: e1a0100d mov r1, sp <== NOT EXECUTED 3000d070: ebfffe06 bl 3000c890 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000d074: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000d078: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d07c: 1a000004 bne 3000d094 <_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 );
3000d080: eb000c26 bl 30010120 <_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;
3000d084: e59f300c ldr r3, [pc, #12] ; 3000d098 <_Thread_queue_Timeout+0x30><== NOT EXECUTED 3000d088: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000d08c: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000d090: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000d094: 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: eb0010d6 bl 3001d574 <_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: eb004efd bl 3002ce24 <__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: eb0010c9 bl 3001d574 <_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: 3b00109c blcc 3001d4d4 <_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: eb0002bd bl 30019d6c <_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: eb0010d9 bl 3001d608 <_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: eb000f89 bl 3001d16c <_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: eb000d55 bl 3001c8b0 <_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: eb0010fe bl 3001d764 <_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: eb0010fc bl 3001d764 <_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: eb00118c bl 3001d764 <_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: ea001129 b 3001d608 <_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: eb001178 bl 3001d764 <_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: ea001115 b 3001d608 <_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: eb001081 bl 3001d608 <_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: eb004e79 bl 3002ce24 <__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: eb00105f bl 3001d608 <_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: ea000d03 b 3001c8b0 <_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: ea000224 b 30019d40 <_Chain_Append> <== NOT EXECUTED
3000eaf8 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
3000eaf8: e1a03000 mov r3, r0 <== NOT EXECUTED
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000eafc: e5932000 ldr r2, [r3] <== NOT EXECUTED
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
uint32_t seconds = add->tv_sec;
3000eb00: e5910000 ldr r0, [r1] <== NOT EXECUTED
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000eb04: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000eb08: e0822000 add r2, r2, r0 <== NOT EXECUTED 3000eb0c: e5832000 str r2, [r3] <== NOT EXECUTED
time->tv_nsec += add->tv_nsec;
3000eb10: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED 3000eb14: e08c2002 add r2, ip, r2 <== NOT EXECUTED 3000eb18: e5832004 str r2, [r3, #4] <== NOT EXECUTED
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000eb1c: e59fc02c ldr ip, [pc, #44] ; 3000eb50 <_Timespec_Add_to+0x58><== NOT EXECUTED 3000eb20: ea000006 b 3000eb40 <_Timespec_Add_to+0x48> <== NOT EXECUTED
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000eb24: e59f2028 ldr r2, [pc, #40] ; 3000eb54 <_Timespec_Add_to+0x5c><== NOT EXECUTED
time->tv_sec++;
seconds++;
3000eb28: 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;
3000eb2c: e0812002 add r2, r1, r2 <== NOT EXECUTED 3000eb30: e5832004 str r2, [r3, #4] <== NOT EXECUTED
time->tv_sec++;
3000eb34: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000eb38: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000eb3c: 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 ) {
3000eb40: e5931004 ldr r1, [r3, #4] <== NOT EXECUTED 3000eb44: e151000c cmp r1, ip <== NOT EXECUTED 3000eb48: 8afffff5 bhi 3000eb24 <_Timespec_Add_to+0x2c> <== NOT EXECUTED
time->tv_sec++;
seconds++;
}
return seconds;
}
3000eb4c: e12fff1e bx lr <== NOT EXECUTED
3000cffc <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000cffc: 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;
3000d000: e5914000 ldr r4, [r1]
right += rhs->tv_nsec;
3000d004: e5911004 ldr r1, [r1, #4]
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000d008: e1a06002 mov r6, r2 3000d00c: 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;
3000d010: e1a02001 mov r2, r1 3000d014: e1a03fc1 asr r3, r1, #31 3000d018: e59f106c ldr r1, [pc, #108] ; 3000d08c <_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;
3000d01c: e590c000 ldr ip, [r0]
left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec;
3000d020: e0e32491 smlal r2, r3, r1, r4
if ( right == 0 ) {
3000d024: e1924003 orrs r4, r2, r3
*ival_percentage = 0;
3000d028: 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;
3000d02c: 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;
3000d030: 05863000 streq r3, [r6]
*fval_percentage = 0;
3000d034: 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 ) {
3000d038: 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;
3000d03c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000d040: e1a05fc0 asr r5, r0, #31 <== NOT EXECUTED 3000d044: 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;
3000d048: e59fc040 ldr ip, [pc, #64] ; 3000d090 <_Timespec_Divide+0x94><== NOT EXECUTED 3000d04c: e0810c94 umull r0, r1, r4, ip <== NOT EXECUTED 3000d050: e021159c mla r1, ip, r5, r1 <== NOT EXECUTED 3000d054: eb003b30 bl 3001bd1c <__udivdi3> <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000d058: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000d05c: 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;
3000d060: e1a05000 mov r5, r0 <== NOT EXECUTED 3000d064: e1a04001 mov r4, r1 <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000d068: eb003b2b bl 3001bd1c <__udivdi3> <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000d06c: e1a01004 mov r1, r4 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
3000d070: e5860000 str r0, [r6] <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000d074: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000d078: e1a00005 mov r0, r5 <== NOT EXECUTED
3000d07c: e3a03000 mov r3, #0 <== NOT EXECUTED
3000d080: eb003c49 bl 3001c1ac <__umoddi3> <== NOT EXECUTED
3000d084: e5870000 str r0, [r7] <== NOT EXECUTED
3000d088: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30027560 <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
30027560: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30027564: 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;
30027568: 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;
3002756c: e590c000 ldr ip, [r0] <== NOT EXECUTED
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
30027570: 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;
30027574: e1a00002 mov r0, r2 <== NOT EXECUTED 30027578: e1a01fc2 asr r1, r2, #31 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3002757c: e59f2040 ldr r2, [pc, #64] ; 300275c4 <_Timespec_Divide_by_integer+0x64><== NOT EXECUTED 30027580: e0e10c92 smlal r0, r1, r2, ip <== NOT EXECUTED 30027584: e1a02003 mov r2, r3 <== NOT EXECUTED 30027588: e3a03000 mov r3, #0 <== NOT EXECUTED 3002758c: eb00a345 bl 300502a8 <__udivdi3> <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
30027590: e59f202c ldr r2, [pc, #44] ; 300275c4 <_Timespec_Divide_by_integer+0x64><== NOT EXECUTED 30027594: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
30027598: e1a06000 mov r6, r0 <== NOT EXECUTED 3002759c: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
300275a0: eb00a340 bl 300502a8 <__udivdi3> <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
300275a4: e1a01005 mov r1, r5 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
300275a8: e5840000 str r0, [r4] <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
300275ac: e59f2010 ldr r2, [pc, #16] ; 300275c4 <_Timespec_Divide_by_integer+0x64><== NOT EXECUTED 300275b0: e1a00006 mov r0, r6 <== NOT EXECUTED 300275b4: e3a03000 mov r3, #0 <== NOT EXECUTED 300275b8: eb00a45e bl 30050738 <__umoddi3> <== NOT EXECUTED 300275bc: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
300275c0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300296f8 <_Timespec_From_ticks>:
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
300296f8: e59f3038 ldr r3, [pc, #56] ; 30029738 <_Timespec_From_ticks+0x40><== NOT EXECUTED
void _Timespec_From_ticks(
uint32_t ticks,
struct timespec *time
)
{
300296fc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30029700: e593500c ldr r5, [r3, #12] <== NOT EXECUTED
void _Timespec_From_ticks(
uint32_t ticks,
struct timespec *time
)
{
30029704: e1a04001 mov r4, r1 <== NOT EXECUTED
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30029708: e0050590 mul r5, r0, r5 <== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
3002970c: e59f1028 ldr r1, [pc, #40] ; 3002973c <_Timespec_From_ticks+0x44><== NOT EXECUTED 30029710: e1a00005 mov r0, r5 <== NOT EXECUTED 30029714: ebff6da8 bl 30004dbc <__aeabi_uidiv> <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
30029718: e59f101c ldr r1, [pc, #28] ; 3002973c <_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;
3002971c: e5840000 str r0, [r4] <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
30029720: e1a00005 mov r0, r5 <== NOT EXECUTED 30029724: ebfff742 bl 30027434 <__umodsi3> <== NOT EXECUTED 30029728: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED 3002972c: e0030390 mul r3, r0, r3 <== NOT EXECUTED 30029730: e5843004 str r3, [r4, #4] <== NOT EXECUTED
TOD_NANOSECONDS_PER_MICROSECOND;
}
30029734: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30029740 <_Timespec_Is_valid>:
bool _Timespec_Is_valid(
const struct timespec *time
)
{
if ( !time )
30029740: e3500000 cmp r0, #0 30029744: 012fff1e bxeq lr
return false;
if ( time->tv_sec < 0 )
30029748: e5903000 ldr r3, [r0] 3002974c: e3530000 cmp r3, #0
return false;
30029750: b3a00000 movlt r0, #0
)
{
if ( !time )
return false;
if ( time->tv_sec < 0 )
30029754: b12fff1e bxlt lr
return false;
if ( time->tv_nsec < 0 )
30029758: e5903004 ldr r3, [r0, #4] 3002975c: e3530000 cmp r3, #0
30029760: ba000004 blt 30029778 <_Timespec_Is_valid+0x38>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
30029764: e59f0014 ldr r0, [pc, #20] ; 30029780 <_Timespec_Is_valid+0x40> 30029768: e1530000 cmp r3, r0 3002976c: 83a00000 movhi r0, #0 30029770: 93a00001 movls r0, #1 30029774: e12fff1e bx lr
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
30029778: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
3002977c: e12fff1e bx lr <== NOT EXECUTED
300103c8 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
300103c8: e5902000 ldr r2, [r0] 300103cc: e5913000 ldr r3, [r1] 300103d0: e1520003 cmp r2, r3
return true;
300103d4: b3a00001 movlt r0, #1
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
300103d8: b12fff1e bxlt lr
return true;
if ( lhs->tv_sec > rhs->tv_sec )
300103dc: ca000005 bgt 300103f8 <_Timespec_Less_than+0x30>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Less_than(
300103e0: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED 300103e4: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 300103e8: e1500003 cmp r0, r3 <== NOT EXECUTED 300103ec: a3a00000 movge r0, #0 <== NOT EXECUTED 300103f0: b3a00001 movlt r0, #1 <== NOT EXECUTED 300103f4: e12fff1e bx lr <== NOT EXECUTED
{
if ( lhs->tv_sec < rhs->tv_sec )
return true;
if ( lhs->tv_sec > rhs->tv_sec )
return false;
300103f8: e3a00000 mov r0, #0
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
return true;
return false;
}
300103fc: e12fff1e bx lr
3000e824 <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
3000e824: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000e828: e1a04002 mov r4, r2 <== NOT EXECUTED
3000e82c: e1a05003 mov r5, r3 <== NOT EXECUTED
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
3000e830: e891000c ldm r1, {r2, r3} <== NOT EXECUTED
3000e834: e1921003 orrs r1, r2, r3 <== NOT EXECUTED
*_ival_percentage = 0;
3000e838: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000e83c: 05843000 streq r3, [r4] <== NOT EXECUTED
*_fval_percentage = 0;
3000e840: 05853000 streq r3, [r5] <== NOT EXECUTED
uint32_t *_fval_percentage
)
{
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
3000e844: 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;
3000e848: e59fc044 ldr ip, [pc, #68] ; 3000e894 <_Timestamp64_Divide+0x70><== NOT EXECUTED 3000e84c: e5906000 ldr r6, [r0] <== NOT EXECUTED 3000e850: e590e004 ldr lr, [r0, #4] <== NOT EXECUTED 3000e854: e0810c96 umull r0, r1, r6, ip <== NOT EXECUTED 3000e858: e0211e9c mla r1, ip, lr, r1 <== NOT EXECUTED 3000e85c: eb003ae4 bl 3001d3f4 <__divdi3> <== NOT EXECUTED
*_ival_percentage = answer / 1000;
3000e860: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000e864: 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;
3000e868: e1a07000 mov r7, r0 <== NOT EXECUTED 3000e86c: e1a06001 mov r6, r1 <== NOT EXECUTED
*_ival_percentage = answer / 1000;
3000e870: eb003adf bl 3001d3f4 <__divdi3> <== NOT EXECUTED
*_fval_percentage = answer % 1000;
3000e874: e1a01006 mov r1, r6 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
3000e878: e5840000 str r0, [r4] <== NOT EXECUTED
*_fval_percentage = answer % 1000;
3000e87c: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000e880: e1a00007 mov r0, r7 <== NOT EXECUTED
3000e884: e3a03000 mov r3, #0 <== NOT EXECUTED
3000e888: eb003c14 bl 3001d8e0 <__moddi3> <== NOT EXECUTED
3000e88c: e5850000 str r0, [r5] <== NOT EXECUTED
3000e890: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30010c80 <_User_extensions_Remove_set>:
#include <rtems/score/userextimpl.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
30010c80: e92d4010 push {r4, lr}
30010c84: e1a04000 mov r4, r0
_Chain_Extract( &the_extension->Node );
30010c88: eb0012c0 bl 30015790 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
30010c8c: e5943024 ldr r3, [r4, #36] ; 0x24
30010c90: e3530000 cmp r3, #0
30010c94: 08bd8010 popeq {r4, pc}
_Chain_Extract( &the_extension->Switch.Node );
30010c98: e2840008 add r0, r4, #8 <== NOT EXECUTED
}
30010c9c: 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 );
30010ca0: ea0012ba b 30015790 <_Chain_Extract> <== NOT EXECUTED
3000ead0 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
3000ead0: e92d40f0 push {r4, r5, r6, r7, lr}
3000ead4: e1a04000 mov r4, r0
3000ead8: e1a05002 mov r5, r2
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000eadc: e10f3000 mrs r3, CPSR 3000eae0: e3832080 orr r2, r3, #128 ; 0x80 3000eae4: 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;
3000eae8: e1a06000 mov r6, r0 3000eaec: 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 ) ) {
3000eaf0: e1520006 cmp r2, r6
3000eaf4: 0a00001b beq 3000eb68 <_Watchdog_Adjust+0x98>
switch ( direction ) {
3000eaf8: 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;
3000eafc: 03a07001 moveq r7, #1 <== NOT EXECUTED
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000eb00: 0a000016 beq 3000eb60 <_Watchdog_Adjust+0x90> <== NOT EXECUTED 3000eb04: e3510001 cmp r1, #1 <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
3000eb08: 05921010 ldreq r1, [r2, #16] <== NOT EXECUTED 3000eb0c: 00815005 addeq r5, r1, r5 <== NOT EXECUTED
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000eb10: 1a000014 bne 3000eb68 <_Watchdog_Adjust+0x98> <== NOT EXECUTED 3000eb14: ea000004 b 3000eb2c <_Watchdog_Adjust+0x5c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000eb18: 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 ) {
3000eb1c: e5921010 ldr r1, [r2, #16] <== NOT EXECUTED 3000eb20: e1550001 cmp r5, r1 <== NOT EXECUTED 3000eb24: 2a000002 bcs 3000eb34 <_Watchdog_Adjust+0x64> <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
3000eb28: e0655001 rsb r5, r5, r1 <== NOT EXECUTED 3000eb2c: e5825010 str r5, [r2, #16] <== NOT EXECUTED
break;
3000eb30: ea00000c b 3000eb68 <_Watchdog_Adjust+0x98> <== NOT EXECUTED
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000eb34: 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;
3000eb38: 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 (
3000eb3c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
_Watchdog_Tickle( header );
3000eb40: e1a00004 mov r0, r4 <== NOT EXECUTED 3000eb44: eb000089 bl 3000ed70 <_Watchdog_Tickle> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000eb48: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000eb4c: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000eb50: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000eb54: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000eb58: e1520006 cmp r2, r6 <== NOT EXECUTED 3000eb5c: 0a000001 beq 3000eb68 <_Watchdog_Adjust+0x98> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000eb60: e3550000 cmp r5, #0 <== NOT EXECUTED 3000eb64: 1affffeb bne 3000eb18 <_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 (
3000eb68: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000eb6c: e8bd80f0 pop {r4, r5, r6, r7, pc}
3001d574 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
3001d574: 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 (
3001d578: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3001d57c: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3001d580: 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;
3001d584: 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 );
3001d588: 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 );
3001d58c: 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;
3001d590: e5903000 ldr r3, [r0] <== NOT EXECUTED
Watchdog_Control *first;
_ISR_Disable( level );
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
3001d594: e1530005 cmp r3, r5 <== NOT EXECUTED 3001d598: 0a000018 beq 3001d600 <_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 ) {
3001d59c: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001d5a0: e151000c cmp r1, ip <== NOT EXECUTED
first->delta_interval -= units;
3001d5a4: 3061100c rsbcc r1, r1, ip <== NOT EXECUTED 3001d5a8: 35831010 strcc r1, [r3, #16] <== NOT EXECUTED
break;
3001d5ac: 3a000013 bcc 3001d600 <_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;
3001d5b0: e06c1001 rsb r1, ip, r1 <== NOT EXECUTED
first->delta_interval = 0;
3001d5b4: e5838010 str r8, [r3, #16] <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3001d5b8: e8931040 ldm r3, {r6, ip} <== NOT EXECUTED
next->previous = previous;
3001d5bc: e586c004 str ip, [r6, #4] <== NOT EXECUTED
previous->next = next;
3001d5c0: 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;
3001d5c4: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
the_node->next = tail;
3001d5c8: e5837000 str r7, [r3] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
3001d5cc: 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;
3001d5d0: e5823008 str r3, [r2, #8] <== NOT EXECUTED
old_last->next = the_node; the_node->previous = old_last;
3001d5d4: 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 (
3001d5d8: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001d5dc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3001d5e0: 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;
3001d5e4: 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 ) )
3001d5e8: e1530005 cmp r3, r5 <== NOT EXECUTED 3001d5ec: 0affffe7 beq 3001d590 <_Watchdog_Adjust_to_chain+0x1c> <== NOT EXECUTED
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
3001d5f0: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001d5f4: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001d5f8: 0affffee beq 3001d5b8 <_Watchdog_Adjust_to_chain+0x44> <== NOT EXECUTED 3001d5fc: eaffffe3 b 3001d590 <_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 (
3001d600: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001d604: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000e614 <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000e614: e92d401f push {r0, r1, r2, r3, r4, lr} <== NOT EXECUTED
3000e618: e1a03001 mov r3, r1 <== NOT EXECUTED
printk(
3000e61c: e2501000 subs r1, r0, #0 <== NOT EXECUTED
3000e620: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
3000e624: 059f1034 ldreq r1, [pc, #52] ; 3000e660 <_Watchdog_Report+0x4c><== NOT EXECUTED
3000e628: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED
3000e62c: e593001c ldr r0, [r3, #28] <== NOT EXECUTED
3000e630: 01a02001 moveq r2, r1 <== NOT EXECUTED
3000e634: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
3000e638: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
3000e63c: 159f2020 ldrne r2, [pc, #32] ; 3000e664 <_Watchdog_Report+0x50><== NOT EXECUTED
3000e640: e58d000c str r0, [sp, #12] <== NOT EXECUTED
3000e644: e5930024 ldr r0, [r3, #36] ; 0x24 <== NOT EXECUTED
3000e648: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
3000e64c: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
3000e650: e59f0010 ldr r0, [pc, #16] ; 3000e668 <_Watchdog_Report+0x54><== NOT EXECUTED
3000e654: ebffe544 bl 30007b6c <printk> <== NOT EXECUTED
watch,
watch->routine,
watch->id,
watch->user_data
);
}
3000e658: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000e65c: e8bd8000 pop {pc} <== NOT EXECUTED
3000e598 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
3000e598: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000e59c: e1a04000 mov r4, r0 <== NOT EXECUTED
3000e5a0: e1a05001 mov r5, r1 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000e5a4: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000e5a8: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000e5ac: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
3000e5b0: e59f0050 ldr r0, [pc, #80] ; 3000e608 <_Watchdog_Report_chain+0x70><== NOT EXECUTED 3000e5b4: e1a02005 mov r2, r5 <== NOT EXECUTED 3000e5b8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e5bc: ebffe56a 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;
3000e5c0: e4957004 ldr r7, [r5], #4 <== NOT EXECUTED
if ( !_Chain_Is_empty( header ) ) {
3000e5c4: e1570005 cmp r7, r5 <== NOT EXECUTED 3000e5c8: 1a000004 bne 3000e5e0 <_Watchdog_Report_chain+0x48> <== NOT EXECUTED 3000e5cc: ea000009 b 3000e5f8 <_Watchdog_Report_chain+0x60> <== NOT EXECUTED
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
3000e5d0: e1a01007 mov r1, r7 <== NOT EXECUTED 3000e5d4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e5d8: eb00000d bl 3000e614 <_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 )
3000e5dc: 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 ) ;
3000e5e0: e1570005 cmp r7, r5 <== NOT EXECUTED 3000e5e4: 1afffff9 bne 3000e5d0 <_Watchdog_Report_chain+0x38> <== NOT EXECUTED
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
3000e5e8: e59f001c ldr r0, [pc, #28] ; 3000e60c <_Watchdog_Report_chain+0x74><== NOT EXECUTED 3000e5ec: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e5f0: ebffe55d bl 30007b6c <printk> <== NOT EXECUTED 3000e5f4: ea000001 b 3000e600 <_Watchdog_Report_chain+0x68> <== NOT EXECUTED
} else {
printk( "Chain is empty\n" );
3000e5f8: e59f0010 ldr r0, [pc, #16] ; 3000e610 <_Watchdog_Report_chain+0x78><== NOT EXECUTED 3000e5fc: ebffe55a 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 (
3000e600: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
}
_ISR_Enable( level );
}
3000e604: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000d620 <_Watchdog_Tickle>:
#include <rtems/score/watchdog.h>
void _Watchdog_Tickle(
Chain_Control *header
)
{
3000d620: e92d40f0 push {r4, r5, r6, r7, lr}
3000d624: e1a06000 mov r6, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d628: e10f7000 mrs r7, CPSR 3000d62c: e3873080 orr r3, r7, #128 ; 0x80 3000d630: 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;
3000d634: e1a05000 mov r5, r0 3000d638: e4954004 ldr r4, [r5], #4
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000d63c: e1540005 cmp r4, r5
3000d640: 0a000015 beq 3000d69c <_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) {
3000d644: e5943010 ldr r3, [r4, #16] 3000d648: e3530000 cmp r3, #0
3000d64c: 0a000003 beq 3000d660 <_Watchdog_Tickle+0x40>
the_watchdog->delta_interval--;
3000d650: e2433001 sub r3, r3, #1 3000d654: e5843010 str r3, [r4, #16]
if ( the_watchdog->delta_interval != 0 )
3000d658: e3530000 cmp r3, #0
3000d65c: 1a00000e bne 3000d69c <_Watchdog_Tickle+0x7c>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
3000d660: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d664: ebffffc4 bl 3000d57c <_Watchdog_Remove> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d668: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
switch( watchdog_state ) {
3000d66c: e3500002 cmp r0, #2 <== NOT EXECUTED
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
3000d670: 05940020 ldreq r0, [r4, #32] <== NOT EXECUTED 3000d674: 05941024 ldreq r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000d678: 01a0e00f moveq lr, pc <== NOT EXECUTED 3000d67c: 0594f01c ldreq pc, [r4, #28] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d680: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000d684: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3000d688: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000d68c: e5964000 ldr r4, [r6] <== NOT EXECUTED
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
3000d690: e1540005 cmp r4, r5 <== NOT EXECUTED
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
3000d694: 15943010 ldrne r3, [r4, #16] <== NOT EXECUTED 3000d698: 1affffee bne 3000d658 <_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 (
3000d69c: e129f007 msr CPSR_fc, r7
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000d6a0: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000d7cc <_Workspace_Allocate_or_fatal_error>:
3000d7cc: e3a02000 mov r2, #0
}
void *_Workspace_Allocate_or_fatal_error(
size_t size
)
{
3000d7d0: e1a01000 mov r1, r0
3000d7d4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3000d7d8: e59f0018 ldr r0, [pc, #24] ; 3000d7f8 <_Workspace_Allocate_or_fatal_error+0x2c>
3000d7dc: e1a03002 mov r3, r2
3000d7e0: eb00085c bl 3000f958 <_Heap_Allocate_aligned_with_boundary>
__builtin_return_address( 1 ),
memory
);
#endif
if ( memory == NULL )
3000d7e4: e3500000 cmp r0, #0
3000d7e8: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
_Internal_error_Occurred(
3000d7ec: e3a01001 mov r1, #1 <== NOT EXECUTED 3000d7f0: e3a02003 mov r2, #3 <== NOT EXECUTED 3000d7f4: ebfff74e bl 3000b534 <_Internal_error_Occurred> <== NOT EXECUTED
3001d870 <_execve>:
int _execve(
const char *path __attribute__((unused)),
char *const argv[] __attribute__((unused)),
char *const envp[] __attribute__((unused))
)
{
3001d870: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3001d874: ebffd1e4 bl 3001200c <__errno> <== NOT EXECUTED 3001d878: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3001d87c: e5803000 str r3, [r0] <== NOT EXECUTED
}
3001d880: e3e00000 mvn r0, #0 <== NOT EXECUTED
3001d884: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3001cba8 <_kill_r>:
struct _reent *ptr,
pid_t pid,
int sig
)
{
return killinfo( pid, sig, NULL );
3001cba8: e1a00001 mov r0, r1 <== NOT EXECUTED 3001cbac: e1a01002 mov r1, r2 <== NOT EXECUTED 3001cbb0: e3a02000 mov r2, #0 <== NOT EXECUTED 3001cbb4: ea000022 b 3001cc44 <killinfo> <== NOT EXECUTED
3000a120 <adjtime>:
*/
int adjtime(
const struct timeval *delta,
struct timeval *olddelta
)
{
3000a120: e92d4373 push {r0, r1, r4, r5, r6, r8, r9, lr} <== NOT EXECUTED
long adjustment;
/*
* Simple validations
*/
if ( !delta )
3000a124: e2505000 subs r5, r0, #0 <== NOT EXECUTED
*/
int adjtime(
const struct timeval *delta,
struct timeval *olddelta
)
{
3000a128: e1a06001 mov r6, r1 <== NOT EXECUTED
long adjustment;
/*
* Simple validations
*/
if ( !delta )
3000a12c: 0a000003 beq 3000a140 <adjtime+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
3000a130: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED 3000a134: e59f3128 ldr r3, [pc, #296] ; 3000a264 <adjtime+0x144> <== NOT EXECUTED 3000a138: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a13c: 9a000004 bls 3000a154 <adjtime+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a140: eb0020b4 bl 30012418 <__errno> <== NOT EXECUTED 3000a144: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a148: e5803000 str r3, [r0] <== NOT EXECUTED 3000a14c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000a150: ea000042 b 3000a260 <adjtime+0x140> <== NOT EXECUTED
if ( olddelta ) {
3000a154: e3510000 cmp r1, #0 <== NOT EXECUTED
olddelta->tv_sec = 0;
3000a158: 13a03000 movne r3, #0 <== NOT EXECUTED 3000a15c: 15813000 strne r3, [r1] <== NOT EXECUTED
olddelta->tv_usec = 0;
3000a160: 15813004 strne r3, [r1, #4] <== NOT EXECUTED
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
adjustment += delta->tv_usec;
3000a164: e59f10fc ldr r1, [pc, #252] ; 3000a268 <adjtime+0x148> <== NOT EXECUTED
3000a168: e895000c ldm r5, {r2, r3} <== NOT EXECUTED
3000a16c: e0223291 mla r2, r1, r2, r3 <== NOT EXECUTED
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
3000a170: e59f30f4 ldr r3, [pc, #244] ; 3000a26c <adjtime+0x14c> <== NOT EXECUTED 3000a174: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 3000a178: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a17c: 3a000036 bcc 3000a25c <adjtime+0x13c> <== 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;
3000a180: e59f30e8 ldr r3, [pc, #232] ; 3000a270 <adjtime+0x150> <== NOT EXECUTED 3000a184: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3000a188: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000a18c: e5832000 str r2, [r3] <== NOT EXECUTED
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
3000a190: e59f10dc ldr r1, [pc, #220] ; 3000a274 <adjtime+0x154> <== NOT EXECUTED 3000a194: e1a0000d mov r0, sp <== NOT EXECUTED 3000a198: eb0005fe bl 3000b998 <_TOD_Get_with_nanoseconds> <== NOT EXECUTED
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a19c: e59f20d4 ldr r2, [pc, #212] ; 3000a278 <adjtime+0x158> <== NOT EXECUTED
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
3000a1a0: e8900300 ldm r0, {r8, r9} <== NOT EXECUTED
3000a1a4: e3a03000 mov r3, #0 <== NOT EXECUTED
3000a1a8: e1a00008 mov r0, r8 <== NOT EXECUTED
3000a1ac: e1a01009 mov r1, r9 <== NOT EXECUTED
3000a1b0: eb004fbb bl 3001e0a4 <__moddi3> <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
3000a1b4: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 3000a1b8: e3a04ffa mov r4, #1000 ; 0x3e8 <== NOT EXECUTED 3000a1bc: e0240493 mla r4, r3, r4, r0 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
3000a1c0: e59f20b0 ldr r2, [pc, #176] ; 3000a278 <adjtime+0x158> <== NOT EXECUTED 3000a1c4: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a1c8: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a1cc: e1a01009 mov r1, r9 <== NOT EXECUTED 3000a1d0: eb004e78 bl 3001dbb8 <__divdi3> <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
3000a1d4: e5953000 ldr r3, [r5] <== NOT EXECUTED
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000a1d8: e59f209c ldr r2, [pc, #156] ; 3000a27c <adjtime+0x15c> <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
3000a1dc: e0830000 add r0, r3, r0 <== NOT EXECUTED
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000a1e0: ea000002 b 3000a1f0 <adjtime+0xd0> <== NOT EXECUTED
int _EXFUN(setitimer, (int __which, const struct itimerval *__value,
struct itimerval *__ovalue));
#if defined(__rtems__)
/* BSD function used by RTEMS code */
int _EXFUN(adjtime,(const struct timeval *, struct timeval *));
3000a1e4: e2844331 add r4, r4, #-1006632960 ; 0xc4000000 <== NOT EXECUTED 3000a1e8: e2844865 add r4, r4, #6619136 ; 0x650000 <== NOT EXECUTED 3000a1ec: e2844c36 add r4, r4, #13824 ; 0x3600 <== NOT EXECUTED 3000a1f0: e1540002 cmp r4, r2 <== NOT EXECUTED 3000a1f4: e1a03000 mov r3, r0 <== NOT EXECUTED 3000a1f8: e2800001 add r0, r0, #1 <== NOT EXECUTED 3000a1fc: 8afffff8 bhi 3000a1e4 <adjtime+0xc4> <== NOT EXECUTED
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
3000a200: e59f2078 ldr r2, [pc, #120] ; 3000a280 <adjtime+0x160> <== NOT EXECUTED 3000a204: ea000002 b 3000a214 <adjtime+0xf4> <== NOT EXECUTED 3000a208: e28445ee add r4, r4, #998244352 ; 0x3b800000 <== NOT EXECUTED 3000a20c: e284496b add r4, r4, #1753088 ; 0x1ac000 <== NOT EXECUTED 3000a210: e2844c0a add r4, r4, #2560 ; 0xa00 <== NOT EXECUTED 3000a214: e1540002 cmp r4, r2 <== NOT EXECUTED 3000a218: e1a00003 mov r0, r3 <== NOT EXECUTED 3000a21c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000a220: 9afffff8 bls 3000a208 <adjtime+0xe8> <== NOT EXECUTED
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
3000a224: e59f104c ldr r1, [pc, #76] ; 3000a278 <adjtime+0x158> <== NOT EXECUTED
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
3000a228: e1a02004 mov r2, r4 <== NOT EXECUTED
3000a22c: e1a03fc4 asr r3, r4, #31 <== NOT EXECUTED
3000a230: e0e32091 smlal r2, r3, r1, r0 <== NOT EXECUTED
3000a234: e28d0008 add r0, sp, #8 <== NOT EXECUTED
3000a238: e920000c stmdb r0!, {r2, r3} <== NOT EXECUTED
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
3000a23c: e1a0000d mov r0, sp <== NOT EXECUTED 3000a240: eb0005f3 bl 3000ba14 <_TOD_Set_with_timestamp> <== NOT EXECUTED
ts.tv_sec--;
}
_TOD_Set( &ts );
_Thread_Enable_dispatch();
3000a244: eb000be6 bl 3000d1e4 <_Thread_Enable_dispatch> <== NOT EXECUTED
/* set the user's output */
if ( olddelta )
3000a248: e3560000 cmp r6, #0 <== NOT EXECUTED
*olddelta = *delta;
return 0;
3000a24c: 01a00006 moveq r0, r6 <== NOT EXECUTED
_TOD_Set( &ts );
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
3000a250: 0a000002 beq 3000a260 <adjtime+0x140> <== NOT EXECUTED
*olddelta = *delta;
3000a254: e895000c ldm r5, {r2, r3} <== NOT EXECUTED
3000a258: e886000c stm r6, {r2, r3} <== NOT EXECUTED
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
return 0;
3000a25c: e3a00000 mov r0, #0 <== NOT EXECUTED
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
3000a260: e8bd837c pop {r2, r3, r4, r5, r6, r8, r9, pc} <== NOT EXECUTED
3000a348 <aio_cancel>:
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
3000a348: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
3000a34c: e59f4198 ldr r4, [pc, #408] ; 3000a4ec <aio_cancel+0x1a4> <== NOT EXECUTED
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
3000a350: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
3000a354: e1a00004 mov r0, r4 <== NOT EXECUTED
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
3000a358: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
3000a35c: eb000415 bl 3000b3b8 <pthread_mutex_lock> <== NOT EXECUTED
if (fcntl (fildes, F_GETFD) < 0) {
3000a360: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a364: e3a01001 mov r1, #1 <== NOT EXECUTED 3000a368: eb00192a bl 30010818 <fcntl> <== NOT EXECUTED 3000a36c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a370: aa000004 bge 3000a388 <aio_cancel+0x40> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
3000a374: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a378: eb00042d bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EBADF);
3000a37c: eb0025e8 bl 30013b24 <__errno> <== NOT EXECUTED 3000a380: e3a03009 mov r3, #9 <== NOT EXECUTED 3000a384: ea00002f b 3000a448 <aio_cancel+0x100> <== NOT EXECUTED
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
3000a388: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a38c: 1a000026 bne 3000a42c <aio_cancel+0xe4> <== NOT EXECUTED
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
3000a390: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000a394: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a398: e1a02005 mov r2, r5 <== NOT EXECUTED 3000a39c: eb000152 bl 3000a8ec <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000a3a0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000a3a4: 1a000017 bne 3000a408 <aio_cancel+0xc0> <== NOT EXECUTED
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
3000a3a8: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 3000a3ac: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 3000a3b0: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a3b4: 0a00003b beq 3000a4a8 <aio_cancel+0x160> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
3000a3b8: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 3000a3bc: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a3c0: e1a02006 mov r2, r6 <== NOT EXECUTED 3000a3c4: eb000148 bl 3000a8ec <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000a3c8: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000a3cc: 0a000035 beq 3000a4a8 <aio_cancel+0x160> <== NOT EXECUTED
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
3000a3d0: e285701c add r7, r5, #28 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000a3d4: eb000a44 bl 3000ccec <_Chain_Extract> <== NOT EXECUTED
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
3000a3d8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a3dc: eb00016d bl 3000a998 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
3000a3e0: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a3e4: eb000356 bl 3000b144 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
3000a3e8: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a3ec: eb000289 bl 3000ae18 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
3000a3f0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a3f4: ebfff1c8 bl 30006b1c <free> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a3f8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a3fc: eb00040c bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
3000a400: e1a05006 mov r5, r6 <== NOT EXECUTED 3000a404: ea000036 b 3000a4e4 <aio_cancel+0x19c> <== NOT EXECUTED
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
3000a408: e286701c add r7, r6, #28 <== NOT EXECUTED 3000a40c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a410: eb0003e8 bl 3000b3b8 <pthread_mutex_lock> <== NOT EXECUTED 3000a414: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a418: eb000a33 bl 3000ccec <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
3000a41c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a420: eb00015c bl 3000a998 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000a424: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a428: ea00002a b 3000a4d8 <aio_cancel+0x190> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
3000a42c: e5956000 ldr r6, [r5] <== NOT EXECUTED 3000a430: e1560007 cmp r6, r7 <== NOT EXECUTED 3000a434: 0a000006 beq 3000a454 <aio_cancel+0x10c> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a438: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a43c: eb0003fc bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EINVAL);
3000a440: eb0025b7 bl 30013b24 <__errno> <== NOT EXECUTED 3000a444: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a448: e5803000 str r3, [r0] <== NOT EXECUTED 3000a44c: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000a450: ea000023 b 3000a4e4 <aio_cancel+0x19c> <== NOT EXECUTED
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
3000a454: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000a458: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a45c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a460: eb000121 bl 3000a8ec <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000a464: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000a468: 1a000012 bne 3000a4b8 <aio_cancel+0x170> <== NOT EXECUTED
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
3000a46c: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 3000a470: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 3000a474: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a478: 0a00000a beq 3000a4a8 <aio_cancel+0x160> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
3000a47c: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 3000a480: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a484: e1a02007 mov r2, r7 <== NOT EXECUTED 3000a488: eb000117 bl 3000a8ec <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000a48c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a490: 0affffe8 beq 3000a438 <aio_cancel+0xf0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
3000a494: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a498: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000a49c: eb00014f bl 3000a9e0 <rtems_aio_remove_req> <== NOT EXECUTED 3000a4a0: e1a05000 mov r5, r0 <== NOT EXECUTED 3000a4a4: ea00000c b 3000a4dc <aio_cancel+0x194> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a4a8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a4ac: eb0003e0 bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
3000a4b0: e3a05002 mov r5, #2 <== NOT EXECUTED 3000a4b4: ea00000a b 3000a4e4 <aio_cancel+0x19c> <== NOT EXECUTED
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
3000a4b8: e287801c add r8, r7, #28 <== NOT EXECUTED 3000a4bc: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a4c0: eb0003bc bl 3000b3b8 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
3000a4c4: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a4c8: e2870008 add r0, r7, #8 <== NOT EXECUTED 3000a4cc: eb000143 bl 3000a9e0 <rtems_aio_remove_req> <== NOT EXECUTED 3000a4d0: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000a4d4: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a4d8: eb0003d5 bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a4dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a4e0: eb0003d3 bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
3000a4e4: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a4e8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000a4f0 <aio_error>:
int
aio_error (const struct aiocb *aiocbp)
{
return aiocbp->error_code;
}
3000a4f0: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED 3000a4f4: e12fff1e bx lr <== NOT EXECUTED
3000a4f8 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
3000a4f8: e3500a02 cmp r0, #8192 ; 0x2000 <== NOT EXECUTED
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
3000a4fc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000a500: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
3000a504: 13a05016 movne r5, #22 <== NOT EXECUTED
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
3000a508: 1a00000c bne 3000a540 <aio_fsync+0x48> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000a50c: e5910000 ldr r0, [r1] <== NOT EXECUTED 3000a510: e3a01003 mov r1, #3 <== NOT EXECUTED 3000a514: eb0018bf bl 30010818 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000a518: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000a51c: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000a520: e3500001 cmp r0, #1 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000a524: 83a05009 movhi r5, #9 <== NOT EXECUTED
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000a528: 8a000004 bhi 3000a540 <aio_fsync+0x48> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
3000a52c: e3a00018 mov r0, #24 <== NOT EXECUTED 3000a530: ebfff289 bl 30006f5c <malloc> <== NOT EXECUTED
if (req == NULL)
3000a534: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000a538: 1a000007 bne 3000a55c <aio_fsync+0x64> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000a53c: e3a0500b mov r5, #11 <== NOT EXECUTED 3000a540: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000a544: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000a548: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000a54c: eb002574 bl 30013b24 <__errno> <== NOT EXECUTED 3000a550: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
3000a554: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a558: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000a55c: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
3000a560: e3a03003 mov r3, #3 <== NOT EXECUTED 3000a564: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000a568: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
3000a56c: ea000135 b 3000aa48 <rtems_aio_enqueue> <== NOT EXECUTED
3000ac48 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
3000ac48: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000ac4c: e3a01003 mov r1, #3 <== NOT EXECUTED
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
3000ac50: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000ac54: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000ac58: eb0016ee bl 30010818 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000ac5c: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000ac60: e3500002 cmp r0, #2 <== NOT EXECUTED 3000ac64: 13500000 cmpne r0, #0 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000ac68: 13a05009 movne r5, #9 <== NOT EXECUTED
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000ac6c: 1a00000d bne 3000aca8 <aio_read+0x60> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
3000ac70: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000ac74: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ac78: 1a000003 bne 3000ac8c <aio_read+0x44> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
3000ac7c: e994000c ldmib r4, {r2, r3} <== NOT EXECUTED
3000ac80: e3520000 cmp r2, #0 <== NOT EXECUTED
3000ac84: e2d31000 sbcs r1, r3, #0 <== NOT EXECUTED
3000ac88: aa000001 bge 3000ac94 <aio_read+0x4c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
3000ac8c: e3a05016 mov r5, #22 <== NOT EXECUTED 3000ac90: ea000004 b 3000aca8 <aio_read+0x60> <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
3000ac94: e3a00018 mov r0, #24 <== NOT EXECUTED 3000ac98: ebfff0af bl 30006f5c <malloc> <== NOT EXECUTED
if (req == NULL)
3000ac9c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000aca0: 1a000007 bne 3000acc4 <aio_read+0x7c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000aca4: e3a0500b mov r5, #11 <== NOT EXECUTED 3000aca8: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000acac: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000acb0: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000acb4: eb00239a bl 30013b24 <__errno> <== NOT EXECUTED 3000acb8: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
3000acbc: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000acc0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000acc4: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_READ;
3000acc8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000accc: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000acd0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
3000acd4: eaffff5b b 3000aa48 <rtems_aio_enqueue> <== NOT EXECUTED
3000acd8 <aio_return>:
ssize_t
aio_return (const struct aiocb *aiocbp)
{
return aiocbp->return_value;
}
3000acd8: e5900034 ldr r0, [r0, #52] ; 0x34 <== NOT EXECUTED 3000acdc: e12fff1e bx lr <== NOT EXECUTED
30009d98 <aio_suspend>:
int aio_suspend(
const struct aiocb * const list[] __attribute__((unused)),
int nent __attribute__((unused)),
const struct timespec *timeout __attribute__((unused))
)
{
30009d98: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009d9c: eb00209a bl 3001200c <__errno> <== NOT EXECUTED 30009da0: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009da4: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009da8: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009dac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ace0 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
3000ace0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000ace4: e3a01003 mov r1, #3 <== NOT EXECUTED
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
3000ace8: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000acec: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000acf0: eb0016c8 bl 30010818 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000acf4: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000acf8: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000acfc: e3500001 cmp r0, #1 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000ad00: 83a05009 movhi r5, #9 <== NOT EXECUTED
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000ad04: 8a00000d bhi 3000ad40 <aio_write+0x60> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
3000ad08: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000ad0c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ad10: 1a000003 bne 3000ad24 <aio_write+0x44> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
3000ad14: e994000c ldmib r4, {r2, r3} <== NOT EXECUTED
3000ad18: e3520000 cmp r2, #0 <== NOT EXECUTED
3000ad1c: e2d31000 sbcs r1, r3, #0 <== NOT EXECUTED
3000ad20: aa000001 bge 3000ad2c <aio_write+0x4c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
3000ad24: e3a05016 mov r5, #22 <== NOT EXECUTED 3000ad28: ea000004 b 3000ad40 <aio_write+0x60> <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
3000ad2c: e3a00018 mov r0, #24 <== NOT EXECUTED 3000ad30: ebfff089 bl 30006f5c <malloc> <== NOT EXECUTED
if (req == NULL)
3000ad34: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000ad38: 1a000007 bne 3000ad5c <aio_write+0x7c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000ad3c: e3a0500b mov r5, #11 <== NOT EXECUTED 3000ad40: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000ad44: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000ad48: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000ad4c: eb002374 bl 30013b24 <__errno> <== NOT EXECUTED 3000ad50: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
3000ad54: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000ad58: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000ad5c: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_WRITE;
3000ad60: e3a03002 mov r3, #2 <== NOT EXECUTED 3000ad64: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000ad68: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
3000ad6c: eaffff35 b 3000aa48 <rtems_aio_enqueue> <== NOT EXECUTED
3000bc04 <alarm>:
}
unsigned int alarm(
unsigned int seconds
)
{
3000bc04: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000bc08: e59f607c ldr r6, [pc, #124] ; 3000bc8c <alarm+0x88> <== NOT EXECUTED
}
unsigned int alarm(
unsigned int seconds
)
{
3000bc0c: e1a05000 mov r5, r0 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000bc10: e596401c ldr r4, [r6, #28] <== NOT EXECUTED 3000bc14: e3540000 cmp r4, #0 <== NOT EXECUTED 3000bc18: 1a000005 bne 3000bc34 <alarm+0x30> <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000bc1c: e59f306c ldr r3, [pc, #108] ; 3000bc90 <alarm+0x8c> <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000bc20: e5864008 str r4, [r6, #8] <== NOT EXECUTED
the_watchdog->routine = routine;
3000bc24: e586301c str r3, [r6, #28] <== NOT EXECUTED
the_watchdog->id = id;
3000bc28: e5864020 str r4, [r6, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000bc2c: e5864024 str r4, [r6, #36] ; 0x24 <== NOT EXECUTED 3000bc30: ea00000e b 3000bc70 <alarm+0x6c> <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
3000bc34: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bc38: eb0012ca bl 30010768 <_Watchdog_Remove> <== NOT EXECUTED
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
3000bc3c: e2400002 sub r0, r0, #2 <== NOT EXECUTED 3000bc40: e3500001 cmp r0, #1 <== NOT EXECUTED
unsigned int alarm(
unsigned int seconds
)
{
unsigned int remaining = 0;
3000bc44: 83a04000 movhi r4, #0 <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
3000bc48: 8a000008 bhi 3000bc70 <alarm+0x6c> <== NOT EXECUTED
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
remaining = the_timer->initial -
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
3000bc4c: e5962018 ldr r2, [r6, #24] <== NOT EXECUTED 3000bc50: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
* The stop_time and start_time fields are snapshots of ticks since
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
remaining = the_timer->initial -
3000bc54: e596400c ldr r4, [r6, #12] <== NOT EXECUTED
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
3000bc58: e0636002 rsb r6, r3, r2 <== NOT EXECUTED 3000bc5c: eb000971 bl 3000e228 <TOD_TICKS_PER_SECOND_method> <== NOT EXECUTED 3000bc60: e1a01000 mov r1, r0 <== NOT EXECUTED 3000bc64: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bc68: eb004b7f bl 3001ea6c <__aeabi_uidiv> <== NOT EXECUTED
* The stop_time and start_time fields are snapshots of ticks since
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
remaining = the_timer->initial -
3000bc6c: e0604004 rsb r4, r0, r4 <== NOT EXECUTED
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
}
}
if ( seconds )
3000bc70: e3550000 cmp r5, #0 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000bc74: 159f1010 ldrne r1, [pc, #16] ; 3000bc8c <alarm+0x88> <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000bc78: 159f0014 ldrne r0, [pc, #20] ; 3000bc94 <alarm+0x90> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000bc7c: 1581500c strne r5, [r1, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000bc80: 1b001261 blne 3001060c <_Watchdog_Insert> <== NOT EXECUTED
_Watchdog_Insert_seconds( the_timer, seconds );
return remaining;
}
3000bc84: e1a00004 mov r0, r4 <== NOT EXECUTED
3000bc88: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000b164 <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) {
3000b164: 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(
3000b168: 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) {
3000b16c: e5934018 ldr r4, [r3, #24] <== NOT EXECUTED 3000b170: e154000c cmp r4, ip <== NOT EXECUTED 3000b174: 31a0c002 movcc ip, r2 <== NOT EXECUTED 3000b178: 31a02003 movcc r2, r3 <== NOT EXECUTED 3000b17c: 31a0300c movcc r3, ip <== NOT EXECUTED
a = b;
b = t;
}
a->size += b->size;
3000b180: e592401c ldr r4, [r2, #28] <== NOT EXECUTED 3000b184: e593c01c ldr ip, [r3, #28] <== NOT EXECUTED 3000b188: e084c00c add ip, r4, ip <== NOT EXECUTED 3000b18c: e582c01c str ip, [r2, #28] <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000b190: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3000b194: e593c000 ldr ip, [r3] <== NOT EXECUTED
previous = the_node->previous; next->previous = previous; previous->next = next;
3000b198: e582c000 str ip, [r2] <== NOT EXECUTED
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
3000b19c: e58c2004 str r2, [ip, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b1a0: e5902000 ldr r2, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b1a4: e5830004 str r0, [r3, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b1a8: 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);
3000b1ac: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b1b0: e2831008 add r1, r3, #8 <== NOT EXECUTED
the_node->next = before_node;
3000b1b4: e5832000 str r2, [r3] <== NOT EXECUTED
before_node->previous = the_node;
3000b1b8: e5823004 str r3, [r2, #4] <== NOT EXECUTED
} }
3000b1bc: 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);
3000b1c0: ea000664 b 3000cb58 <_RBTree_Extract_unprotected> <== NOT EXECUTED
3000b154 <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);
3000b154: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 3000b158: e5910010 ldr r0, [r1, #16] <== NOT EXECUTED
}
3000b15c: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 3000b160: e12fff1e bx lr <== NOT EXECUTED
30009db0 <clock_getcpuclockid>:
int clock_getcpuclockid(
pid_t pid,
clockid_t *clock_id
)
{
30009db0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009db4: eb002094 bl 3001200c <__errno> <== NOT EXECUTED 30009db8: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009dbc: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009dc0: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009dc4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009dc8 <clock_getenable_attr>:
int clock_getenable_attr(
clockid_t clock_id,
int *attr
)
{
30009dc8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009dcc: eb00208e bl 3001200c <__errno> <== NOT EXECUTED 30009dd0: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009dd4: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009dd8: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009ddc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a5bc <clock_getres>:
int clock_getres(
clockid_t clock_id,
struct timespec *res
)
{
3000a5bc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !res )
3000a5c0: e2514000 subs r4, r1, #0 <== NOT EXECUTED 3000a5c4: 1a000004 bne 3000a5dc <clock_getres+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a5c8: eb002097 bl 3001282c <__errno> <== NOT EXECUTED
3000a5cc: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a5d0: e5803000 str r3, [r0] <== NOT EXECUTED
3000a5d4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a5d8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
switch ( clock_id ) {
3000a5dc: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000a5e0: e3500002 cmp r0, #2 <== NOT EXECUTED 3000a5e4: 8a000008 bhi 3000a60c <clock_getres+0x50> <== NOT EXECUTED
case CLOCK_REALTIME:
case CLOCK_PROCESS_CPUTIME_ID:
case CLOCK_THREAD_CPUTIME_ID:
if ( res ) {
res->tv_sec = rtems_configuration_get_microseconds_per_tick() /
3000a5e8: e59f5030 ldr r5, [pc, #48] ; 3000a620 <clock_getres+0x64> <== NOT EXECUTED 3000a5ec: e59f1030 ldr r1, [pc, #48] ; 3000a624 <clock_getres+0x68> <== NOT EXECUTED 3000a5f0: e595000c ldr r0, [r5, #12] <== NOT EXECUTED 3000a5f4: eb004d8f bl 3001dc38 <__aeabi_uidiv> <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND;
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
3000a5f8: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
case CLOCK_REALTIME:
case CLOCK_PROCESS_CPUTIME_ID:
case CLOCK_THREAD_CPUTIME_ID:
if ( res ) {
res->tv_sec = rtems_configuration_get_microseconds_per_tick() /
3000a5fc: e5840000 str r0, [r4] <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND;
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
3000a600: e5843004 str r3, [r4, #4] <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return 0;
3000a604: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a608: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
}
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000a60c: eb002086 bl 3001282c <__errno> <== NOT EXECUTED 3000a610: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a614: e5803000 str r3, [r0] <== NOT EXECUTED 3000a618: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
3000a61c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30009f80 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
30009f80: e92d40d3 push {r0, r1, r4, r6, r7, lr}
if ( !tp )
30009f84: e2514000 subs r4, r1, #0
30009f88: 0a00001f beq 3000a00c <clock_gettime+0x8c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
30009f8c: e3500001 cmp r0, #1
30009f90: 1a000010 bne 30009fd8 <clock_gettime+0x58>
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
30009f94: e59f1084 ldr r1, [pc, #132] ; 3000a020 <clock_gettime+0xa0> 30009f98: e1a0000d mov r0, sp 30009f9c: eb000784 bl 3000bdb4 <_TOD_Get_with_nanoseconds>
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30009fa0: e59f207c ldr r2, [pc, #124] ; 3000a024 <clock_gettime+0xa4>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
30009fa4: e89000c0 ldm r0, {r6, r7}
30009fa8: e3a03000 mov r3, #0
30009fac: e1a00006 mov r0, r6
30009fb0: e1a01007 mov r1, r7
30009fb4: eb005319 bl 3001ec20 <__divdi3>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30009fb8: e1a01007 mov r1, r7
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30009fbc: e5840000 str r0, [r4]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30009fc0: e59f205c ldr r2, [pc, #92] ; 3000a024 <clock_gettime+0xa4> 30009fc4: e1a00006 mov r0, r6 30009fc8: e3a03000 mov r3, #0 30009fcc: eb00544e bl 3001f10c <__moddi3> 30009fd0: e5840004 str r0, [r4, #4] 30009fd4: ea000005 b 30009ff0 <clock_gettime+0x70>
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
30009fd8: e3500004 cmp r0, #4 <== NOT EXECUTED 30009fdc: 0a000001 beq 30009fe8 <clock_gettime+0x68> <== NOT EXECUTED
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
30009fe0: e3500002 cmp r0, #2 <== NOT EXECUTED 30009fe4: 1a000003 bne 30009ff8 <clock_gettime+0x78> <== NOT EXECUTED
_TOD_Get_uptime_as_timespec( tp );
30009fe8: e1a00004 mov r0, r4 <== NOT EXECUTED 30009fec: eb000781 bl 3000bdf8 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return 0;
30009ff0: e3a00000 mov r0, #0 30009ff4: ea000008 b 3000a01c <clock_gettime+0x9c>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
30009ff8: e3500003 cmp r0, #3 <== NOT EXECUTED 30009ffc: 1a000002 bne 3000a00c <clock_gettime+0x8c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a000: eb002258 bl 30012968 <__errno> <== NOT EXECUTED 3000a004: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a008: ea000001 b 3000a014 <clock_gettime+0x94> <== NOT EXECUTED
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
3000a00c: eb002255 bl 30012968 <__errno> <== NOT EXECUTED 3000a010: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a014: e5803000 str r3, [r0] <== NOT EXECUTED 3000a018: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
3000a01c: e8bd80dc pop {r2, r3, r4, r6, r7, pc}
30009de0 <clock_setenable_attr>:
int clock_setenable_attr(
clockid_t clock_id,
int attr
)
{
30009de0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009de4: eb002088 bl 3001200c <__errno> <== NOT EXECUTED 30009de8: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009dec: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009df0: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009df4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300261ec <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
300261ec: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
if ( !tp )
300261f0: e3510000 cmp r1, #0 <== NOT EXECUTED 300261f4: 0a00001c beq 3002626c <clock_settime+0x80> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
300261f8: e3500001 cmp r0, #1 <== NOT EXECUTED 300261fc: 1a000013 bne 30026250 <clock_settime+0x64> <== NOT EXECUTED
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
30026200: e5912000 ldr r2, [r1] <== NOT EXECUTED 30026204: e59f3074 ldr r3, [pc, #116] ; 30026280 <clock_settime+0x94><== NOT EXECUTED 30026208: e1520003 cmp r2, r3 <== NOT EXECUTED 3002620c: 9a000016 bls 3002626c <clock_settime+0x80> <== 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;
30026210: e59f306c ldr r3, [pc, #108] ; 30026284 <clock_settime+0x98><== NOT EXECUTED 30026214: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
30026218: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3002621c: e5832000 str r2, [r3] <== NOT EXECUTED
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
30026220: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
30026224: e1a02001 mov r2, r1 <== NOT EXECUTED
30026228: e1a03fc1 asr r3, r1, #31 <== NOT EXECUTED
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
3002622c: e59f1054 ldr r1, [pc, #84] ; 30026288 <clock_settime+0x9c> <== NOT EXECUTED
30026230: e0e32091 smlal r2, r3, r1, r0 <== NOT EXECUTED
30026234: e28d0008 add r0, sp, #8 <== NOT EXECUTED
30026238: e920000c stmdb r0!, {r2, r3} <== NOT EXECUTED
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
3002623c: e1a0000d mov r0, sp <== NOT EXECUTED 30026240: eb0003dc bl 300271b8 <_TOD_Set_with_timestamp> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
30026244: ebff9b7c bl 3000d03c <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
30026248: e3a00000 mov r0, #0 <== NOT EXECUTED 3002624c: ea00000a b 3002627c <clock_settime+0x90> <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
30026250: e3500002 cmp r0, #2 <== NOT EXECUTED 30026254: 0a000001 beq 30026260 <clock_settime+0x74> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
30026258: e3500003 cmp r0, #3 <== NOT EXECUTED 3002625c: 1a000002 bne 3002626c <clock_settime+0x80> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30026260: eb003e28 bl 30035b08 <__errno> <== NOT EXECUTED 30026264: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30026268: ea000001 b 30026274 <clock_settime+0x88> <== NOT EXECUTED
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
3002626c: eb003e25 bl 30035b08 <__errno> <== NOT EXECUTED 30026270: e3a03016 mov r3, #22 <== NOT EXECUTED 30026274: e5803000 str r3, [r0] <== NOT EXECUTED 30026278: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
3002627c: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
30009df8 <fork>:
#include <errno.h>
#include <rtems/seterr.h>
int fork( void )
{
30009df8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009dfc: eb002082 bl 3001200c <__errno> <== NOT EXECUTED 30009e00: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009e04: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009e08: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009e0c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009d24 <getitimer>:
int getitimer(
int which,
struct itimerval *value
)
{
if ( !value )
30009d24: e3510000 cmp r1, #0 <== NOT EXECUTED
int getitimer(
int which,
struct itimerval *value
)
{
30009d28: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !value )
30009d2c: 1a000002 bne 30009d3c <getitimer+0x18> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
30009d30: eb002062 bl 30011ec0 <__errno> <== NOT EXECUTED 30009d34: e3a0300e mov r3, #14 <== NOT EXECUTED 30009d38: ea000006 b 30009d58 <getitimer+0x34> <== NOT EXECUTED
switch ( which ) {
30009d3c: e3500002 cmp r0, #2 <== NOT EXECUTED 30009d40: 8a000002 bhi 30009d50 <getitimer+0x2c> <== NOT EXECUTED
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
30009d44: eb00205d bl 30011ec0 <__errno> <== NOT EXECUTED 30009d48: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009d4c: ea000001 b 30009d58 <getitimer+0x34> <== NOT EXECUTED
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
30009d50: eb00205a bl 30011ec0 <__errno> <== NOT EXECUTED 30009d54: e3a03016 mov r3, #22 <== NOT EXECUTED 30009d58: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009d5c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009d60: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3001cc44 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
3001cc44: e92d47f7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, lr}
3001cc48: e1a05000 mov r5, r0
3001cc4c: e1a04001 mov r4, r1
3001cc50: e1a06002 mov r6, r2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
3001cc54: ebffff80 bl 3001ca5c <getpid> 3001cc58: e1550000 cmp r5, r0
3001cc5c: 0a000002 beq 3001cc6c <killinfo+0x28>
rtems_set_errno_and_return_minus_one( ESRCH );
3001cc60: ebffd341 bl 3001196c <__errno> <== NOT EXECUTED 3001cc64: e3a03003 mov r3, #3 <== NOT EXECUTED 3001cc68: ea00007d b 3001ce64 <killinfo+0x220> <== NOT EXECUTED
/*
* Validate the signal passed.
*/
if ( !sig )
3001cc6c: e3540000 cmp r4, #0
3001cc70: 0a000002 beq 3001cc80 <killinfo+0x3c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3001cc74: e2445001 sub r5, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
3001cc78: e355001f cmp r5, #31
3001cc7c: 9a000002 bls 3001cc8c <killinfo+0x48>
rtems_set_errno_and_return_minus_one( EINVAL );
3001cc80: ebffd339 bl 3001196c <__errno> <== NOT EXECUTED 3001cc84: e3a03016 mov r3, #22 <== NOT EXECUTED 3001cc88: ea000075 b 3001ce64 <killinfo+0x220> <== NOT EXECUTED
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
3001cc8c: e59f3208 ldr r3, [pc, #520] ; 3001ce9c <killinfo+0x258> 3001cc90: e3a0200c mov r2, #12 3001cc94: e0233492 mla r3, r2, r4, r3 3001cc98: e5933008 ldr r3, [r3, #8] 3001cc9c: e3530001 cmp r3, #1
3001cca0: 0a00007b beq 3001ce94 <killinfo+0x250> /* * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
3001cca4: e3540008 cmp r4, #8 3001cca8: 13540004 cmpne r4, #4
3001ccac: 0a000001 beq 3001ccb8 <killinfo+0x74>
3001ccb0: e354000b cmp r4, #11
3001ccb4: 1a000003 bne 3001ccc8 <killinfo+0x84>
return pthread_kill( pthread_self(), sig );
3001ccb8: eb000104 bl 3001d0d0 <pthread_self> <== NOT EXECUTED 3001ccbc: e1a01004 mov r1, r4 <== NOT EXECUTED 3001ccc0: eb0000cd bl 3001cffc <pthread_kill> <== NOT EXECUTED 3001ccc4: ea000073 b 3001ce98 <killinfo+0x254> <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3001ccc8: e3a03001 mov r3, #1
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
3001cccc: e3560000 cmp r6, #0
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
3001ccd0: e58d3004 str r3, [sp, #4] 3001ccd4: e1a05513 lsl r5, r3, r5
if ( !value ) {
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
3001ccd8: 15963000 ldrne r3, [r6]
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
3001ccdc: e58d4000 str r4, [sp]
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
3001cce0: 158d3008 strne r3, [sp, #8]
*
* 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;
3001cce4: e59f31b4 ldr r3, [pc, #436] ; 3001cea0 <killinfo+0x25c>
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
3001cce8: 058d6008 streq r6, [sp, #8] 3001ccec: e5932000 ldr r2, [r3]
++level;
3001ccf0: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3001ccf4: e5832000 str r2, [r3]
*/
void _POSIX_signals_Manager_Initialization(void);
static inline void _POSIX_signals_Add_post_switch_extension(void)
{
_API_extensions_Add_post_switch( &_POSIX_signals_Post_switch );
3001ccf8: e59f01a4 ldr r0, [pc, #420] ; 3001cea4 <killinfo+0x260> 3001ccfc: ebffb76c bl 3000aab4 <_API_extensions_Add_post_switch>
/*
* Is the currently executing thread interested? If so then it will
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Thread_Executing;
3001cd00: e59f31a0 ldr r3, [pc, #416] ; 3001cea8 <killinfo+0x264> 3001cd04: e5930008 ldr r0, [r3, #8]
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
3001cd08: e59030f4 ldr r3, [r0, #244] ; 0xf4 3001cd0c: e59330d0 ldr r3, [r3, #208] ; 0xd0 3001cd10: e1d53003 bics r3, r5, r3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3001cd14: 059f3190 ldreq r3, [pc, #400] ; 3001ceac <killinfo+0x268> 3001cd18: 04930004 ldreq r0, [r3], #4
3001cd1c: 0a000008 beq 3001cd44 <killinfo+0x100>
3001cd20: ea00003b b 3001ce14 <killinfo+0x1d0> <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
3001cd24: e5901030 ldr r1, [r0, #48] ; 0x30 <== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3001cd28: e59020f4 ldr r2, [r0, #244] ; 0xf4 <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
3001cd2c: e1150001 tst r5, r1 <== NOT EXECUTED 3001cd30: 1a000037 bne 3001ce14 <killinfo+0x1d0> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
3001cd34: e59220d0 ldr r2, [r2, #208] ; 0xd0 <== NOT EXECUTED 3001cd38: e1d52002 bics r2, r5, r2 <== NOT EXECUTED 3001cd3c: 1a000034 bne 3001ce14 <killinfo+0x1d0> <== NOT EXECUTED
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
3001cd40: e5900000 ldr r0, [r0] <== NOT EXECUTED
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
3001cd44: e1500003 cmp r0, r3
3001cd48: 1afffff5 bne 3001cd24 <killinfo+0xe0> * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
3001cd4c: e59f315c ldr r3, [pc, #348] ; 3001ceb0 <killinfo+0x26c> 3001cd50: e59fc15c ldr ip, [pc, #348] ; 3001ceb4 <killinfo+0x270> 3001cd54: e5d32000 ldrb r2, [r3]
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
3001cd58: e28ca008 add sl, ip, #8
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
3001cd5c: e2822001 add r2, r2, #1
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
3001cd60: e3a00000 mov r0, #0
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
3001cd64: e5bc3004 ldr r3, [ip, #4]! 3001cd68: e3530000 cmp r3, #0
3001cd6c: 0a000024 beq 3001ce04 <killinfo+0x1c0>
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
3001cd70: e5933004 ldr r3, [r3, #4]
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
3001cd74: e3a0e001 mov lr, #1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
3001cd78: e1d391b0 ldrh r9, [r3, #16] 3001cd7c: e593601c ldr r6, [r3, #28]
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
3001cd80: ea00001d b 3001cdfc <killinfo+0x1b8>
the_thread = (Thread_Control *) object_table[ index ];
3001cd84: e5b63004 ldr r3, [r6, #4]!
if ( !the_thread )
3001cd88: e3530000 cmp r3, #0
3001cd8c: 0a000019 beq 3001cdf8 <killinfo+0x1b4>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
3001cd90: e5931014 ldr r1, [r3, #20] 3001cd94: e1510002 cmp r1, r2
3001cd98: 8a000016 bhi 3001cdf8 <killinfo+0x1b4>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
3001cd9c: e59370f4 ldr r7, [r3, #244] ; 0xf4 3001cda0: e59770d0 ldr r7, [r7, #208] ; 0xd0 3001cda4: e1d57007 bics r7, r5, r7
3001cda8: 0a000012 beq 3001cdf8 <killinfo+0x1b4>
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
3001cdac: e1510002 cmp r1, r2 <== NOT EXECUTED 3001cdb0: 3a00000e bcc 3001cdf0 <killinfo+0x1ac> <== NOT EXECUTED
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
3001cdb4: e3500000 cmp r0, #0 <== NOT EXECUTED 3001cdb8: 0a00000e beq 3001cdf8 <killinfo+0x1b4> <== NOT EXECUTED 3001cdbc: e5908010 ldr r8, [r0, #16] <== NOT EXECUTED 3001cdc0: e3580000 cmp r8, #0 <== NOT EXECUTED 3001cdc4: 0a00000b beq 3001cdf8 <killinfo+0x1b4> <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
3001cdc8: e5937010 ldr r7, [r3, #16] <== NOT EXECUTED 3001cdcc: e3570000 cmp r7, #0 <== NOT EXECUTED 3001cdd0: 0a000006 beq 3001cdf0 <killinfo+0x1ac> <== NOT EXECUTED
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
3001cdd4: e3180201 tst r8, #268435456 ; 0x10000000 <== NOT EXECUTED 3001cdd8: 1a000006 bne 3001cdf8 <killinfo+0x1b4> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
3001cddc: e2077201 and r7, r7, #268435456 ; 0x10000000 <== NOT EXECUTED
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
3001cde0: e3570000 cmp r7, #0 <== NOT EXECUTED 3001cde4: 11a02001 movne r2, r1 <== NOT EXECUTED 3001cde8: 11a00003 movne r0, r3 <== NOT EXECUTED 3001cdec: ea000001 b 3001cdf8 <killinfo+0x1b4> <== NOT EXECUTED
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
3001cdf0: e1a02001 mov r2, r1 <== NOT EXECUTED 3001cdf4: e1a00003 mov r0, r3 <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
3001cdf8: e28ee001 add lr, lr, #1 3001cdfc: e15e0009 cmp lr, r9
3001ce00: 9affffdf bls 3001cd84 <killinfo+0x140>
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
3001ce04: e15c000a cmp ip, sl
3001ce08: 1affffd5 bne 3001cd64 <killinfo+0x120>
}
}
}
}
if ( interested ) {
3001ce0c: e3500000 cmp r0, #0
3001ce10: 0a000004 beq 3001ce28 <killinfo+0x1e4>
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
3001ce14: e1a01004 mov r1, r4 <== NOT EXECUTED 3001ce18: e1a0200d mov r2, sp <== NOT EXECUTED 3001ce1c: eb000031 bl 3001cee8 <_POSIX_signals_Unblock_thread> <== NOT EXECUTED 3001ce20: e3500000 cmp r0, #0 <== NOT EXECUTED 3001ce24: 1a000019 bne 3001ce90 <killinfo+0x24c> <== NOT EXECUTED
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
3001ce28: e1a00005 mov r0, r5 3001ce2c: eb000023 bl 3001cec0 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
3001ce30: e3a0300c mov r3, #12 3001ce34: e0040493 mul r4, r3, r4 3001ce38: e59f305c ldr r3, [pc, #92] ; 3001ce9c <killinfo+0x258> 3001ce3c: e7933004 ldr r3, [r3, r4] 3001ce40: e3530002 cmp r3, #2
3001ce44: 1a000011 bne 3001ce90 <killinfo+0x24c>
psiginfo = (POSIX_signals_Siginfo_node *)
3001ce48: e59f0068 ldr r0, [pc, #104] ; 3001ceb8 <killinfo+0x274> <== NOT EXECUTED 3001ce4c: ebffb77b bl 3000ac40 <_Chain_Get> <== NOT EXECUTED
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
3001ce50: e250c000 subs ip, r0, #0 <== NOT EXECUTED 3001ce54: 1a000005 bne 3001ce70 <killinfo+0x22c> <== NOT EXECUTED
_Thread_Enable_dispatch();
3001ce58: ebffbe84 bl 3000c870 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
3001ce5c: ebffd2c2 bl 3001196c <__errno> <== NOT EXECUTED 3001ce60: e3a0300b mov r3, #11 <== NOT EXECUTED 3001ce64: e5803000 str r3, [r0] <== NOT EXECUTED 3001ce68: e3e00000 mvn r0, #0 <== NOT EXECUTED 3001ce6c: ea000009 b 3001ce98 <killinfo+0x254> <== NOT EXECUTED
}
psiginfo->Info = *siginfo;
3001ce70: e28c3008 add r3, ip, #8 <== NOT EXECUTED
3001ce74: e28de00c add lr, sp, #12 <== NOT EXECUTED
3001ce78: e91e0007 ldmdb lr, {r0, r1, r2} <== NOT EXECUTED
3001ce7c: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
3001ce80: e59f0034 ldr r0, [pc, #52] ; 3001cebc <killinfo+0x278> <== NOT EXECUTED 3001ce84: e1a0100c mov r1, ip <== NOT EXECUTED 3001ce88: e0800004 add r0, r0, r4 <== NOT EXECUTED 3001ce8c: ebffb760 bl 3000ac14 <_Chain_Append> <== NOT EXECUTED
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
3001ce90: ebffbe76 bl 3000c870 <_Thread_Enable_dispatch>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
return 0;
3001ce94: e3a00000 mov r0, #0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
3001ce98: e8bd87fe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, pc}
30009e10 <lio_listio>:
int mode __attribute__((unused)),
struct aiocb * const list[] __attribute__((unused)),
int nent __attribute__((unused)),
struct sigevent *sig __attribute__((unused))
)
{
30009e10: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009e14: eb00207c bl 3001200c <__errno> <== NOT EXECUTED 30009e18: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009e1c: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009e20: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009e24: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009e28 <mprotect>:
const void *addr __attribute__((unused)),
size_t len __attribute__((unused)),
int prot __attribute__((unused)) )
{
return 0;
}
30009e28: e3a00000 mov r0, #0 <== NOT EXECUTED 30009e2c: e12fff1e bx lr <== NOT EXECUTED
3000eee4 <mq_close>:
*/
int mq_close(
mqd_t mqdes
)
{
3000eee4: e92d4031 push {r0, r4, r5, lr}
3000eee8: e1a01000 mov r1, r0
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000eeec: e1a0200d mov r2, sp 3000eef0: e59f005c ldr r0, [pc, #92] ; 3000ef54 <mq_close+0x70> 3000eef4: eb000d26 bl 30012394 <_Objects_Get>
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
if ( location == OBJECTS_LOCAL ) {
3000eef8: e59d5000 ldr r5, [sp] 3000eefc: e1a04000 mov r4, r0 3000ef00: e3550000 cmp r5, #0
3000ef04: 1a00000d bne 3000ef40 <mq_close+0x5c>
* First update the actual message queue to reflect this descriptor
* being disassociated. This may result in the queue being really
* deleted.
*/
the_mq = the_mq_fd->Queue;
3000ef08: e5900010 ldr r0, [r0, #16]
the_mq->open_count -= 1;
3000ef0c: e5903018 ldr r3, [r0, #24] 3000ef10: e2433001 sub r3, r3, #1 3000ef14: e5803018 str r3, [r0, #24]
_POSIX_Message_queue_Delete( the_mq );
3000ef18: eb00000e bl 3000ef58 <_POSIX_Message_queue_Delete>
/*
* Now close this file descriptor.
*/
_Objects_Close(
3000ef1c: e59f0030 ldr r0, [pc, #48] ; 3000ef54 <mq_close+0x70> 3000ef20: e1a01004 mov r1, r4 3000ef24: eb000c18 bl 30011f8c <_Objects_Close>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
3000ef28: e59f0024 ldr r0, [pc, #36] ; 3000ef54 <mq_close+0x70> 3000ef2c: e1a01004 mov r1, r4 3000ef30: eb000cc2 bl 30012240 <_Objects_Free>
&_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000ef34: eb0010a4 bl 300131cc <_Thread_Enable_dispatch>
return 0;
3000ef38: e1a00005 mov r0, r5 3000ef3c: ea000003 b 3000ef50 <mq_close+0x6c>
/*
* OBJECTS_REMOTE:
* OBJECTS_ERROR:
*/
rtems_set_errno_and_return_minus_one( EBADF );
3000ef40: eb002699 bl 300189ac <__errno> <== NOT EXECUTED 3000ef44: e3a03009 mov r3, #9 <== NOT EXECUTED 3000ef48: e5803000 str r3, [r0] <== NOT EXECUTED 3000ef4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000ef50: e8bd8038 pop {r3, r4, r5, pc}
3000efa8 <mq_getattr>:
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
3000efa8: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
if ( !mqstat )
3000efac: e2514000 subs r4, r1, #0 <== NOT EXECUTED
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
3000efb0: e1a03000 mov r3, r0 <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
if ( !mqstat )
3000efb4: 1a000002 bne 3000efc4 <mq_getattr+0x1c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000efb8: eb00267b bl 300189ac <__errno> <== NOT EXECUTED 3000efbc: e3a03016 mov r3, #22 <== NOT EXECUTED 3000efc0: ea000014 b 3000f018 <mq_getattr+0x70> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000efc4: e59f0058 ldr r0, [pc, #88] ; 3000f024 <mq_getattr+0x7c> <== NOT EXECUTED 3000efc8: e1a01003 mov r1, r3 <== NOT EXECUTED 3000efcc: e1a0200d mov r2, sp <== NOT EXECUTED 3000efd0: eb000cef bl 30012394 <_Objects_Get> <== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000efd4: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000efd8: e3550000 cmp r5, #0 <== NOT EXECUTED 3000efdc: 1a00000b bne 3000f010 <mq_getattr+0x68> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
3000efe0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
/*
* Return the old values.
*/
mqstat->mq_flags = the_mq_fd->oflag;
3000efe4: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED 3000efe8: e5842000 str r2, [r4] <== NOT EXECUTED
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
3000efec: e5932068 ldr r2, [r3, #104] ; 0x68 <== NOT EXECUTED 3000eff0: e5842008 str r2, [r4, #8] <== NOT EXECUTED
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
3000eff4: e5932060 ldr r2, [r3, #96] ; 0x60 <== NOT EXECUTED
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
3000eff8: e5933064 ldr r3, [r3, #100] ; 0x64 <== NOT EXECUTED
/*
* Return the old values.
*/
mqstat->mq_flags = the_mq_fd->oflag;
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
3000effc: e5842004 str r2, [r4, #4] <== NOT EXECUTED
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
3000f000: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000f004: eb001070 bl 300131cc <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000f008: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f00c: ea000003 b 3000f020 <mq_getattr+0x78> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f010: eb002665 bl 300189ac <__errno> <== NOT EXECUTED 3000f014: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f018: e5803000 str r3, [r0] <== NOT EXECUTED 3000f01c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000f020: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000f04c <mq_notify>:
int mq_notify(
mqd_t mqdes,
const struct sigevent *notification
)
{
3000f04c: e92d4011 push {r0, r4, lr}
3000f050: e1a03000 mov r3, r0
3000f054: e1a04001 mov r4, r1
3000f058: e59f0088 ldr r0, [pc, #136] ; 3000f0e8 <mq_notify+0x9c>
3000f05c: e1a01003 mov r1, r3
3000f060: e1a0200d mov r2, sp
3000f064: eb000cca bl 30012394 <_Objects_Get>
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000f068: e59d3000 ldr r3, [sp] 3000f06c: e3530000 cmp r3, #0
3000f070: 1a000017 bne 3000f0d4 <mq_notify+0x88>
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
if ( notification ) {
3000f074: e3540000 cmp r4, #0
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
3000f078: e590c010 ldr ip, [r0, #16]
if ( notification ) {
3000f07c: 0a00000f beq 3000f0c0 <mq_notify+0x74>
if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {
3000f080: e59c307c ldr r3, [ip, #124] ; 0x7c 3000f084: e3530000 cmp r3, #0
3000f088: 0a000003 beq 3000f09c <mq_notify+0x50>
_Thread_Enable_dispatch();
3000f08c: eb00104e bl 300131cc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
3000f090: eb002645 bl 300189ac <__errno> <== NOT EXECUTED 3000f094: e3a03010 mov r3, #16 <== NOT EXECUTED 3000f098: ea00000f b 3000f0dc <mq_notify+0x90> <== NOT EXECUTED
}
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
the_mq->notification = *notification;
3000f09c: e28ce090 add lr, ip, #144 ; 0x90
3000f0a0: e8b4000f ldm r4!, {r0, r1, r2, r3}
3000f0a4: e8ae000f stmia lr!, {r0, r1, r2, r3}
3000f0a8: e5943000 ldr r3, [r4]
3000f0ac: e58e3000 str r3, [lr]
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
3000f0b0: e59f3034 ldr r3, [pc, #52] ; 3000f0ec <mq_notify+0xa0>
the_message_queue->notify_argument = the_argument;
3000f0b4: e58cc080 str ip, [ip, #128] ; 0x80
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
3000f0b8: e58c307c str r3, [ip, #124] ; 0x7c 3000f0bc: ea000001 b 3000f0c8 <mq_notify+0x7c>
3000f0c0: e58c407c str r4, [ip, #124] ; 0x7c <== NOT EXECUTED
the_message_queue->notify_argument = the_argument;
3000f0c4: e58c4080 str r4, [ip, #128] ; 0x80 <== NOT EXECUTED
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
}
_Thread_Enable_dispatch();
3000f0c8: eb00103f bl 300131cc <_Thread_Enable_dispatch>
return 0;
3000f0cc: e3a00000 mov r0, #0 3000f0d0: ea000003 b 3000f0e4 <mq_notify+0x98>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f0d4: eb002634 bl 300189ac <__errno> <== NOT EXECUTED 3000f0d8: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f0dc: e5803000 str r3, [r0] <== NOT EXECUTED 3000f0e0: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000f0e4: e8bd8018 pop {r3, r4, pc}
3000a4b0 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
3000a4b0: e92d000e push {r1, r2, r3}
3000a4b4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
*
* 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;
3000a4b8: e59f3178 ldr r3, [pc, #376] ; 3000a638 <mq_open+0x188> 3000a4bc: e24dd018 sub sp, sp, #24 3000a4c0: e5932000 ldr r2, [r3] 3000a4c4: e59d6038 ldr r6, [sp, #56] ; 0x38
++level;
3000a4c8: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000a4cc: e5832000 str r2, [r3] 3000a4d0: e1a08000 mov r8, r0
*/
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
3000a4d4: e59f5160 ldr r5, [pc, #352] ; 3000a63c <mq_open+0x18c>
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
3000a4d8: e2167c02 ands r7, r6, #512 ; 0x200
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
attr = va_arg( arg, struct mq_attr * );
3000a4dc: 128d3044 addne r3, sp, #68 ; 0x44 3000a4e0: e1a00005 mov r0, r5 3000a4e4: 158d3004 strne r3, [sp, #4] 3000a4e8: 159d9040 ldrne r9, [sp, #64] ; 0x40
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
3000a4ec: 01a09007 moveq r9, r7 3000a4f0: eb000af6 bl 3000d0d0 <_Objects_Allocate>
attr = va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
3000a4f4: e2504000 subs r4, r0, #0
3000a4f8: 1a000003 bne 3000a50c <mq_open+0x5c>
_Thread_Enable_dispatch();
3000a4fc: eb000fb9 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
3000a500: eb002489 bl 3001372c <__errno> <== NOT EXECUTED 3000a504: e3a03017 mov r3, #23 <== NOT EXECUTED 3000a508: ea00001c b 3000a580 <mq_open+0xd0> <== NOT EXECUTED
} the_mq_fd->oflag = oflag;
3000a50c: e5846014 str r6, [r4, #20]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Message_queue_Information, name, id, len );
3000a510: e59f0128 ldr r0, [pc, #296] ; 3000a640 <mq_open+0x190> 3000a514: e1a01008 mov r1, r8 3000a518: e28d2008 add r2, sp, #8 3000a51c: e28d3014 add r3, sp, #20 3000a520: eb000117 bl 3000a984 <_POSIX_Name_to_id>
* If the name to id translation worked, then the message queue exists
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "message queue does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
3000a524: e250a000 subs sl, r0, #0
3000a528: 0a00000b beq 3000a55c <mq_open+0xac>
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
3000a52c: e35a0002 cmp sl, #2
3000a530: 1a000001 bne 3000a53c <mq_open+0x8c>
3000a534: e3570000 cmp r7, #0
3000a538: 1a000021 bne 3000a5c4 <mq_open+0x114>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
3000a53c: e59f00f8 ldr r0, [pc, #248] ; 3000a63c <mq_open+0x18c> <== NOT EXECUTED 3000a540: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a544: eb000bb0 bl 3000d40c <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000a548: eb000fa6 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
3000a54c: eb002476 bl 3001372c <__errno> <== NOT EXECUTED 3000a550: e580a000 str sl, [r0] <== NOT EXECUTED 3000a554: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000a558: ea000032 b 3000a628 <mq_open+0x178> <== NOT EXECUTED
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
3000a55c: e2066c0a and r6, r6, #2560 ; 0xa00 3000a560: e3560c0a cmp r6, #2560 ; 0xa00
3000a564: 1a000007 bne 3000a588 <mq_open+0xd8>
3000a568: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a56c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a570: eb000ba5 bl 3000d40c <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000a574: eb000f9b bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
3000a578: eb00246b bl 3001372c <__errno> <== NOT EXECUTED 3000a57c: e3a03011 mov r3, #17 <== NOT EXECUTED 3000a580: e5803000 str r3, [r0] <== NOT EXECUTED 3000a584: eafffff2 b 3000a554 <mq_open+0xa4> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
3000a588: e28d2010 add r2, sp, #16 3000a58c: e59d1008 ldr r1, [sp, #8] 3000a590: e59f00a8 ldr r0, [pc, #168] ; 3000a640 <mq_open+0x190> 3000a594: eb000bf1 bl 3000d560 <_Objects_Get>
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
the_mq->open_count += 1;
3000a598: e5903018 ldr r3, [r0, #24]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
3000a59c: e1d420b8 ldrh r2, [r4, #8] 3000a5a0: e2833001 add r3, r3, #1 3000a5a4: e5803018 str r3, [r0, #24]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a5a8: e595301c ldr r3, [r5, #28]
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
3000a5ac: e58d000c str r0, [sp, #12]
the_mq->open_count += 1;
the_mq_fd->Queue = the_mq;
3000a5b0: e5840010 str r0, [r4, #16] 3000a5b4: e7834102 str r4, [r3, r2, lsl #2]
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
3000a5b8: e584a00c str sl, [r4, #12]
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
3000a5bc: eb000f89 bl 3000e3e8 <_Thread_Enable_dispatch> 3000a5c0: ea000016 b 3000a620 <mq_open+0x170>
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
3000a5c4: e28d300c add r3, sp, #12 3000a5c8: e58d3000 str r3, [sp] 3000a5cc: e1a00008 mov r0, r8 3000a5d0: e59d1014 ldr r1, [sp, #20] 3000a5d4: e3a02001 mov r2, #1 3000a5d8: e1a03009 mov r3, r9 3000a5dc: eb001907 bl 30010a00 <_POSIX_Message_queue_Create_support>
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
3000a5e0: e3700001 cmn r0, #1
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
3000a5e4: e1a06000 mov r6, r0
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
3000a5e8: 1a000005 bne 3000a604 <mq_open+0x154>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
3000a5ec: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a5f0: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a5f4: eb000b84 bl 3000d40c <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000a5f8: eb000f7a bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return (mqd_t) -1;
3000a5fc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a600: ea000008 b 3000a628 <mq_open+0x178> <== NOT EXECUTED
}
the_mq_fd->Queue = the_mq;
3000a604: e59d300c ldr r3, [sp, #12]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
3000a608: e1d420b8 ldrh r2, [r4, #8] 3000a60c: e5843010 str r3, [r4, #16]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a610: e595301c ldr r3, [r5, #28] 3000a614: e7834102 str r4, [r3, r2, lsl #2]
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
3000a618: e3a03000 mov r3, #0 3000a61c: e584300c str r3, [r4, #12]
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
3000a620: eb000f70 bl 3000e3e8 <_Thread_Enable_dispatch>
return (mqd_t) the_mq_fd->Object.id;
3000a624: e5940008 ldr r0, [r4, #8]
}
3000a628: e28dd018 add sp, sp, #24
3000a62c: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
3000a630: e28dd00c add sp, sp, #12
3000a634: e12fff1e bx lr
3000f4d4 <mq_setattr>:
int mq_setattr(
mqd_t mqdes,
const struct mq_attr *mqstat,
struct mq_attr *omqstat
)
{
3000f4d4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
POSIX_Message_queue_Control_fd *the_mq_fd;
CORE_message_queue_Control *the_core_mq;
Objects_Locations location;
if ( !mqstat )
3000f4d8: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int mq_setattr(
mqd_t mqdes,
const struct mq_attr *mqstat,
struct mq_attr *omqstat
)
{
3000f4dc: e1a03000 mov r3, r0 <== NOT EXECUTED 3000f4e0: e1a04002 mov r4, r2 <== NOT EXECUTED
POSIX_Message_queue_Control_fd *the_mq_fd;
CORE_message_queue_Control *the_core_mq;
Objects_Locations location;
if ( !mqstat )
3000f4e4: 1a000002 bne 3000f4f4 <mq_setattr+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000f4e8: eb00252f bl 300189ac <__errno> <== NOT EXECUTED 3000f4ec: e3a03016 mov r3, #22 <== NOT EXECUTED 3000f4f0: ea000018 b 3000f558 <mq_setattr+0x84> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000f4f4: e1a01003 mov r1, r3 <== NOT EXECUTED 3000f4f8: e59f0064 ldr r0, [pc, #100] ; 3000f564 <mq_setattr+0x90> <== NOT EXECUTED 3000f4fc: e1a0200d mov r2, sp <== NOT EXECUTED 3000f500: eb000ba3 bl 30012394 <_Objects_Get> <== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000f504: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000f508: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f50c: 1a00000f bne 3000f550 <mq_setattr+0x7c> <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
3000f510: e3540000 cmp r4, #0 <== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_core_mq = &the_mq_fd->Queue->Message_queue;
3000f514: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
3000f518: 0a000007 beq 3000f53c <mq_setattr+0x68> <== NOT EXECUTED
omqstat->mq_flags = the_mq_fd->oflag;
3000f51c: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED 3000f520: e5842000 str r2, [r4] <== NOT EXECUTED
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
3000f524: e5932068 ldr r2, [r3, #104] ; 0x68 <== NOT EXECUTED 3000f528: e5842008 str r2, [r4, #8] <== NOT EXECUTED
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
3000f52c: e5932060 ldr r2, [r3, #96] ; 0x60 <== NOT EXECUTED
omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages;
3000f530: e5933064 ldr r3, [r3, #100] ; 0x64 <== NOT EXECUTED
*/
if ( omqstat ) {
omqstat->mq_flags = the_mq_fd->oflag;
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
3000f534: e5842004 str r2, [r4, #4] <== NOT EXECUTED
omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages;
3000f538: e584300c str r3, [r4, #12] <== NOT EXECUTED
}
the_mq_fd->oflag = mqstat->mq_flags;
3000f53c: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000f540: e5803014 str r3, [r0, #20] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000f544: eb000f20 bl 300131cc <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000f548: e3a00000 mov r0, #0 <== NOT EXECUTED 3000f54c: ea000003 b 3000f560 <mq_setattr+0x8c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f550: eb002515 bl 300189ac <__errno> <== NOT EXECUTED 3000f554: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f558: e5803000 str r3, [r0] <== NOT EXECUTED 3000f55c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000f560: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000f618 <mq_unlink>:
*
* 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;
3000f618: e59f3070 ldr r3, [pc, #112] ; 3000f690 <mq_unlink+0x78>
*/
int mq_unlink(
const char *name
)
{
3000f61c: e92d4073 push {r0, r1, r4, r5, r6, lr}
3000f620: e5932000 ldr r2, [r3]
3000f624: e1a01000 mov r1, r0
++level;
3000f628: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000f62c: e5832000 str r2, [r3]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Message_queue_Information, name, id, len );
3000f630: e59f405c ldr r4, [pc, #92] ; 3000f694 <mq_unlink+0x7c> 3000f634: e1a0200d mov r2, sp 3000f638: e1a00004 mov r0, r4 3000f63c: e28d3004 add r3, sp, #4 3000f640: eb000041 bl 3000f74c <_POSIX_Name_to_id>
size_t name_len;
_Thread_Disable_dispatch();
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id, &name_len );
if ( status != 0 ) {
3000f644: e2505000 subs r5, r0, #0
3000f648: 0a000004 beq 3000f660 <mq_unlink+0x48>
_Thread_Enable_dispatch();
3000f64c: eb000ede bl 300131cc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( status );
3000f650: eb0024d5 bl 300189ac <__errno> <== NOT EXECUTED 3000f654: e5805000 str r5, [r0] <== NOT EXECUTED 3000f658: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000f65c: ea00000a b 3000f68c <mq_unlink+0x74> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3000f660: e594301c ldr r3, [r4, #28] 3000f664: e1dd20b0 ldrh r2, [sp]
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Namespace_remove (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Namespace_remove(
3000f668: e1a00004 mov r0, r4 3000f66c: e7936102 ldr r6, [r3, r2, lsl #2] 3000f670: e1a01006 mov r1, r6
the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object(
&_POSIX_Message_queue_Information,
_Objects_Get_index( the_mq_id )
);
the_mq->linked = false;
3000f674: e5c65015 strb r5, [r6, #21] 3000f678: eb000b92 bl 300124c8 <_Objects_Namespace_remove>
_POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq );
3000f67c: e1a00006 mov r0, r6 3000f680: ebfffe34 bl 3000ef58 <_POSIX_Message_queue_Delete>
_Thread_Enable_dispatch();
3000f684: eb000ed0 bl 300131cc <_Thread_Enable_dispatch>
return 0;
3000f688: e1a00005 mov r0, r5
}
3000f68c: e8bd807c pop {r2, r3, r4, r5, r6, pc}
300295e8 <nanosleep>:
int nanosleep(
const struct timespec *rqtp,
struct timespec *rmtp
)
{
300295e8: e92d4070 push {r4, r5, r6, lr}
300295ec: e1a05000 mov r5, r0
300295f0: e1a04001 mov r4, r1
* Return EINVAL if the delay interval is negative. * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( !_Timespec_Is_valid( rqtp ) )
300295f4: eb000051 bl 30029740 <_Timespec_Is_valid> 300295f8: e3500000 cmp r0, #0
300295fc: 1a000002 bne 3002960c <nanosleep+0x24>
rtems_set_errno_and_return_minus_one( EINVAL );
30029600: ebffbd2b bl 30018ab4 <__errno> <== NOT EXECUTED 30029604: e3a03016 mov r3, #22 <== NOT EXECUTED 30029608: ea00002f b 300296cc <nanosleep+0xe4> <== NOT EXECUTED
ticks = _Timespec_To_ticks( rqtp );
3002960c: e1a00005 mov r0, r5 30029610: ebffb3b5 bl 300164ec <_Timespec_To_ticks> 30029614: e59f30c8 ldr r3, [pc, #200] ; 300296e4 <nanosleep+0xfc>
* A nanosleep for zero time is implemented as a yield.
* This behavior is also beyond the POSIX specification but is
* consistent with the RTEMS API and yields desirable behavior.
*/
if ( !ticks ) {
30029618: e2505000 subs r5, r0, #0
*
* 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;
3002961c: e5932000 ldr r2, [r3]
++level;
30029620: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
30029624: e5832000 str r2, [r3]
30029628: 1a000008 bne 30029650 <nanosleep+0x68>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
3002962c: e59f30b4 ldr r3, [pc, #180] ; 300296e8 <nanosleep+0x100> 30029630: e1a0e00f mov lr, pc 30029634: e593f00c ldr pc, [r3, #12]
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
30029638: ebff9a95 bl 30010094 <_Thread_Enable_dispatch>
if ( rmtp ) {
3002963c: e3540000 cmp r4, #0
rmtp->tv_sec = 0;
30029640: 15845000 strne r5, [r4]
rmtp->tv_nsec = 0;
30029644: 15845004 strne r5, [r4, #4]
if ( !ticks ) {
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
if ( rmtp ) {
30029648: 1a000023 bne 300296dc <nanosleep+0xf4>
3002964c: ea000021 b 300296d8 <nanosleep+0xf0>
/*
* Block for the desired amount of time
*/
_Thread_Disable_dispatch();
_Thread_Set_state(
30029650: e59f6094 ldr r6, [pc, #148] ; 300296ec <nanosleep+0x104> 30029654: e3a01281 mov r1, #268435464 ; 0x10000008 30029658: e5960008 ldr r0, [r6, #8] 3002965c: ebff9c9e bl 300108dc <_Thread_Set_state>
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
&_Thread_Executing->Timer,
30029660: e5961008 ldr r1, [r6, #8]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30029664: e59f0084 ldr r0, [pc, #132] ; 300296f0 <nanosleep+0x108>
_Thread_Disable_dispatch();
_Thread_Set_state(
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
30029668: e5912008 ldr r2, [r1, #8]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3002966c: e3a03000 mov r3, #0 30029670: e5813050 str r3, [r1, #80] ; 0x50
the_watchdog->routine = routine;
30029674: e5810064 str r0, [r1, #100] ; 0x64
the_watchdog->id = id;
30029678: e5812068 str r2, [r1, #104] ; 0x68
the_watchdog->user_data = user_data;
3002967c: e581306c str r3, [r1, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30029680: e5815054 str r5, [r1, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30029684: e59f0068 ldr r0, [pc, #104] ; 300296f4 <nanosleep+0x10c> 30029688: e2811048 add r1, r1, #72 ; 0x48 3002968c: ebff9d84 bl 30010ca4 <_Watchdog_Insert>
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
_Thread_Enable_dispatch();
30029690: ebff9a7f bl 30010094 <_Thread_Enable_dispatch>
/* calculate time remaining */
if ( rmtp ) {
30029694: e3540000 cmp r4, #0 <== NOT EXECUTED 30029698: 0a00000e beq 300296d8 <nanosleep+0xf0> <== NOT EXECUTED
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
3002969c: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
_Timespec_From_ticks( ticks, rmtp );
300296a0: e1a01004 mov r1, r4 <== NOT EXECUTED
/* calculate time remaining */
if ( rmtp ) {
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
300296a4: e593205c ldr r2, [r3, #92] ; 0x5c <== NOT EXECUTED 300296a8: e5933060 ldr r3, [r3, #96] ; 0x60 <== NOT EXECUTED 300296ac: e0633002 rsb r3, r3, r2 <== NOT EXECUTED
_Thread_Enable_dispatch();
/* calculate time remaining */
if ( rmtp ) {
ticks -=
300296b0: e0835005 add r5, r3, r5 <== NOT EXECUTED
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
_Timespec_From_ticks( ticks, rmtp );
300296b4: e1a00005 mov r0, r5 <== NOT EXECUTED 300296b8: eb00000e bl 300296f8 <_Timespec_From_ticks> <== NOT EXECUTED
*/
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
300296bc: e3550000 cmp r5, #0 <== NOT EXECUTED 300296c0: 0a000005 beq 300296dc <nanosleep+0xf4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINTR );
300296c4: ebffbcfa bl 30018ab4 <__errno> <== NOT EXECUTED 300296c8: e3a03004 mov r3, #4 <== NOT EXECUTED 300296cc: e5803000 str r3, [r0] <== NOT EXECUTED 300296d0: e3e05000 mvn r5, #0 <== NOT EXECUTED 300296d4: ea000000 b 300296dc <nanosleep+0xf4> <== NOT EXECUTED
#endif
}
return 0;
300296d8: e1a05004 mov r5, r4
}
300296dc: e1a00005 mov r0, r5
300296e0: e8bd8070 pop {r4, r5, r6, pc}
3000bd40 <pause>:
/**
* 3.4.2 Suspend Process Execution, P1003.1b-1993, p. 81
*/
int pause( void )
{
3000bd40: e92d4001 push {r0, lr} <== NOT EXECUTED
sigset_t all_signals;
int status;
(void) sigfillset( &all_signals );
3000bd44: e1a0000d mov r0, sp <== NOT EXECUTED 3000bd48: eb0002ec bl 3000c900 <sigfillset> <== NOT EXECUTED
status = sigtimedwait( &all_signals, NULL, NULL );
3000bd4c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bd50: e1a0000d mov r0, sp <== NOT EXECUTED 3000bd54: e1a02001 mov r2, r1 <== NOT EXECUTED 3000bd58: eb00034c bl 3000ca90 <sigtimedwait> <== NOT EXECUTED
return status;
}
3000bd5c: e8bd8008 pop {r3, pc} <== NOT EXECUTED
30009e30 <pthread_atfork>:
int pthread_atfork(
void (*prepare)(void) __attribute__((unused)),
void (*parent)(void) __attribute__((unused)),
void (*child)(void) __attribute__((unused))
)
{
30009e30: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009e34: eb002074 bl 3001200c <__errno> <== NOT EXECUTED 30009e38: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009e3c: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009e40: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009e44: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000e4a0 <pthread_attr_destroy>:
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000e4a0: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e4a4: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000e4a8: 012fff1e bxeq lr <== NOT EXECUTED 3000e4ac: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000e4b0: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000e4b4: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e4b8: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e4bc: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000e4c0: e12fff1e bx lr <== NOT EXECUTED
3000e4c4 <pthread_attr_getdetachstate>:
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000e4c4: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e4c8: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000e4cc: 012fff1e bxeq lr <== NOT EXECUTED 3000e4d0: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e4d4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e4d8: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*detachstate = attr->detachstate;
3000e4dc: 1593303c ldrne r3, [r3, #60] ; 0x3c <== NOT EXECUTED
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000e4e0: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e4e4: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*detachstate = attr->detachstate;
3000e4e8: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
return EINVAL;
3000e4ec: 03a00016 moveq r0, #22 <== NOT EXECUTED
*detachstate = attr->detachstate;
return 0;
}
3000e4f0: e12fff1e bx lr <== NOT EXECUTED
3000e4f4 <pthread_attr_getguardsize>:
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000e4f4: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e4f8: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000e4fc: 012fff1e bxeq lr <== NOT EXECUTED 3000e500: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e504: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e508: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*guardsize = attr->guardsize;
3000e50c: 15933034 ldrne r3, [r3, #52] ; 0x34 <== NOT EXECUTED
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000e510: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e514: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*guardsize = attr->guardsize;
3000e518: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
return EINVAL;
3000e51c: 03a00016 moveq r0, #22 <== NOT EXECUTED
*guardsize = attr->guardsize;
return 0;
}
3000e520: e12fff1e bx lr <== NOT EXECUTED
3000e524 <pthread_attr_getinheritsched>:
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000e524: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e528: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000e52c: 012fff1e bxeq lr <== NOT EXECUTED 3000e530: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e534: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e538: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*inheritsched = attr->inheritsched;
3000e53c: 15933010 ldrne r3, [r3, #16] <== NOT EXECUTED
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000e540: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e544: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*inheritsched = attr->inheritsched;
3000e548: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
3000e54c: 03a00016 moveq r0, #22 <== NOT EXECUTED
*inheritsched = attr->inheritsched;
return 0;
}
3000e550: e12fff1e bx lr <== NOT EXECUTED
3000e554 <pthread_attr_getschedparam>:
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000e554: e3500000 cmp r0, #0 <== NOT EXECUTED
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
3000e558: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
3000e55c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000e560: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
3000e564: e5905000 ldr r5, [r0] <== NOT EXECUTED
3000e568: e3550000 cmp r5, #0 <== NOT EXECUTED
3000e56c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*param = attr->schedparam;
3000e570: 11a0c001 movne ip, r1 <== NOT EXECUTED
3000e574: 12804018 addne r4, r0, #24 <== NOT EXECUTED
3000e578: 18b4000f ldmne r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3000e57c: 18ac000f stmiane ip!, {r0, r1, r2, r3} <== NOT EXECUTED
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000e580: 13a05000 movne r5, #0 <== NOT EXECUTED 3000e584: 03a05001 moveq r5, #1 <== NOT EXECUTED
return EINVAL;
*param = attr->schedparam;
3000e588: 18940007 ldmne r4, {r0, r1, r2} <== NOT EXECUTED
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
3000e58c: 03a00016 moveq r0, #22 <== NOT EXECUTED
*param = attr->schedparam;
3000e590: 188c0007 stmne ip, {r0, r1, r2} <== NOT EXECUTED
return 0;
3000e594: 11a00005 movne r0, r5 <== NOT EXECUTED
}
3000e598: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000e59c <pthread_attr_getschedpolicy>:
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000e59c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e5a0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000e5a4: 012fff1e bxeq lr <== NOT EXECUTED 3000e5a8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e5ac: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e5b0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*policy = attr->schedpolicy;
3000e5b4: 15933014 ldrne r3, [r3, #20] <== NOT EXECUTED
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000e5b8: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e5bc: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*policy = attr->schedpolicy;
3000e5c0: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
return EINVAL;
3000e5c4: 03a00016 moveq r0, #22 <== NOT EXECUTED
*policy = attr->schedpolicy;
return 0;
}
3000e5c8: e12fff1e bx lr <== NOT EXECUTED
3000e5cc <pthread_attr_getscope>:
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000e5cc: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e5d0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000e5d4: 012fff1e bxeq lr <== NOT EXECUTED 3000e5d8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e5dc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e5e0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*contentionscope = attr->contentionscope;
3000e5e4: 1593300c ldrne r3, [r3, #12] <== NOT EXECUTED
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000e5e8: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e5ec: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*contentionscope = attr->contentionscope;
3000e5f0: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
return EINVAL;
3000e5f4: 03a00016 moveq r0, #22 <== NOT EXECUTED
*contentionscope = attr->contentionscope;
return 0;
}
3000e5f8: e12fff1e bx lr <== NOT EXECUTED
3000e62c <pthread_attr_getstack>:
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
3000e62c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000e630: 0a00000c beq 3000e668 <pthread_attr_getstack+0x3c> <== NOT EXECUTED 3000e634: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e638: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e63c: 13510000 cmpne r1, #0 <== NOT EXECUTED 3000e640: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e644: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000e648: 0a000006 beq 3000e668 <pthread_attr_getstack+0x3c> <== NOT EXECUTED 3000e64c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000e650: 0a000006 beq 3000e670 <pthread_attr_getstack+0x44> <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000e654: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED
*stacksize = attr->stacksize;
3000e658: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
*stackaddr = attr->stackaddr;
3000e65c: e581c000 str ip, [r1] <== NOT EXECUTED
*stacksize = attr->stacksize;
3000e660: e5823000 str r3, [r2] <== NOT EXECUTED
return 0;
3000e664: e12fff1e bx lr <== NOT EXECUTED
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
3000e668: e3a00016 mov r0, #22 <== NOT EXECUTED 3000e66c: e12fff1e bx lr <== NOT EXECUTED 3000e670: e3a00016 mov r0, #22 <== NOT EXECUTED
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
return 0;
}
3000e674: e12fff1e bx lr <== NOT EXECUTED
3000e5fc <pthread_attr_getstackaddr>:
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000e5fc: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e600: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000e604: 012fff1e bxeq lr <== NOT EXECUTED 3000e608: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e60c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e610: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000e614: 15933004 ldrne r3, [r3, #4] <== NOT EXECUTED
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000e618: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e61c: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000e620: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
return EINVAL;
3000e624: 03a00016 moveq r0, #22 <== NOT EXECUTED
*stackaddr = attr->stackaddr;
return 0;
}
3000e628: e12fff1e bx lr <== NOT EXECUTED
3000e678 <pthread_attr_getstacksize>:
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000e678: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e67c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000e680: 012fff1e bxeq lr <== NOT EXECUTED 3000e684: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e688: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e68c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*stacksize = attr->stacksize;
3000e690: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000e694: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e698: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*stacksize = attr->stacksize;
3000e69c: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
return EINVAL;
3000e6a0: 03a00016 moveq r0, #22 <== NOT EXECUTED
*stacksize = attr->stacksize;
return 0;
}
3000e6a4: e12fff1e bx lr <== NOT EXECUTED
300101e8 <pthread_attr_init>:
*/
int pthread_attr_init(
pthread_attr_t *attr
)
{
if ( !attr )
300101e8: e250c000 subs ip, r0, #0
* 16.1.1 Thread Creation Attributes, P1003.1c/Draft 10, p, 140
*/
int pthread_attr_init(
pthread_attr_t *attr
)
{
300101ec: e92d4010 push {r4, lr}
if ( !attr )
300101f0: 0a00000a beq 30010220 <pthread_attr_init+0x38>
return EINVAL;
*attr = _POSIX_Threads_Default_attributes;
300101f4: e59f402c ldr r4, [pc, #44] ; 30010228 <pthread_attr_init+0x40>
300101f8: e8b4000f ldm r4!, {r0, r1, r2, r3}
300101fc: e8ac000f stmia ip!, {r0, r1, r2, r3}
30010200: e8b4000f ldm r4!, {r0, r1, r2, r3}
30010204: e8ac000f stmia ip!, {r0, r1, r2, r3}
30010208: e8b4000f ldm r4!, {r0, r1, r2, r3}
3001020c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30010210: e894000f ldm r4, {r0, r1, r2, r3}
30010214: e88c000f stm ip, {r0, r1, r2, r3}
return 0;
30010218: e3a00000 mov r0, #0
3001021c: e8bd8010 pop {r4, pc}
int pthread_attr_init(
pthread_attr_t *attr
)
{
if ( !attr )
return EINVAL;
30010220: e3a00016 mov r0, #22 <== NOT EXECUTED
*attr = _POSIX_Threads_Default_attributes;
return 0;
}
30010224: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000e6ec <pthread_attr_setdetachstate>:
int pthread_attr_setdetachstate(
pthread_attr_t *attr,
int detachstate
)
{
if ( !attr || !attr->is_initialized )
3000e6ec: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e6f0: 0a000007 beq 3000e714 <pthread_attr_setdetachstate+0x28> <== NOT EXECUTED 3000e6f4: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e6f8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e6fc: 0a000004 beq 3000e714 <pthread_attr_setdetachstate+0x28> <== NOT EXECUTED
return EINVAL;
switch ( detachstate ) {
3000e700: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_CREATE_DETACHED:
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
3000e704: 9580103c strls r1, [r0, #60] ; 0x3c <== NOT EXECUTED
return 0;
3000e708: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( detachstate ) {
3000e70c: 912fff1e bxls lr <== NOT EXECUTED 3000e710: ea000001 b 3000e71c <pthread_attr_setdetachstate+0x30> <== NOT EXECUTED
pthread_attr_t *attr,
int detachstate
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e714: e3a00016 mov r0, #22 <== NOT EXECUTED 3000e718: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
return 0;
default:
return EINVAL;
3000e71c: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000e720: e12fff1e bx lr <== NOT EXECUTED
3000e724 <pthread_attr_setguardsize>:
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
3000e724: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000e728: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
3000e72c: 012fff1e bxeq lr <== NOT EXECUTED 3000e730: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e734: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
attr->guardsize = guardsize;
3000e738: 15801034 strne r1, [r0, #52] ; 0x34 <== NOT EXECUTED
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e73c: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->guardsize = guardsize;
return 0;
3000e740: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000e744: e12fff1e bx lr <== NOT EXECUTED
3001022c <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
3001022c: e3500000 cmp r0, #0
30010230: 0a000008 beq 30010258 <pthread_attr_setinheritsched+0x2c>
30010234: e5903000 ldr r3, [r0] 30010238: e3530000 cmp r3, #0
3001023c: 0a000005 beq 30010258 <pthread_attr_setinheritsched+0x2c>
return EINVAL;
switch ( inheritsched ) {
30010240: e2413001 sub r3, r1, #1 30010244: e3530001 cmp r3, #1
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
30010248: 95801010 strls r1, [r0, #16]
return 0;
3001024c: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( inheritsched ) {
30010250: 912fff1e bxls lr
30010254: ea000001 b 30010260 <pthread_attr_setinheritsched+0x34> <== NOT EXECUTED
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
30010258: e3a00016 mov r0, #22 <== NOT EXECUTED 3001025c: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
return 0;
default:
return ENOTSUP;
30010260: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
30010264: e12fff1e bx lr <== NOT EXECUTED
3000e7cc <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
3000e7cc: e3500000 cmp r0, #0
3000e7d0: 0a00000b beq 3000e804 <pthread_attr_setschedpolicy+0x38>
3000e7d4: e5903000 ldr r3, [r0] 3000e7d8: e3530000 cmp r3, #0
3000e7dc: 0a000008 beq 3000e804 <pthread_attr_setschedpolicy+0x38>
return EINVAL;
switch ( policy ) {
3000e7e0: e3510004 cmp r1, #4
3000e7e4: 8a000008 bhi 3000e80c <pthread_attr_setschedpolicy+0x40>
3000e7e8: e3a03001 mov r3, #1 3000e7ec: e1a03113 lsl r3, r3, r1 3000e7f0: e3130017 tst r3, #23
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
3000e7f4: 15801014 strne r1, [r0, #20]
return 0;
3000e7f8: 13a00000 movne r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
3000e7fc: 112fff1e bxne lr
3000e800: ea000001 b 3000e80c <pthread_attr_setschedpolicy+0x40> <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e804: e3a00016 mov r0, #22 <== NOT EXECUTED 3000e808: e12fff1e bx lr <== NOT EXECUTED
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
3000e80c: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
3000e810: e12fff1e bx lr <== NOT EXECUTED
3000e814 <pthread_attr_setscope>:
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
3000e814: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000e818: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
3000e81c: 012fff1e bxeq lr <== NOT EXECUTED 3000e820: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e824: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e828: 0a000007 beq 3000e84c <pthread_attr_setscope+0x38> <== NOT EXECUTED
return EINVAL;
switch ( contentionscope ) {
3000e82c: e3510000 cmp r1, #0 <== NOT EXECUTED
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
3000e830: 0580100c streq r1, [r0, #12] <== NOT EXECUTED
return 0;
3000e834: 01a00001 moveq r0, r1 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( contentionscope ) {
3000e838: 012fff1e bxeq lr <== NOT EXECUTED
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
default:
return EINVAL;
3000e83c: e3510001 cmp r1, #1 <== NOT EXECUTED 3000e840: 03a00086 moveq r0, #134 ; 0x86 <== NOT EXECUTED 3000e844: 13a00016 movne r0, #22 <== NOT EXECUTED 3000e848: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e84c: e3a00016 mov r0, #22 <== NOT EXECUTED
return ENOTSUP;
default:
return EINVAL;
}
}
3000e850: e12fff1e bx lr <== NOT EXECUTED
3000e878 <pthread_attr_setstack>:
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000e878: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000e87c: 03a00016 moveq r0, #22 <== NOT EXECUTED
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000e880: 012fff1e bxeq lr <== NOT EXECUTED 3000e884: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e888: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e88c: 0a000008 beq 3000e8b4 <pthread_attr_setstack+0x3c> <== NOT EXECUTED
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
3000e890: e59f3024 ldr r3, [pc, #36] ; 3000e8bc <pthread_attr_setstack+0x44><== NOT EXECUTED
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
3000e894: e5801004 str r1, [r0, #4] <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
3000e898: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e89c: e1a03083 lsl r3, r3, #1 <== NOT EXECUTED
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
3000e8a0: e1530002 cmp r3, r2 <== NOT EXECUTED 3000e8a4: 25803008 strcs r3, [r0, #8] <== NOT EXECUTED 3000e8a8: 35802008 strcc r2, [r0, #8] <== NOT EXECUTED
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
3000e8ac: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e8b0: e12fff1e bx lr <== NOT EXECUTED
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e8b4: e3a00016 mov r0, #22 <== NOT EXECUTED
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
}
3000e8b8: e12fff1e bx lr <== NOT EXECUTED
3000e854 <pthread_attr_setstackaddr>:
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
3000e854: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000e858: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
3000e85c: 012fff1e bxeq lr <== NOT EXECUTED 3000e860: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e864: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
attr->stackaddr = stackaddr;
3000e868: 15801004 strne r1, [r0, #4] <== NOT EXECUTED
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e86c: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->stackaddr = stackaddr;
return 0;
3000e870: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000e874: e12fff1e bx lr <== NOT EXECUTED
30010268 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
30010268: e3500000 cmp r0, #0
return EINVAL;
3001026c: 03a00016 moveq r0, #22
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
30010270: 012fff1e bxeq lr 30010274: e5903000 ldr r3, [r0] 30010278: e3530000 cmp r3, #0
3001027c: 0a000007 beq 300102a0 <pthread_attr_setstacksize+0x38>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
30010280: e59f3020 ldr r3, [pc, #32] ; 300102a8 <pthread_attr_setstacksize+0x40> 30010284: e5933000 ldr r3, [r3] 30010288: e1a03083 lsl r3, r3, #1 3001028c: e1510003 cmp r1, r3
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
30010290: 35803008 strcc r3, [r0, #8]
else
attr->stacksize = stacksize;
30010294: 25801008 strcs r1, [r0, #8]
return 0;
30010298: e3a00000 mov r0, #0 3001029c: e12fff1e bx lr
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
300102a0: e3a00016 mov r0, #22 <== NOT EXECUTED
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
return 0;
}
300102a4: e12fff1e bx lr <== NOT EXECUTED
3000a504 <pthread_barrier_destroy>:
)
{
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000a504: e2503000 subs r3, r0, #0
* source of the error.
*/
int pthread_barrier_destroy(
pthread_barrier_t *barrier
)
{
3000a508: e92d4031 push {r0, r4, r5, lr}
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000a50c: 0a000016 beq 3000a56c <pthread_barrier_destroy+0x68>
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
3000a510: e5931000 ldr r1, [r3] 3000a514: e59f0058 ldr r0, [pc, #88] ; 3000a574 <pthread_barrier_destroy+0x70> 3000a518: e1a0200d mov r2, sp 3000a51c: eb00095f bl 3000caa0 <_Objects_Get>
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
3000a520: e59d3000 ldr r3, [sp] 3000a524: e1a04000 mov r4, r0 3000a528: e3530000 cmp r3, #0
3000a52c: 1a00000e bne 3000a56c <pthread_barrier_destroy+0x68>
case OBJECTS_LOCAL:
if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) {
3000a530: e5905058 ldr r5, [r0, #88] ; 0x58 3000a534: e3550000 cmp r5, #0
3000a538: 0a000002 beq 3000a548 <pthread_barrier_destroy+0x44>
_Thread_Enable_dispatch();
3000a53c: eb000cc2 bl 3000d84c <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000a540: e3a00010 mov r0, #16 <== NOT EXECUTED 3000a544: ea000009 b 3000a570 <pthread_barrier_destroy+0x6c> <== NOT EXECUTED
}
_Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object );
3000a548: e59f0024 ldr r0, [pc, #36] ; 3000a574 <pthread_barrier_destroy+0x70> 3000a54c: e1a01004 mov r1, r4 3000a550: eb000850 bl 3000c698 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Barrier_Free (
POSIX_Barrier_Control *the_barrier
)
{
_Objects_Free( &_POSIX_Barrier_Information, &the_barrier->Object );
3000a554: e59f0018 ldr r0, [pc, #24] ; 3000a574 <pthread_barrier_destroy+0x70> 3000a558: e1a01004 mov r1, r4 3000a55c: eb0008fa bl 3000c94c <_Objects_Free>
_POSIX_Barrier_Free( the_barrier );
_Thread_Enable_dispatch();
3000a560: eb000cb9 bl 3000d84c <_Thread_Enable_dispatch>
return 0;
3000a564: e1a00005 mov r0, r5 3000a568: ea000000 b 3000a570 <pthread_barrier_destroy+0x6c>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a56c: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a570: e8bd8038 pop {r3, r4, r5, pc}
3000a578 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
3000a578: e92d40ff push {r0, r1, r2, r3, r4, r5, r6, r7, lr}
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
3000a57c: e2507000 subs r7, r0, #0
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
3000a580: e1a04002 mov r4, r2
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
3000a584: 0a000026 beq 3000a624 <pthread_barrier_init+0xac>
return EINVAL;
if ( count == 0 )
3000a588: e3520000 cmp r2, #0
3000a58c: 0a000024 beq 3000a624 <pthread_barrier_init+0xac>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
3000a590: e3510000 cmp r1, #0
3000a594: 1a000002 bne 3000a5a4 <pthread_barrier_init+0x2c>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
3000a598: e28d0008 add r0, sp, #8 3000a59c: ebffffc3 bl 3000a4b0 <pthread_barrierattr_init>
the_attr = &my_attr;
3000a5a0: e28d1008 add r1, sp, #8
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
3000a5a4: e5913000 ldr r3, [r1] 3000a5a8: e3530000 cmp r3, #0
3000a5ac: 0a00001c beq 3000a624 <pthread_barrier_init+0xac>
return EINVAL;
switch ( the_attr->process_shared ) {
3000a5b0: e5915004 ldr r5, [r1, #4] 3000a5b4: e3550000 cmp r5, #0
3000a5b8: 1a000019 bne 3000a624 <pthread_barrier_init+0xac>
*
* 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;
3000a5bc: e59f306c ldr r3, [pc, #108] ; 3000a630 <pthread_barrier_init+0xb8>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
3000a5c0: e58d5000 str r5, [sp] 3000a5c4: e5932000 ldr r2, [r3]
the_attributes.maximum_count = count;
3000a5c8: e58d4004 str r4, [sp, #4]
++level;
3000a5cc: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000a5d0: e5832000 str r2, [r3]
* This function allocates a barrier control block from
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
3000a5d4: e59f6058 ldr r6, [pc, #88] ; 3000a634 <pthread_barrier_init+0xbc> 3000a5d8: e1a00006 mov r0, r6 3000a5dc: eb00080b bl 3000c610 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
3000a5e0: e2504000 subs r4, r0, #0
3000a5e4: 1a000002 bne 3000a5f4 <pthread_barrier_init+0x7c>
_Thread_Enable_dispatch();
3000a5e8: eb000c97 bl 3000d84c <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000a5ec: e3a0000b mov r0, #11 <== NOT EXECUTED 3000a5f0: ea00000c b 3000a628 <pthread_barrier_init+0xb0> <== NOT EXECUTED
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
3000a5f4: e2840010 add r0, r4, #16 3000a5f8: e1a0100d mov r1, sp 3000a5fc: eb00059a bl 3000bc6c <_CORE_barrier_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a600: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000a604: e5943008 ldr r3, [r4, #8] 3000a608: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a60c: e7824101 str r4, [r2, r1, lsl #2]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000a610: e584500c str r5, [r4, #12]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
3000a614: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
3000a618: eb000c8b bl 3000d84c <_Thread_Enable_dispatch>
return 0;
3000a61c: e1a00005 mov r0, r5 3000a620: ea000000 b 3000a628 <pthread_barrier_init+0xb0>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
3000a624: e3a00016 mov r0, #22 <== NOT EXECUTED
* Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; }
3000a628: e28dd010 add sp, sp, #16
3000a62c: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000a638 <pthread_barrier_wait>:
)
{
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000a638: e2503000 subs r3, r0, #0
*/
int pthread_barrier_wait(
pthread_barrier_t *barrier
)
{
3000a63c: e92d4003 push {r0, r1, lr}
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000a640: 0a000012 beq 3000a690 <pthread_barrier_wait+0x58>
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
3000a644: e5931000 ldr r1, [r3] 3000a648: e28d2004 add r2, sp, #4 3000a64c: e59f0044 ldr r0, [pc, #68] ; 3000a698 <pthread_barrier_wait+0x60> 3000a650: eb000912 bl 3000caa0 <_Objects_Get>
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
3000a654: e59d3004 ldr r3, [sp, #4] 3000a658: e1a02000 mov r2, r0 3000a65c: e3530000 cmp r3, #0
3000a660: 1a00000a bne 3000a690 <pthread_barrier_wait+0x58>
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
3000a664: e58d3000 str r3, [sp] 3000a668: e5921008 ldr r1, [r2, #8] 3000a66c: e2800010 add r0, r0, #16 3000a670: e3a02001 mov r2, #1 3000a674: eb000586 bl 3000bc94 <_CORE_barrier_Wait>
the_barrier->Object.id,
true,
0,
NULL
);
_Thread_Enable_dispatch();
3000a678: eb000c73 bl 3000d84c <_Thread_Enable_dispatch>
return _POSIX_Barrier_Translate_core_barrier_return_code(
_Thread_Executing->Wait.return_code );
3000a67c: e59f3018 ldr r3, [pc, #24] ; 3000a69c <pthread_barrier_wait+0x64> 3000a680: e5933008 ldr r3, [r3, #8]
true,
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_Barrier_Translate_core_barrier_return_code(
3000a684: e5930034 ldr r0, [r3, #52] ; 0x34 3000a688: eb001630 bl 3000ff50 <_POSIX_Barrier_Translate_core_barrier_return_code> 3000a68c: ea000000 b 3000a694 <pthread_barrier_wait+0x5c>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a690: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a694: e8bd800c pop {r2, r3, pc}
3000a464 <pthread_barrierattr_destroy>:
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000a464: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000a468: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000a46c: 012fff1e bxeq lr <== NOT EXECUTED 3000a470: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000a474: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000a478: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a47c: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000a480: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000a484: e12fff1e bx lr <== NOT EXECUTED
3000a488 <pthread_barrierattr_getpshared>:
int pthread_barrierattr_getpshared(
const pthread_barrierattr_t *attr,
int *pshared
)
{
if ( !attr )
3000a488: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000a48c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_barrierattr_getpshared(
const pthread_barrierattr_t *attr,
int *pshared
)
{
if ( !attr )
3000a490: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000a494: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000a498: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000a49c: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000a4a0: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
3000a4a4: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0;
3000a4a8: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000a4ac: e12fff1e bx lr <== NOT EXECUTED
3000a4cc <pthread_barrierattr_setpshared>:
int pthread_barrierattr_setpshared(
pthread_barrierattr_t *attr,
int pshared
)
{
if ( !attr )
3000a4cc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a4d0: 0a000007 beq 3000a4f4 <pthread_barrierattr_setpshared+0x28><== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000a4d4: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000a4d8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a4dc: 0a000004 beq 3000a4f4 <pthread_barrierattr_setpshared+0x28><== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000a4e0: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000a4e4: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000a4e8: 93a00000 movls r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000a4ec: 912fff1e bxls lr <== NOT EXECUTED 3000a4f0: ea000001 b 3000a4fc <pthread_barrierattr_setpshared+0x30> <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000a4f4: e3a00016 mov r0, #22 <== NOT EXECUTED 3000a4f8: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000a4fc: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000a500: e12fff1e bx lr <== NOT EXECUTED
30009b38 <pthread_cancel>:
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
30009b38: e59f3044 ldr r3, [pc, #68] ; 30009b84 <pthread_cancel+0x4c><== NOT EXECUTED
*/
int pthread_cancel(
pthread_t thread
)
{
30009b3c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
30009b40: e5933000 ldr r3, [r3] <== NOT EXECUTED 30009b44: e3530000 cmp r3, #0 <== NOT EXECUTED
return EPROTO;
30009b48: 13a00047 movne r0, #71 ; 0x47 <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
30009b4c: 1a00000b bne 30009b80 <pthread_cancel+0x48> <== NOT EXECUTED
return EPROTO;
the_thread = _Thread_Get( thread, &location );
30009b50: e1a0100d mov r1, sp <== NOT EXECUTED 30009b54: eb000b9f bl 3000c9d8 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30009b58: e59d4000 ldr r4, [sp] <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
30009b5c: e1a03000 mov r3, r0 <== NOT EXECUTED
switch ( location ) {
30009b60: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
30009b64: 13a00016 movne r0, #22 <== NOT EXECUTED
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
30009b68: 1a000004 bne 30009b80 <pthread_cancel+0x48> <== NOT EXECUTED
case OBJECTS_LOCAL:
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
thread_support->cancelation_requested = 1;
30009b6c: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED 30009b70: e3a02001 mov r2, #1 <== NOT EXECUTED 30009b74: e58320e0 str r2, [r3, #224] ; 0xe0 <== NOT EXECUTED
/* This enables dispatch implicitly */
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( the_thread );
30009b78: eb00148d bl 3000edb4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
return 0;
30009b7c: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
30009b80: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000994c <pthread_cleanup_pop>:
*
* 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;
3000994c: e59f2080 ldr r2, [pc, #128] ; 300099d4 <pthread_cleanup_pop+0x88>
POSIX_Cancel_Handler_control tmp_handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30009950: e59f3080 ldr r3, [pc, #128] ; 300099d8 <pthread_cleanup_pop+0x8c> 30009954: e5921000 ldr r1, [r2] 30009958: e5933008 ldr r3, [r3, #8]
++level;
3000995c: e2811001 add r1, r1, #1
*/
void pthread_cleanup_pop(
int execute
)
{
30009960: e92d4070 push {r4, r5, r6, lr}
POSIX_Cancel_Handler_control tmp_handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30009964: e59330f4 ldr r3, [r3, #244] ; 0xf4
_Thread_Dispatch_disable_level = level;
30009968: e5821000 str r1, [r2]
*/
void pthread_cleanup_pop(
int execute
)
{
3000996c: e1a06000 mov r6, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30009970: e10f4000 mrs r4, CPSR 30009974: e3842080 orr r2, r4, #128 ; 0x80 30009978: e129f002 msr CPSR_fc, r2
*/
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
3000997c: e59310e4 ldr r1, [r3, #228] ; 0xe4
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30009980: e28320e8 add r2, r3, #232 ; 0xe8 30009984: e1510002 cmp r1, r2
30009988: 1a000002 bne 30009998 <pthread_cleanup_pop+0x4c>
_Thread_Enable_dispatch();
3000998c: eb000b25 bl 3000c628 <_Thread_Enable_dispatch> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009990: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
30009994: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
_ISR_Enable( level );
return;
}
handler = (POSIX_Cancel_Handler_control *)
30009998: e59300ec ldr r0, [r3, #236] ; 0xec
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000999c: e890000c ldm r0, {r2, r3}
next->previous = previous;
300099a0: e5823004 str r3, [r2, #4]
previous->next = next;
300099a4: e5832000 str r2, [r3] 300099a8: e129f004 msr CPSR_fc, r4
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
tmp_handler = *handler;
300099ac: e5904008 ldr r4, [r0, #8] 300099b0: e590500c ldr r5, [r0, #12]
_Workspace_Free( handler );
300099b4: eb000eee bl 3000d574 <_Workspace_Free>
_Thread_Enable_dispatch();
300099b8: eb000b1a bl 3000c628 <_Thread_Enable_dispatch>
if ( execute )
300099bc: e3560000 cmp r6, #0
300099c0: 08bd8070 popeq {r4, r5, r6, pc}
(*tmp_handler.routine)( tmp_handler.arg );
300099c4: e1a00005 mov r0, r5 <== NOT EXECUTED
300099c8: e1a0e00f mov lr, pc <== NOT EXECUTED
300099cc: e12fff14 bx r4 <== NOT EXECUTED
300099d0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000acd0 <pthread_cond_destroy>:
* P1003.1c/Draft 10, p. 87
*/
int pthread_cond_destroy(
pthread_cond_t *cond
)
{
3000acd0: e92d4031 push {r0, r4, r5, lr}
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000acd4: e1a0100d mov r1, sp 3000acd8: eb000015 bl 3000ad34 <_POSIX_Condition_variables_Get>
switch ( location ) {
3000acdc: e59d3000 ldr r3, [sp]
)
{
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000ace0: e1a04000 mov r4, r0
switch ( location ) {
3000ace4: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ace8: 13a00016 movne r0, #22
{
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
switch ( location ) {
3000acec: 1a00000e bne 3000ad2c <pthread_cond_destroy+0x5c>
case OBJECTS_LOCAL:
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
3000acf0: e2840018 add r0, r4, #24 3000acf4: eb001022 bl 3000ed84 <_Thread_queue_First> 3000acf8: e2505000 subs r5, r0, #0
3000acfc: 0a000002 beq 3000ad0c <pthread_cond_destroy+0x3c>
_Thread_Enable_dispatch();
3000ad00: eb000e5b bl 3000e674 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000ad04: e3a00010 mov r0, #16 <== NOT EXECUTED 3000ad08: ea000007 b 3000ad2c <pthread_cond_destroy+0x5c> <== NOT EXECUTED
}
_Objects_Close(
3000ad0c: e59f001c ldr r0, [pc, #28] ; 3000ad30 <pthread_cond_destroy+0x60> 3000ad10: e1a01004 mov r1, r4 3000ad14: eb0009e9 bl 3000d4c0 <_Objects_Close>
RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free (
POSIX_Condition_variables_Control *the_condition_variable
)
{
_Objects_Free(
3000ad18: e59f0010 ldr r0, [pc, #16] ; 3000ad30 <pthread_cond_destroy+0x60> 3000ad1c: e1a01004 mov r1, r4 3000ad20: eb000a93 bl 3000d774 <_Objects_Free>
&_POSIX_Condition_variables_Information,
&the_cond->Object
);
_POSIX_Condition_variables_Free( the_cond );
_Thread_Enable_dispatch();
3000ad24: eb000e52 bl 3000e674 <_Thread_Enable_dispatch>
return 0;
3000ad28: e1a00005 mov r0, r5
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000ad2c: e8bd8038 pop {r3, r4, r5, pc}
3000ad90 <pthread_cond_init>:
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
3000ad90: e92d40f0 push {r4, r5, r6, r7, lr}
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
3000ad94: e3510000 cmp r1, #0 3000ad98: e59f50a0 ldr r5, [pc, #160] ; 3000ae40 <pthread_cond_init+0xb0> 3000ad9c: 11a05001 movne r5, r1
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000ada0: e5953004 ldr r3, [r5, #4]
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
3000ada4: e1a07000 mov r7, r0
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000ada8: e3530001 cmp r3, #1
return EINVAL;
3000adac: 03a00016 moveq r0, #22
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000adb0: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return EINVAL;
if ( !the_attr->is_initialized )
3000adb4: e5953000 ldr r3, [r5] 3000adb8: e3530000 cmp r3, #0
3000adbc: 0a00001d beq 3000ae38 <pthread_cond_init+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;
3000adc0: e59f307c ldr r3, [pc, #124] ; 3000ae44 <pthread_cond_init+0xb4> 3000adc4: e5932000 ldr r2, [r3]
++level;
3000adc8: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000adcc: e5832000 str r2, [r3]
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
3000add0: e59f6070 ldr r6, [pc, #112] ; 3000ae48 <pthread_cond_init+0xb8> 3000add4: e1a00006 mov r0, r6 3000add8: eb000996 bl 3000d438 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
3000addc: e2504000 subs r4, r0, #0
3000ade0: 1a000002 bne 3000adf0 <pthread_cond_init+0x60>
_Thread_Enable_dispatch();
3000ade4: eb000e22 bl 3000e674 <_Thread_Enable_dispatch>
return ENOMEM;
3000ade8: e3a0000c mov r0, #12
3000adec: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
the_cond->process_shared = the_attr->process_shared;
3000adf0: e5953004 ldr r3, [r5, #4]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
3000adf4: e3a05000 mov r5, #0
_Thread_queue_Initialize(
3000adf8: e2840018 add r0, r4, #24
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
3000adfc: e5843010 str r3, [r4, #16]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
3000ae00: e1a01005 mov r1, r5 3000ae04: e59f2040 ldr r2, [pc, #64] ; 3000ae4c <pthread_cond_init+0xbc> 3000ae08: e3a03074 mov r3, #116 ; 0x74
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
3000ae0c: e5845014 str r5, [r4, #20]
_Thread_queue_Initialize(
3000ae10: eb000ffe bl 3000ee10 <_Thread_queue_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ae14: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000ae18: e5943008 ldr r3, [r4, #8] 3000ae1c: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ae20: e7824101 str r4, [r2, r1, lsl #2]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000ae24: e584500c str r5, [r4, #12]
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
3000ae28: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
3000ae2c: eb000e10 bl 3000e674 <_Thread_Enable_dispatch>
return 0;
3000ae30: e1a00005 mov r0, r5
3000ae34: e8bd80f0 pop {r4, r5, r6, r7, pc}
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
if ( !the_attr->is_initialized )
return EINVAL;
3000ae38: e3a00016 mov r0, #22 <== NOT EXECUTED
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000ae3c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000ae50 <pthread_cond_signal>:
*/
int pthread_cond_signal(
pthread_cond_t *cond
)
{
return _POSIX_Condition_variables_Signal_support( cond, false );
3000ae50: e3a01000 mov r1, #0 <== NOT EXECUTED 3000ae54: eaffffff b 3000ae58 <_POSIX_Condition_variables_Signal_support><== NOT EXECUTED
3000aeac <pthread_cond_timedwait>:
int pthread_cond_timedwait(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
3000aeac: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3000aeb0: e1a05000 mov r5, r0 <== NOT EXECUTED
3000aeb4: e1a04001 mov r4, r1 <== NOT EXECUTED
* is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ already_timedout = false; status = _POSIX_Absolute_timeout_to_ticks(abstime, &ticks);
3000aeb8: e1a00002 mov r0, r2 <== NOT EXECUTED 3000aebc: e1a0100d mov r1, sp <== NOT EXECUTED 3000aec0: eb00011c bl 3000b338 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000aec4: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000aec8: 03a00016 moveq r0, #22 <== NOT EXECUTED
* then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ already_timedout = false; status = _POSIX_Absolute_timeout_to_ticks(abstime, &ticks); if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000aecc: 0a000007 beq 3000aef0 <pthread_cond_timedwait+0x44> <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000aed0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
already_timedout = true;
return _POSIX_Condition_variables_Wait_support(
3000aed4: e3530001 cmp r3, #1 <== NOT EXECUTED 3000aed8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000aedc: e1a01004 mov r1, r4 <== NOT EXECUTED 3000aee0: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000aee4: 83a03000 movhi r3, #0 <== NOT EXECUTED 3000aee8: 93a03001 movls r3, #1 <== NOT EXECUTED 3000aeec: eb000003 bl 3000af00 <_POSIX_Condition_variables_Wait_support><== NOT EXECUTED
cond,
mutex,
ticks,
already_timedout
);
}
3000aef0: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000aef4 <pthread_cond_wait>:
int pthread_cond_wait(
pthread_cond_t *cond,
pthread_mutex_t *mutex
)
{
return _POSIX_Condition_variables_Wait_support(
3000aef4: e3a02000 mov r2, #0 <== NOT EXECUTED 3000aef8: e1a03002 mov r3, r2 <== NOT EXECUTED 3000aefc: eaffffff b 3000af00 <_POSIX_Condition_variables_Wait_support><== NOT EXECUTED
3000ac44 <pthread_condattr_destroy>:
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000ac44: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000ac48: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000ac4c: 012fff1e bxeq lr <== NOT EXECUTED 3000ac50: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000ac54: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000ac58: 13a00000 movne r0, #0 <== NOT EXECUTED 3000ac5c: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000ac60: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000ac64: e12fff1e bx lr <== NOT EXECUTED
3000ac68 <pthread_condattr_getpshared>:
int pthread_condattr_getpshared(
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
3000ac68: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000ac6c: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
return EINVAL;
3000ac70: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
3000ac74: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0;
3000ac78: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000ac7c: e12fff1e bx lr <== NOT EXECUTED
3000ac80 <pthread_condattr_init>:
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
if ( !attr )
3000ac80: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ac84: 0a000004 beq 3000ac9c <pthread_condattr_init+0x1c> <== NOT EXECUTED
return EINVAL;
*attr = _POSIX_Condition_variables_Default_attributes;
3000ac88: e59f3014 ldr r3, [pc, #20] ; 3000aca4 <pthread_condattr_init+0x24><== NOT EXECUTED
3000ac8c: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000ac90: e880000c stm r0, {r2, r3} <== NOT EXECUTED
return 0;
3000ac94: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ac98: e12fff1e bx lr <== NOT EXECUTED
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
if ( !attr )
return EINVAL;
3000ac9c: e3a00016 mov r0, #22 <== NOT EXECUTED
*attr = _POSIX_Condition_variables_Default_attributes;
return 0;
}
3000aca0: e12fff1e bx lr <== NOT EXECUTED
3000aca8 <pthread_condattr_setpshared>:
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
if ( !attr )
3000aca8: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000acac: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
if ( !attr )
3000acb0: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000acb4: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000acb8: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
default:
return EINVAL;
3000acbc: 83a00016 movhi r0, #22 <== NOT EXECUTED
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
3000acc0: 93a00000 movls r0, #0 <== NOT EXECUTED
default:
return EINVAL;
}
}
3000acc4: e12fff1e bx lr <== NOT EXECUTED
3000a244 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
3000a244: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
3000a248: e3520000 cmp r2, #0
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
3000a24c: e24dd04c sub sp, sp, #76 ; 0x4c 3000a250: e58d001c str r0, [sp, #28] 3000a254: e58d3024 str r3, [sp, #36] ; 0x24
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
3000a258: e58d2020 str r2, [sp, #32]
return EFAULT;
3000a25c: 03a0400e moveq r4, #14
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
3000a260: 0a000082 beq 3000a470 <pthread_create+0x22c>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
3000a264: e59f5210 ldr r5, [pc, #528] ; 3000a47c <pthread_create+0x238> 3000a268: e3510000 cmp r1, #0 3000a26c: 11a05001 movne r5, r1
if ( !the_attr->is_initialized )
3000a270: e5953000 ldr r3, [r5] 3000a274: e3530000 cmp r3, #0
3000a278: 0a00007b beq 3000a46c <pthread_create+0x228> * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
3000a27c: e5953004 ldr r3, [r5, #4] 3000a280: e3530000 cmp r3, #0
3000a284: 0a000004 beq 3000a29c <pthread_create+0x58>
3000a288: e59f31f0 ldr r3, [pc, #496] ; 3000a480 <pthread_create+0x23c><== NOT EXECUTED 3000a28c: e5952008 ldr r2, [r5, #8] <== NOT EXECUTED 3000a290: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a294: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a298: 3a000073 bcc 3000a46c <pthread_create+0x228> <== NOT EXECUTED
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
3000a29c: e5953010 ldr r3, [r5, #16] 3000a2a0: e3530001 cmp r3, #1
3000a2a4: 0a000002 beq 3000a2b4 <pthread_create+0x70>
3000a2a8: e3530002 cmp r3, #2
3000a2ac: 1a00006e bne 3000a46c <pthread_create+0x228>
3000a2b0: ea000006 b 3000a2d0 <pthread_create+0x8c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000a2b4: e59f31c8 ldr r3, [pc, #456] ; 3000a484 <pthread_create+0x240>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
3000a2b8: e28dc028 add ip, sp, #40 ; 0x28
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000a2bc: e5933008 ldr r3, [r3, #8] 3000a2c0: e59340f4 ldr r4, [r3, #244] ; 0xf4
schedpolicy = api->schedpolicy;
3000a2c4: e594a084 ldr sl, [r4, #132] ; 0x84
schedparam = api->schedparam;
3000a2c8: e2844088 add r4, r4, #136 ; 0x88 3000a2cc: ea000002 b 3000a2dc <pthread_create+0x98>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
3000a2d0: e595a014 ldr sl, [r5, #20]
schedparam = the_attr->schedparam;
3000a2d4: e28dc028 add ip, sp, #40 ; 0x28
3000a2d8: e2854018 add r4, r5, #24
3000a2dc: e8b4000f ldm r4!, {r0, r1, r2, r3}
3000a2e0: e8ac000f stmia ip!, {r0, r1, r2, r3}
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
3000a2e4: e595300c ldr r3, [r5, #12]
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
3000a2e8: e8940007 ldm r4, {r0, r1, r2}
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
3000a2ec: e3530000 cmp r3, #0
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
3000a2f0: e88c0007 stm ip, {r0, r1, r2}
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
return ENOTSUP;
3000a2f4: 13a04086 movne r4, #134 ; 0x86
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
3000a2f8: 1a00005c bne 3000a470 <pthread_create+0x22c>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
3000a2fc: e59d0028 ldr r0, [sp, #40] ; 0x28 3000a300: eb001773 bl 300100d4 <_POSIX_Priority_Is_valid> 3000a304: e3500000 cmp r0, #0
3000a308: 0a000057 beq 3000a46c <pthread_create+0x228>
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
3000a30c: e28d804c add r8, sp, #76 ; 0x4c 3000a310: e538b024 ldr fp, [r8, #-36]! ; 0x24
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000a314: e59f316c ldr r3, [pc, #364] ; 3000a488 <pthread_create+0x244>
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
3000a318: e1a0000a mov r0, sl 3000a31c: e5d39000 ldrb r9, [r3] 3000a320: e1a01008 mov r1, r8 3000a324: e28d2044 add r2, sp, #68 ; 0x44 3000a328: e28d3048 add r3, sp, #72 ; 0x48 3000a32c: eb001773 bl 30010100 <_POSIX_Thread_Translate_sched_param>
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
3000a330: e2504000 subs r4, r0, #0
3000a334: 1a00004d bne 3000a470 <pthread_create+0x22c>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
3000a338: e59f614c ldr r6, [pc, #332] ; 3000a48c <pthread_create+0x248> 3000a33c: e5960000 ldr r0, [r6] 3000a340: eb0005e5 bl 3000badc <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
3000a344: e59f0144 ldr r0, [pc, #324] ; 3000a490 <pthread_create+0x24c> 3000a348: eb00086f bl 3000c50c <_Objects_Allocate>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
3000a34c: e2507000 subs r7, r0, #0
3000a350: 0a000019 beq 3000a3bc <pthread_create+0x178>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
3000a354: e59d2044 ldr r2, [sp, #68] ; 0x44
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
3000a358: e59f3120 ldr r3, [pc, #288] ; 3000a480 <pthread_create+0x23c>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
3000a35c: e595c008 ldr ip, [r5, #8]
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
3000a360: e5933000 ldr r3, [r3] 3000a364: e06b9009 rsb r9, fp, r9
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
3000a368: e58d200c str r2, [sp, #12] 3000a36c: e59d2048 ldr r2, [sp, #72] ; 0x48 3000a370: e58d9004 str r9, [sp, #4] 3000a374: e3a09001 mov r9, #1 3000a378: e58d4000 str r4, [sp] 3000a37c: e58d9008 str r9, [sp, #8] 3000a380: e58d2010 str r2, [sp, #16] 3000a384: e58d4014 str r4, [sp, #20] 3000a388: e58d4018 str r4, [sp, #24]
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
3000a38c: e1a03083 lsl r3, r3, #1
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
3000a390: e153000c cmp r3, ip 3000a394: 31a0300c movcc r3, ip 3000a398: e59f00f0 ldr r0, [pc, #240] ; 3000a490 <pthread_create+0x24c> 3000a39c: e1a01007 mov r1, r7 3000a3a0: e5952004 ldr r2, [r5, #4] 3000a3a4: eb000d14 bl 3000d7fc <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
3000a3a8: e3500000 cmp r0, #0
3000a3ac: 1a000006 bne 3000a3cc <pthread_create+0x188>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
3000a3b0: e59f00d8 ldr r0, [pc, #216] ; 3000a490 <pthread_create+0x24c> 3000a3b4: e1a01007 mov r1, r7 3000a3b8: eb000922 bl 3000c848 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
3000a3bc: e5960000 ldr r0, [r6] 3000a3c0: eb0005de bl 3000bb40 <_API_Mutex_Unlock>
return EAGAIN;
3000a3c4: e3a0400b mov r4, #11 3000a3c8: ea000028 b 3000a470 <pthread_create+0x22c>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000a3cc: e59760f4 ldr r6, [r7, #244] ; 0xf4
api->Attributes = *the_attr;
3000a3d0: e1a0e005 mov lr, r5
3000a3d4: e1a0c006 mov ip, r6
3000a3d8: e8be000f ldm lr!, {r0, r1, r2, r3}
3000a3dc: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000a3e0: e8be000f ldm lr!, {r0, r1, r2, r3}
3000a3e4: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000a3e8: e8be000f ldm lr!, {r0, r1, r2, r3}
3000a3ec: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000a3f0: e89e000f ldm lr, {r0, r1, r2, r3}
3000a3f4: e88c000f stm ip, {r0, r1, r2, r3}
api->detachstate = the_attr->detachstate;
3000a3f8: e595303c ldr r3, [r5, #60] ; 0x3c
api->schedpolicy = schedpolicy; api->schedparam = schedparam;
3000a3fc: e286c088 add ip, r6, #136 ; 0x88
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
3000a400: e5863040 str r3, [r6, #64] ; 0x40
api->schedpolicy = schedpolicy; api->schedparam = schedparam;
3000a404: e8b8000f ldm r8!, {r0, r1, r2, r3}
3000a408: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000a40c: e8980007 ldm r8, {r0, r1, r2}
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
3000a410: e586a084 str sl, [r6, #132] ; 0x84
api->schedparam = schedparam;
3000a414: e88c0007 stm ip, {r0, r1, r2}
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
3000a418: e59d3024 ldr r3, [sp, #36] ; 0x24 3000a41c: e1a00007 mov r0, r7 3000a420: e1a01009 mov r1, r9 3000a424: e59d2020 ldr r2, [sp, #32] 3000a428: e58d4000 str r4, [sp] 3000a42c: eb000f1d bl 3000e0a8 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
3000a430: e35a0004 cmp sl, #4
3000a434: 1a000005 bne 3000a450 <pthread_create+0x20c>
_Watchdog_Insert_ticks(
3000a438: e2860090 add r0, r6, #144 ; 0x90 <== NOT EXECUTED 3000a43c: eb000f40 bl 3000e144 <_Timespec_To_ticks> <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a440: e28610a8 add r1, r6, #168 ; 0xa8 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a444: e58600b4 str r0, [r6, #180] ; 0xb4 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a448: e59f0044 ldr r0, [pc, #68] ; 3000a494 <pthread_create+0x250><== NOT EXECUTED 3000a44c: eb000fe3 bl 3000e3e0 <_Watchdog_Insert> <== NOT EXECUTED
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
3000a450: e5973008 ldr r3, [r7, #8] 3000a454: e59d201c ldr r2, [sp, #28] 3000a458: e5823000 str r3, [r2]
_RTEMS_Unlock_allocator();
3000a45c: e59f3028 ldr r3, [pc, #40] ; 3000a48c <pthread_create+0x248> 3000a460: e5930000 ldr r0, [r3] 3000a464: eb0005b5 bl 3000bb40 <_API_Mutex_Unlock>
return 0;
3000a468: ea000000 b 3000a470 <pthread_create+0x22c>
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
3000a46c: e3a04016 mov r4, #22 <== NOT EXECUTED
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
3000a470: e1a00004 mov r0, r4
3000a474: e28dd04c add sp, sp, #76 ; 0x4c
3000a478: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000a238 <pthread_detach>:
* 16.1.4 Detaching a Thread, P1003.1c/Draft 10, p. 149
*/
int pthread_detach(
pthread_t thread
)
{
3000a238: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
the_thread = _Thread_Get( thread, &location );
3000a23c: e1a0100d mov r1, sp <== NOT EXECUTED 3000a240: eb000c61 bl 3000d3cc <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000a244: e59d4000 ldr r4, [sp] <== NOT EXECUTED 3000a248: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000a24c: 13a00003 movne r0, #3 <== NOT EXECUTED
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000a250: 1a000003 bne 3000a264 <pthread_detach+0x2c> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->detachstate = PTHREAD_CREATE_DETACHED;
3000a254: e59030f4 ldr r3, [r0, #244] ; 0xf4 <== NOT EXECUTED 3000a258: e5834040 str r4, [r3, #64] ; 0x40 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a25c: eb000c52 bl 3000d3ac <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a260: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
3000a264: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000a498 <pthread_equal>:
break;
}
return status;
#endif
}
3000a498: e0613000 rsb r3, r1, r0 <== NOT EXECUTED 3000a49c: e2730000 rsbs r0, r3, #0 <== NOT EXECUTED 3000a4a0: e0a00003 adc r0, r0, r3 <== NOT EXECUTED 3000a4a4: e12fff1e bx lr <== NOT EXECUTED
30009e48 <pthread_getcpuclockid>:
int pthread_getcpuclockid(
pthread_t pid,
clockid_t *clock_id
)
{
30009e48: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009e4c: eb00206e bl 3001200c <__errno> <== NOT EXECUTED 30009e50: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009e54: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009e58: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009e5c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c894 <pthread_getschedparam>:
{
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000c894: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c898: 13520000 cmpne r2, #0 <== NOT EXECUTED
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
3000c89c: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000c8a0: e1a04002 mov r4, r2 <== NOT EXECUTED 3000c8a4: e1a07001 mov r7, r1 <== NOT EXECUTED
return EINVAL;
3000c8a8: 03a00016 moveq r0, #22 <== NOT EXECUTED
{
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000c8ac: 0a000016 beq 3000c90c <pthread_getschedparam+0x78> <== NOT EXECUTED
return EINVAL;
the_thread = _Thread_Get( thread, &location );
3000c8b0: e1a0100d mov r1, sp <== NOT EXECUTED 3000c8b4: eb000c4d bl 3000f9f0 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000c8b8: e59d5000 ldr r5, [sp] <== NOT EXECUTED
register Thread_Control *the_thread;
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
3000c8bc: e1a0c000 mov ip, r0 <== NOT EXECUTED
switch ( location ) {
3000c8c0: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000c8c4: 13a00003 movne r0, #3 <== NOT EXECUTED
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000c8c8: 1a00000f bne 3000c90c <pthread_getschedparam+0x78> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000c8cc: e59c60f4 ldr r6, [ip, #244] ; 0xf4 <== NOT EXECUTED
if ( policy )
*policy = api->schedpolicy;
if ( param ) {
*param = api->schedparam;
3000c8d0: e1a0e004 mov lr, r4 <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( policy )
*policy = api->schedpolicy;
3000c8d4: e5963084 ldr r3, [r6, #132] ; 0x84 <== NOT EXECUTED
if ( param ) {
*param = api->schedparam;
3000c8d8: e2866088 add r6, r6, #136 ; 0x88 <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( policy )
*policy = api->schedpolicy;
3000c8dc: e5873000 str r3, [r7] <== NOT EXECUTED
if ( param ) {
*param = api->schedparam;
3000c8e0: e8b6000f ldm r6!, {r0, r1, r2, r3} <== NOT EXECUTED
3000c8e4: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000c8e8: e59f3020 ldr r3, [pc, #32] ; 3000c910 <pthread_getschedparam+0x7c><== NOT EXECUTED
3000c8ec: e8960007 ldm r6, {r0, r1, r2} <== NOT EXECUTED
3000c8f0: e88e0007 stm lr, {r0, r1, r2} <== NOT EXECUTED
3000c8f4: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
3000c8f8: e59c3014 ldr r3, [ip, #20] <== NOT EXECUTED
3000c8fc: e0633002 rsb r3, r3, r2 <== NOT EXECUTED
param->sched_priority =
3000c900: e5843000 str r3, [r4] <== NOT EXECUTED
_POSIX_Priority_From_core( the_thread->current_priority );
}
_Thread_Enable_dispatch();
3000c904: eb000c31 bl 3000f9d0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000c908: e1a00005 mov r0, r5 <== NOT EXECUTED
break;
}
return ESRCH;
}
3000c90c: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000ed50 <pthread_join>:
int pthread_join(
pthread_t thread,
void **value_ptr
)
{
3000ed50: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000ed54: e59f60cc ldr r6, [pc, #204] ; 3000ee28 <pthread_join+0xd8> <== NOT EXECUTED
/*
* Put ourself on the threads join list
*/
if ( the_thread->current_state ==
3000ed58: e59f50cc ldr r5, [pc, #204] ; 3000ee2c <pthread_join+0xdc> <== NOT EXECUTED
int pthread_join(
pthread_t thread,
void **value_ptr
)
{
3000ed5c: e1a07000 mov r7, r0 <== NOT EXECUTED 3000ed60: e1a04001 mov r4, r1 <== NOT EXECUTED
POSIX_API_Control *api;
Objects_Locations location;
void *return_pointer;
on_EINTR:
the_thread = _Thread_Get( thread, &location );
3000ed64: e1a0100d mov r1, sp <== NOT EXECUTED 3000ed68: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ed6c: eb000c46 bl 30011e8c <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000ed70: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000ed74: e3510000 cmp r1, #0 <== NOT EXECUTED 3000ed78: 1a000026 bne 3000ee18 <pthread_join+0xc8> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000ed7c: e59020f4 ldr r2, [r0, #244] ; 0xf4 <== NOT EXECUTED
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
3000ed80: e592c040 ldr ip, [r2, #64] ; 0x40 <== NOT EXECUTED 3000ed84: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000ed88: 1a000002 bne 3000ed98 <pthread_join+0x48> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ed8c: eb000c36 bl 30011e6c <_Thread_Enable_dispatch> <== NOT EXECUTED
return EINVAL;
3000ed90: e3a00016 mov r0, #22 <== NOT EXECUTED 3000ed94: ea000022 b 3000ee24 <pthread_join+0xd4> <== NOT EXECUTED 3000ed98: e596c008 ldr ip, [r6, #8] <== NOT EXECUTED
}
if ( _Thread_Is_executing( the_thread ) ) {
3000ed9c: e150000c cmp r0, ip <== NOT EXECUTED 3000eda0: 1a000002 bne 3000edb0 <pthread_join+0x60> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000eda4: eb000c30 bl 30011e6c <_Thread_Enable_dispatch> <== NOT EXECUTED
return EDEADLK;
3000eda8: e3a0002d mov r0, #45 ; 0x2d <== NOT EXECUTED 3000edac: ea00001c b 3000ee24 <pthread_join+0xd4> <== NOT EXECUTED
/*
* Put ourself on the threads join list
*/
if ( the_thread->current_state ==
3000edb0: e590e010 ldr lr, [r0, #16] <== NOT EXECUTED 3000edb4: e15e0005 cmp lr, r5 <== NOT EXECUTED 3000edb8: 1a000004 bne 3000edd0 <pthread_join+0x80> <== NOT EXECUTED
(STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT) ) {
return_pointer = the_thread->Wait.return_argument;
3000edbc: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
_Thread_Clear_state(
3000edc0: e1a01005 mov r1, r5 <== NOT EXECUTED
* Put ourself on the threads join list
*/
if ( the_thread->current_state ==
(STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT) ) {
return_pointer = the_thread->Wait.return_argument;
3000edc4: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
_Thread_Clear_state(
3000edc8: eb000b4c bl 30011b00 <_Thread_Clear_state> <== NOT EXECUTED 3000edcc: ea000006 b 3000edec <pthread_join+0x9c> <== NOT EXECUTED
the_thread,
(STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT)
);
} else {
_Thread_Executing->Wait.return_argument = &return_pointer;
3000edd0: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000edd4: e58c3028 str r3, [ip, #40] ; 0x28 <== 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;
3000edd8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000eddc: e5823074 str r3, [r2, #116] ; 0x74 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &api->Join_List );
_Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT );
3000ede0: e2820044 add r0, r2, #68 ; 0x44 <== NOT EXECUTED 3000ede4: e59f2044 ldr r2, [pc, #68] ; 3000ee30 <pthread_join+0xe0> <== NOT EXECUTED 3000ede8: eb000d4b bl 3001231c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
}
_Thread_Enable_dispatch();
3000edec: eb000c1e bl 30011e6c <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( _Thread_Executing->Wait.return_code == EINTR )
3000edf0: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED 3000edf4: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000edf8: e3530004 cmp r3, #4 <== NOT EXECUTED 3000edfc: 0affffd8 beq 3000ed64 <pthread_join+0x14> <== NOT EXECUTED
goto on_EINTR;
if ( value_ptr )
3000ee00: e3540000 cmp r4, #0 <== NOT EXECUTED
*value_ptr = return_pointer;
3000ee04: 159d3004 ldrne r3, [sp, #4] <== NOT EXECUTED
return 0;
3000ee08: 13a00000 movne r0, #0 <== NOT EXECUTED
if ( _Thread_Executing->Wait.return_code == EINTR )
goto on_EINTR;
if ( value_ptr )
*value_ptr = return_pointer;
3000ee0c: 15843000 strne r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
if ( _Thread_Executing->Wait.return_code == EINTR )
goto on_EINTR;
if ( value_ptr )
3000ee10: 1a000003 bne 3000ee24 <pthread_join+0xd4> <== NOT EXECUTED 3000ee14: ea000001 b 3000ee20 <pthread_join+0xd0> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000ee18: e3a00003 mov r0, #3 <== NOT EXECUTED 3000ee1c: ea000000 b 3000ee24 <pthread_join+0xd4> <== NOT EXECUTED
if ( _Thread_Executing->Wait.return_code == EINTR )
goto on_EINTR;
if ( value_ptr )
*value_ptr = return_pointer;
return 0;
3000ee20: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
3000ee24: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
30009ffc <pthread_key_create>:
*
* 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;
30009ffc: e59f30d8 ldr r3, [pc, #216] ; 3000a0dc <pthread_key_create+0xe0>
*/
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
3000a000: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000a004: e5932000 ldr r2, [r3]
3000a008: e1a09000 mov r9, r0
++level;
3000a00c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000a010: e5832000 str r2, [r3] 3000a014: e1a05001 mov r5, r1
* the inactive chain of free keys control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void )
{
return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information );
3000a018: e59f00c0 ldr r0, [pc, #192] ; 3000a0e0 <pthread_key_create+0xe4> 3000a01c: eb00089e bl 3000c29c <_Objects_Allocate>
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
3000a020: e2504000 subs r4, r0, #0
3000a024: 1a000002 bne 3000a034 <pthread_key_create+0x38>
_Thread_Enable_dispatch();
3000a028: eb000d2a bl 3000d4d8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000a02c: e3a0000b mov r0, #11 <== NOT EXECUTED
3000a030: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
the_key->destructor = destructor;
3000a034: e59f80a8 ldr r8, [pc, #168] ; 3000a0e4 <pthread_key_create+0xe8> 3000a038: e5845010 str r5, [r4, #16]
* This is a bit more complex than one might initially expect because
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
3000a03c: e3a07001 mov r7, #1
if ( !the_key ) {
_Thread_Enable_dispatch();
return EAGAIN;
}
the_key->destructor = destructor;
3000a040: e1a05004 mov r5, r4
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
the_key->Values[ the_api ] = NULL;
3000a044: e3a0a000 mov sl, #0 3000a048: e585a018 str sl, [r5, #24]
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
3000a04c: e5b83004 ldr r3, [r8, #4]!
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
the_key->Values[ the_api ] = NULL;
3000a050: e3a06000 mov r6, #0
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
3000a054: e5933004 ldr r3, [r3, #4] 3000a058: e1d3b1b0 ldrh fp, [r3, #16] 3000a05c: e28bb001 add fp, fp, #1
true,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
3000a060: e1a0b10b lsl fp, fp, #2
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
3000a064: e1a0000b mov r0, fp 3000a068: eb001137 bl 3000e54c <_Workspace_Allocate>
if ( !table ) {
3000a06c: e2503000 subs r3, r0, #0
3000a070: 1a000007 bne 3000a094 <pthread_key_create+0x98>
_POSIX_Keys_Free_memory( the_key );
3000a074: e1a00004 mov r0, r4 3000a078: eb000030 bl 3000a140 <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
3000a07c: e59f005c ldr r0, [pc, #92] ; 3000a0e0 <pthread_key_create+0xe4> 3000a080: e1a01004 mov r1, r4 3000a084: eb000953 bl 3000c5d8 <_Objects_Free>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
3000a088: eb000d12 bl 3000d4d8 <_Thread_Enable_dispatch>
return ENOMEM;
3000a08c: e3a0000c mov r0, #12
3000a090: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
the_key->Values[ the_api ] = table;
3000a094: e5853018 str r3, [r5, #24]
memset( table, '\0', bytes_to_allocate );
3000a098: e1a01006 mov r1, r6 3000a09c: e1a0200b mov r2, fp
* This is a bit more complex than one might initially expect because
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
3000a0a0: e2877001 add r7, r7, #1
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
memset( table, '\0', bytes_to_allocate );
3000a0a4: eb00236b bl 30012e58 <memset>
* This is a bit more complex than one might initially expect because
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
3000a0a8: e3570004 cmp r7, #4 3000a0ac: e2855004 add r5, r5, #4
3000a0b0: 1affffe4 bne 3000a048 <pthread_key_create+0x4c>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a0b4: e59f2024 ldr r2, [pc, #36] ; 3000a0e0 <pthread_key_create+0xe4>
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000a0b8: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a0bc: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000a0c0: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a0c4: e7824101 str r4, [r2, r1, lsl #2]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000a0c8: e584600c str r6, [r4, #12]
the_key->Values[ the_api ] = table;
memset( table, '\0', bytes_to_allocate );
}
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
3000a0cc: e5893000 str r3, [r9]
_Thread_Enable_dispatch();
3000a0d0: eb000d00 bl 3000d4d8 <_Thread_Enable_dispatch>
return 0;
3000a0d4: e1a00006 mov r0, r6
}
3000a0d8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3001cffc <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
3001cffc: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
3001d000: e2517000 subs r7, r1, #0 <== NOT EXECUTED 3001d004: 0a000002 beq 3001d014 <pthread_kill+0x18> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3001d008: e2478001 sub r8, r7, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
3001d00c: e358001f cmp r8, #31 <== NOT EXECUTED 3001d010: 9a000002 bls 3001d020 <pthread_kill+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3001d014: ebffd254 bl 3001196c <__errno> <== NOT EXECUTED 3001d018: e3a03016 mov r3, #22 <== NOT EXECUTED 3001d01c: ea000025 b 3001d0b8 <pthread_kill+0xbc> <== NOT EXECUTED
the_thread = _Thread_Get( thread, &location );
3001d020: e1a0100d mov r1, sp <== NOT EXECUTED 3001d024: ebffbe19 bl 3000c890 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3001d028: e59d6000 ldr r6, [sp] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
3001d02c: e1a04000 mov r4, r0 <== NOT EXECUTED
switch ( location ) {
3001d030: e3560000 cmp r6, #0 <== NOT EXECUTED 3001d034: 1a00001d bne 3001d0b0 <pthread_kill+0xb4> <== NOT EXECUTED 3001d038: e59f0084 ldr r0, [pc, #132] ; 3001d0c4 <pthread_kill+0xc8> <== NOT EXECUTED 3001d03c: ebffb69c bl 3000aab4 <_API_extensions_Add_post_switch> <== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
3001d040: e59f2080 ldr r2, [pc, #128] ; 3001d0c8 <pthread_kill+0xcc> <== NOT EXECUTED 3001d044: e3a0100c mov r1, #12 <== NOT EXECUTED 3001d048: e0222791 mla r2, r1, r7, r2 <== NOT EXECUTED 3001d04c: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED
* If sig == 0 then just validate arguments
*/
_POSIX_signals_Add_post_switch_extension();
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3001d050: e59430f4 ldr r3, [r4, #244] ; 0xf4 <== NOT EXECUTED
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
3001d054: e3520001 cmp r2, #1 <== NOT EXECUTED 3001d058: 1a000002 bne 3001d068 <pthread_kill+0x6c> <== NOT EXECUTED
_Thread_Enable_dispatch();
3001d05c: ebffbe03 bl 3000c870 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3001d060: e1a00006 mov r0, r6 <== NOT EXECUTED 3001d064: ea000015 b 3001d0c0 <pthread_kill+0xc4> <== NOT EXECUTED
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
3001d068: e59320d4 ldr r2, [r3, #212] ; 0xd4 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3001d06c: e3a05001 mov r5, #1 <== NOT EXECUTED 3001d070: e1828815 orr r8, r2, r5, lsl r8 <== NOT EXECUTED
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
3001d074: e1a00004 mov r0, r4 <== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
3001d078: e58380d4 str r8, [r3, #212] ; 0xd4 <== NOT EXECUTED
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
3001d07c: e1a02006 mov r2, r6 <== NOT EXECUTED 3001d080: e1a01007 mov r1, r7 <== NOT EXECUTED 3001d084: ebffff97 bl 3001cee8 <_POSIX_signals_Unblock_thread> <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
3001d088: e59f303c ldr r3, [pc, #60] ; 3001d0cc <pthread_kill+0xd0> <== NOT EXECUTED 3001d08c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3001d090: e3520000 cmp r2, #0 <== NOT EXECUTED 3001d094: 0a000002 beq 3001d0a4 <pthread_kill+0xa8> <== NOT EXECUTED 3001d098: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 3001d09c: e1540002 cmp r4, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3001d0a0: 05c35004 strbeq r5, [r3, #4] <== NOT EXECUTED
}
_Thread_Enable_dispatch();
3001d0a4: ebffbdf1 bl 3000c870 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3001d0a8: e3a00000 mov r0, #0 <== NOT EXECUTED 3001d0ac: ea000003 b 3001d0c0 <pthread_kill+0xc4> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
3001d0b0: ebffd22d bl 3001196c <__errno> <== NOT EXECUTED 3001d0b4: e3a03003 mov r3, #3 <== NOT EXECUTED 3001d0b8: e5803000 str r3, [r0] <== NOT EXECUTED 3001d0bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3001d0c0: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000bff0 <pthread_mutex_destroy>:
*/
int pthread_mutex_destroy(
pthread_mutex_t *mutex
)
{
3000bff0: e92d4031 push {r0, r4, r5, lr}
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000bff4: e1a0100d mov r1, sp 3000bff8: eb000018 bl 3000c060 <_POSIX_Mutex_Get>
switch ( location ) {
3000bffc: e59d5000 ldr r5, [sp]
)
{
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000c000: e1a04000 mov r4, r0
switch ( location ) {
3000c004: e3550000 cmp r5, #0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000c008: 13a00016 movne r0, #22
{
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
switch ( location ) {
3000c00c: 1a000011 bne 3000c058 <pthread_mutex_destroy+0x68>
/*
* XXX: There is an error for the mutex being locked
* or being in use by a condition variable.
*/
if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) {
3000c010: e5943064 ldr r3, [r4, #100] ; 0x64 3000c014: e3530000 cmp r3, #0
3000c018: 1a000002 bne 3000c028 <pthread_mutex_destroy+0x38>
_Thread_Enable_dispatch();
3000c01c: eb000e6b bl 3000f9d0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000c020: e3a00010 mov r0, #16 <== NOT EXECUTED 3000c024: ea00000b b 3000c058 <pthread_mutex_destroy+0x68> <== NOT EXECUTED
}
_Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object );
3000c028: e59f002c ldr r0, [pc, #44] ; 3000c05c <pthread_mutex_destroy+0x6c> 3000c02c: e1a01004 mov r1, r4 3000c030: eb0009f9 bl 3000e81c <_Objects_Close>
_CORE_mutex_Flush( &the_mutex->Mutex, NULL, EINVAL );
3000c034: e3a02016 mov r2, #22 3000c038: e2840014 add r0, r4, #20 3000c03c: e1a01005 mov r1, r5 3000c040: eb00076a bl 3000ddf0 <_CORE_mutex_Flush>
RTEMS_INLINE_ROUTINE void _POSIX_Mutex_Free (
POSIX_Mutex_Control *the_mutex
)
{
_Objects_Free( &_POSIX_Mutex_Information, &the_mutex->Object );
3000c044: e59f0010 ldr r0, [pc, #16] ; 3000c05c <pthread_mutex_destroy+0x6c> 3000c048: e1a01004 mov r1, r4 3000c04c: eb000a9f bl 3000ead0 <_Objects_Free>
_POSIX_Mutex_Free( the_mutex );
_Thread_Enable_dispatch();
3000c050: eb000e5e bl 3000f9d0 <_Thread_Enable_dispatch>
return 0;
3000c054: e1a00005 mov r0, r5
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000c058: e8bd8038 pop {r3, r4, r5, pc}
3000c16c <pthread_mutex_init>:
CORE_mutex_Attributes *the_mutex_attr;
const pthread_mutexattr_t *the_attr;
CORE_mutex_Disciplines the_discipline;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Mutex_Default_attributes;
3000c16c: e59f312c ldr r3, [pc, #300] ; 3000c2a0 <pthread_mutex_init+0x134> 3000c170: e3510000 cmp r1, #0
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
3000c174: e92d41f0 push {r4, r5, r6, r7, r8, lr}
CORE_mutex_Attributes *the_mutex_attr;
const pthread_mutexattr_t *the_attr;
CORE_mutex_Disciplines the_discipline;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Mutex_Default_attributes;
3000c178: 11a07001 movne r7, r1 3000c17c: 01a07003 moveq r7, r3
/* Check for NULL mutex */
if ( !mutex )
3000c180: e2506000 subs r6, r0, #0
3000c184: 0a000041 beq 3000c290 <pthread_mutex_init+0x124>
}
}
}
#endif
if ( !the_attr->is_initialized )
3000c188: e5973000 ldr r3, [r7] 3000c18c: e3530000 cmp r3, #0
3000c190: 0a00003e beq 3000c290 <pthread_mutex_init+0x124>
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000c194: e5973004 ldr r3, [r7, #4] 3000c198: e3530001 cmp r3, #1
return ENOSYS;
3000c19c: 03a00058 moveq r0, #88 ; 0x58
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000c1a0: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return ENOSYS;
if ( the_attr->process_shared != PTHREAD_PROCESS_PRIVATE )
3000c1a4: e3530000 cmp r3, #0
3000c1a8: 1a000038 bne 3000c290 <pthread_mutex_init+0x124>
return EINVAL;
/*
* Determine the discipline of the mutex
*/
switch ( the_attr->protocol ) {
3000c1ac: e597800c ldr r8, [r7, #12] 3000c1b0: e3580001 cmp r8, #1
3000c1b4: 0a000006 beq 3000c1d4 <pthread_mutex_init+0x68>
3000c1b8: e3580002 cmp r8, #2
3000c1bc: 0a000002 beq 3000c1cc <pthread_mutex_init+0x60>
3000c1c0: e3580000 cmp r8, #0
3000c1c4: 1a000031 bne 3000c290 <pthread_mutex_init+0x124>
3000c1c8: ea000002 b 3000c1d8 <pthread_mutex_init+0x6c>
break;
case PTHREAD_PRIO_INHERIT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
break;
case PTHREAD_PRIO_PROTECT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
3000c1cc: e3a08003 mov r8, #3 <== NOT EXECUTED
break;
3000c1d0: ea000000 b 3000c1d8 <pthread_mutex_init+0x6c> <== NOT EXECUTED
switch ( the_attr->protocol ) {
case PTHREAD_PRIO_NONE:
the_discipline = CORE_MUTEX_DISCIPLINES_FIFO;
break;
case PTHREAD_PRIO_INHERIT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
3000c1d4: e3a08002 mov r8, #2 <== NOT EXECUTED
}
/*
* Validate the priority ceiling field -- should always be valid.
*/
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
3000c1d8: e5970008 ldr r0, [r7, #8] 3000c1dc: eb0000cf bl 3000c520 <_POSIX_Priority_Is_valid> 3000c1e0: e3500000 cmp r0, #0
3000c1e4: 0a000029 beq 3000c290 <pthread_mutex_init+0x124>
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
/*
* Validate the mutex type and set appropriate SuperCore mutex
* attributes.
*/
switch ( the_attr->type ) {
3000c1e8: e5973010 ldr r3, [r7, #16] 3000c1ec: e3530003 cmp r3, #3
3000c1f0: 8a000028 bhi 3000c298 <pthread_mutex_init+0x12c>
*
* 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;
3000c1f4: e59f30a8 ldr r3, [pc, #168] ; 3000c2a4 <pthread_mutex_init+0x138> 3000c1f8: e5932000 ldr r2, [r3]
++level;
3000c1fc: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000c200: e5832000 str r2, [r3]
* _POSIX_Mutex_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void )
{
return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information );
3000c204: e59f509c ldr r5, [pc, #156] ; 3000c2a8 <pthread_mutex_init+0x13c> 3000c208: e1a00005 mov r0, r5 3000c20c: eb000960 bl 3000e794 <_Objects_Allocate>
*/
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
3000c210: e2504000 subs r4, r0, #0
3000c214: 1a000002 bne 3000c224 <pthread_mutex_init+0xb8>
_Thread_Enable_dispatch();
3000c218: eb000dec bl 3000f9d0 <_Thread_Enable_dispatch>
return EAGAIN;
3000c21c: e3a0000b mov r0, #11
3000c220: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
}
the_mutex->process_shared = the_attr->process_shared;
3000c224: e5973004 ldr r3, [r7, #4]
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
3000c228: e3a02001 mov r2, #1
if ( !the_mutex ) {
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
3000c22c: e5843010 str r3, [r4, #16]
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000c230: e5973014 ldr r3, [r7, #20]
the_mutex_attr->discipline = the_discipline;
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
3000c234: e2840014 add r0, r4, #20
the_mutex->process_shared = the_attr->process_shared;
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000c238: e2733001 rsbs r3, r3, #1 3000c23c: 33a03000 movcc r3, #0
if ( !the_mutex ) {
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
3000c240: e5843054 str r3, [r4, #84] ; 0x54
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000c244: e59f3060 ldr r3, [pc, #96] ; 3000c2ac <pthread_mutex_init+0x140>
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
3000c248: e5c42058 strb r2, [r4, #88] ; 0x58 3000c24c: e5d31000 ldrb r1, [r3] 3000c250: e5973008 ldr r3, [r7, #8]
the_mutex_attr->priority_ceiling =
_POSIX_Priority_To_core( the_attr->prio_ceiling );
the_mutex_attr->discipline = the_discipline;
3000c254: e584805c str r8, [r4, #92] ; 0x5c 3000c258: e0633001 rsb r3, r3, r1
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
the_mutex_attr->priority_ceiling =
3000c25c: e5843060 str r3, [r4, #96] ; 0x60
the_mutex_attr->discipline = the_discipline;
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
3000c260: e2841054 add r1, r4, #84 ; 0x54 3000c264: eb0006e2 bl 3000ddf4 <_CORE_mutex_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000c268: e595201c ldr r2, [r5, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000c26c: e5943008 ldr r3, [r4, #8] 3000c270: e1d410b8 ldrh r1, [r4, #8]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000c274: e3a05000 mov r5, #0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000c278: e7824101 str r4, [r2, r1, lsl #2]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000c27c: e584500c str r5, [r4, #12]
CORE_MUTEX_UNLOCKED
);
_Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 );
*mutex = the_mutex->Object.id;
3000c280: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
3000c284: eb000dd1 bl 3000f9d0 <_Thread_Enable_dispatch>
return 0;
3000c288: e1a00005 mov r0, r5
3000c28c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
/*
* Validate the priority ceiling field -- should always be valid.
*/
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
return EINVAL;
3000c290: e3a00016 mov r0, #22 <== NOT EXECUTED
3000c294: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
break;
default:
return EINVAL;
3000c298: e3a00016 mov r0, #22 <== NOT EXECUTED
*mutex = the_mutex->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000c29c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c31c <pthread_mutex_setprioceiling>:
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
3000c31c: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
Priority_Control the_priority;
if ( !old_ceiling )
3000c320: e2528000 subs r8, r2, #0
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
3000c324: e1a04000 mov r4, r0 3000c328: e1a05001 mov r5, r1
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
Priority_Control the_priority;
if ( !old_ceiling )
3000c32c: 0a00001b beq 3000c3a0 <pthread_mutex_setprioceiling+0x84>
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000c330: e1a00001 mov r0, r1 3000c334: eb000079 bl 3000c520 <_POSIX_Priority_Is_valid> 3000c338: e3500000 cmp r0, #0
3000c33c: 0a000017 beq 3000c3a0 <pthread_mutex_setprioceiling+0x84>
3000c340: e59f6060 ldr r6, [pc, #96] ; 3000c3a8 <pthread_mutex_setprioceiling+0x8c>
/*
* Must acquire the mutex before we can change it's ceiling.
* POSIX says block until we acquire it.
*/
(void) pthread_mutex_lock( mutex );
3000c344: e1a00004 mov r0, r4 3000c348: e5d67000 ldrb r7, [r6] 3000c34c: ebffffd7 bl 3000c2b0 <pthread_mutex_lock>
* operations. * * NOTE: This makes it easier to get 100% binary coverage since the * bad Id case is handled by the switch. */ the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000c350: e1a00004 mov r0, r4 3000c354: e1a0100d mov r1, sp 3000c358: ebffff40 bl 3000c060 <_POSIX_Mutex_Get>
switch ( location ) {
3000c35c: e59d4000 ldr r4, [sp]
* operations. * * NOTE: This makes it easier to get 100% binary coverage since the * bad Id case is handled by the switch. */ the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000c360: e1a03000 mov r3, r0
switch ( location ) {
3000c364: e3540000 cmp r4, #0
3000c368: 1a00000c bne 3000c3a0 <pthread_mutex_setprioceiling+0x84>
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000c36c: e5902060 ldr r2, [r0, #96] ; 0x60 3000c370: e5d61000 ldrb r1, [r6]
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000c374: e0655007 rsb r5, r5, r7
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000c378: e0622001 rsb r2, r2, r1
case OBJECTS_LOCAL:
*old_ceiling = _POSIX_Priority_From_core(
3000c37c: e5882000 str r2, [r8]
);
the_mutex->Mutex.Attributes.priority_ceiling = the_priority;
/*
* We are required to unlock the mutex before we return.
*/
_CORE_mutex_Surrender(
3000c380: e5931008 ldr r1, [r3, #8]
case OBJECTS_LOCAL:
*old_ceiling = _POSIX_Priority_From_core(
the_mutex->Mutex.Attributes.priority_ceiling
);
the_mutex->Mutex.Attributes.priority_ceiling = the_priority;
3000c384: e5805060 str r5, [r0, #96] ; 0x60
/*
* We are required to unlock the mutex before we return.
*/
_CORE_mutex_Surrender(
3000c388: e1a02004 mov r2, r4 3000c38c: e2800014 add r0, r0, #20 3000c390: eb000718 bl 3000dff8 <_CORE_mutex_Surrender>
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
3000c394: eb000d8d bl 3000f9d0 <_Thread_Enable_dispatch>
return 0;
3000c398: e1a00004 mov r0, r4 3000c39c: ea000000 b 3000c3a4 <pthread_mutex_setprioceiling+0x88>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000c3a0: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000c3a4: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc}
3000c3ac <pthread_mutex_timedlock>:
*/
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
3000c3ac: e92d4071 push {r0, r4, r5, r6, lr}
3000c3b0: e1a06000 mov r6, r0
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000c3b4: e1a00001 mov r0, r1 3000c3b8: e1a0100d mov r1, sp 3000c3bc: eb00002a bl 3000c46c <_POSIX_Absolute_timeout_to_ticks>
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
3000c3c0: e2403003 sub r3, r0, #3 3000c3c4: e2735000 rsbs r5, r3, #0 3000c3c8: e0a55003 adc r5, r5, r3 3000c3cc: e1a04000 mov r4, r0
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
3000c3d0: e1a01005 mov r1, r5 3000c3d4: e1a00006 mov r0, r6 3000c3d8: e59d2000 ldr r2, [sp] 3000c3dc: ebffffb6 bl 3000c2bc <_POSIX_Mutex_Lock_support>
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
3000c3e0: e3550000 cmp r5, #0
3000c3e4: 1a000008 bne 3000c40c <pthread_mutex_timedlock+0x60>
3000c3e8: e3500010 cmp r0, #16
3000c3ec: 1a000006 bne 3000c40c <pthread_mutex_timedlock+0x60>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000c3f0: e3540000 cmp r4, #0 <== NOT EXECUTED
return EINVAL;
3000c3f4: 03a00016 moveq r0, #22 <== NOT EXECUTED
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000c3f8: 0a000003 beq 3000c40c <pthread_mutex_timedlock+0x60> <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000c3fc: e2444001 sub r4, r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
3000c400: e3540001 cmp r4, #1 <== NOT EXECUTED 3000c404: 83a00010 movhi r0, #16 <== NOT EXECUTED 3000c408: 93a00074 movls r0, #116 ; 0x74 <== NOT EXECUTED
}
return lock_status;
}
3000c40c: e8bd8078 pop {r3, r4, r5, r6, pc}
3000be58 <pthread_mutexattr_destroy>:
*/
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000be58: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000be5c: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000be60: 012fff1e bxeq lr <== NOT EXECUTED 3000be64: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000be68: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000be6c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000be70: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000be74: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000be78: e12fff1e bx lr <== NOT EXECUTED
3000be7c <pthread_mutexattr_getprioceiling>:
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000be7c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000be80: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000be84: 012fff1e bxeq lr <== NOT EXECUTED 3000be88: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000be8c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000be90: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*prioceiling = attr->prio_ceiling;
3000be94: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000be98: 13a00000 movne r0, #0 <== NOT EXECUTED 3000be9c: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*prioceiling = attr->prio_ceiling;
3000bea0: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
return EINVAL;
3000bea4: 03a00016 moveq r0, #22 <== NOT EXECUTED
*prioceiling = attr->prio_ceiling;
return 0;
}
3000bea8: e12fff1e bx lr <== NOT EXECUTED
3000beac <pthread_mutexattr_getprotocol>:
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000beac: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000beb0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000beb4: 012fff1e bxeq lr <== NOT EXECUTED 3000beb8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000bebc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bec0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*protocol = attr->protocol;
3000bec4: 1593300c ldrne r3, [r3, #12] <== NOT EXECUTED
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000bec8: 13a00000 movne r0, #0 <== NOT EXECUTED 3000becc: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*protocol = attr->protocol;
3000bed0: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
return EINVAL;
3000bed4: 03a00016 moveq r0, #22 <== NOT EXECUTED
*protocol = attr->protocol;
return 0;
}
3000bed8: e12fff1e bx lr <== NOT EXECUTED
3000bedc <pthread_mutexattr_getpshared>:
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000bedc: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000bee0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000bee4: 012fff1e bxeq lr <== NOT EXECUTED 3000bee8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000beec: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bef0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000bef4: 15933004 ldrne r3, [r3, #4] <== NOT EXECUTED
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000bef8: 13a00000 movne r0, #0 <== NOT EXECUTED 3000befc: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000bf00: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
return EINVAL;
3000bf04: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
}
3000bf08: e12fff1e bx lr <== NOT EXECUTED
30009c70 <pthread_mutexattr_gettype>:
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
if ( !attr )
30009c70: e3500000 cmp r0, #0
30009c74: 0a000008 beq 30009c9c <pthread_mutexattr_gettype+0x2c>
return EINVAL;
if ( !attr->is_initialized )
30009c78: e5903000 ldr r3, [r0] 30009c7c: e3530000 cmp r3, #0
30009c80: 0a000005 beq 30009c9c <pthread_mutexattr_gettype+0x2c>
return EINVAL;
if ( !type )
30009c84: e3510000 cmp r1, #0
return EINVAL;
*type = attr->type;
30009c88: 15903010 ldrne r3, [r0, #16]
return 0;
30009c8c: 13a00000 movne r0, #0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
30009c90: 15813000 strne r3, [r1]
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
if ( !type )
30009c94: 112fff1e bxne lr
30009c98: ea000001 b 30009ca4 <pthread_mutexattr_gettype+0x34> <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
30009c9c: e3a00016 mov r0, #22 30009ca0: e12fff1e bx lr
if ( !type )
return EINVAL;
30009ca4: e3a00016 mov r0, #22 <== NOT EXECUTED
*type = attr->type;
return 0;
}
30009ca8: e12fff1e bx lr <== NOT EXECUTED
3000bf38 <pthread_mutexattr_setprioceiling>:
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
3000bf38: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !attr || !attr->is_initialized )
3000bf3c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
3000bf40: e1a05001 mov r5, r1 <== NOT EXECUTED
if ( !attr || !attr->is_initialized )
3000bf44: 0a000009 beq 3000bf70 <pthread_mutexattr_setprioceiling+0x38><== NOT EXECUTED 3000bf48: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000bf4c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf50: 0a000006 beq 3000bf70 <pthread_mutexattr_setprioceiling+0x38><== NOT EXECUTED
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000bf54: e1a00001 mov r0, r1 <== NOT EXECUTED 3000bf58: eb000170 bl 3000c520 <_POSIX_Priority_Is_valid> <== NOT EXECUTED 3000bf5c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
attr->prio_ceiling = prioceiling;
3000bf60: 15845008 strne r5, [r4, #8] <== NOT EXECUTED
return 0;
3000bf64: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000bf68: 0a000002 beq 3000bf78 <pthread_mutexattr_setprioceiling+0x40><== NOT EXECUTED
3000bf6c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
pthread_mutexattr_t *attr,
int prioceiling
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000bf70: e3a00016 mov r0, #22 <== NOT EXECUTED
3000bf74: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
return EINVAL;
3000bf78: e3a00016 mov r0, #22 <== NOT EXECUTED
attr->prio_ceiling = prioceiling;
return 0;
}
3000bf7c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000bf80 <pthread_mutexattr_setprotocol>:
int pthread_mutexattr_setprotocol(
pthread_mutexattr_t *attr,
int protocol
)
{
if ( !attr || !attr->is_initialized )
3000bf80: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bf84: 0a000007 beq 3000bfa8 <pthread_mutexattr_setprotocol+0x28> <== NOT EXECUTED 3000bf88: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000bf8c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf90: 0a000004 beq 3000bfa8 <pthread_mutexattr_setprotocol+0x28> <== NOT EXECUTED
return EINVAL;
switch ( protocol ) {
3000bf94: e3510002 cmp r1, #2 <== NOT EXECUTED
case PTHREAD_PRIO_NONE:
case PTHREAD_PRIO_INHERIT:
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
3000bf98: 9580100c strls r1, [r0, #12] <== NOT EXECUTED
return 0;
3000bf9c: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( protocol ) {
3000bfa0: 912fff1e bxls lr <== NOT EXECUTED 3000bfa4: ea000001 b 3000bfb0 <pthread_mutexattr_setprotocol+0x30> <== NOT EXECUTED
pthread_mutexattr_t *attr,
int protocol
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000bfa8: e3a00016 mov r0, #22 <== NOT EXECUTED 3000bfac: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
return 0;
default:
return EINVAL;
3000bfb0: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000bfb4: e12fff1e bx lr <== NOT EXECUTED
3000bfb8 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
3000bfb8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bfbc: 0a000007 beq 3000bfe0 <pthread_mutexattr_setpshared+0x28> <== NOT EXECUTED 3000bfc0: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000bfc4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bfc8: 0a000004 beq 3000bfe0 <pthread_mutexattr_setpshared+0x28> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000bfcc: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000bfd0: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000bfd4: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000bfd8: 912fff1e bxls lr <== NOT EXECUTED 3000bfdc: ea000001 b 3000bfe8 <pthread_mutexattr_setpshared+0x30> <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000bfe0: e3a00016 mov r0, #22 <== NOT EXECUTED 3000bfe4: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000bfe8: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000bfec: e12fff1e bx lr <== NOT EXECUTED
3000a8e0 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
3000a8e0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a8e4: 13510000 cmpne r1, #0 <== NOT EXECUTED
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
3000a8e8: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
if ( !once_control || !init_routine )
3000a8ec: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a8f0: e1a05001 mov r5, r1 <== NOT EXECUTED 3000a8f4: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a8f8: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
3000a8fc: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
3000a900: 0a000012 beq 3000a950 <pthread_once+0x70> <== NOT EXECUTED
return EINVAL;
if ( !once_control->init_executed ) {
3000a904: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000a908: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a90c: 1a00000f bne 3000a950 <pthread_once+0x70> <== NOT EXECUTED
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
3000a910: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED 3000a914: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a918: e1a0200d mov r2, sp <== NOT EXECUTED 3000a91c: eb0002d6 bl 3000b47c <rtems_task_mode> <== NOT EXECUTED
if ( !once_control->init_executed ) {
3000a920: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000a924: e3530000 cmp r3, #0 <== NOT EXECUTED
once_control->is_initialized = true;
3000a928: 03a03001 moveq r3, #1 <== NOT EXECUTED 3000a92c: 05843000 streq r3, [r4] <== NOT EXECUTED
once_control->init_executed = true;
3000a930: 05843004 streq r3, [r4, #4] <== NOT EXECUTED
(*init_routine)();
3000a934: 01a0e00f moveq lr, pc <== NOT EXECUTED 3000a938: 012fff15 bxeq r5 <== NOT EXECUTED
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
3000a93c: e59d0000 ldr r0, [sp] <== NOT EXECUTED 3000a940: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 3000a944: e1a0200d mov r2, sp <== NOT EXECUTED 3000a948: eb0002cb bl 3000b47c <rtems_task_mode> <== NOT EXECUTED
} return 0;
3000a94c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000a950: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000b288 <pthread_rwlock_destroy>:
)
{
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
3000b288: e2503000 subs r3, r0, #0
* source of the error.
*/
int pthread_rwlock_destroy(
pthread_rwlock_t *rwlock
)
{
3000b28c: e92d4031 push {r0, r4, r5, lr}
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
3000b290: 0a000017 beq 3000b2f4 <pthread_rwlock_destroy+0x6c>
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
3000b294: e5931000 ldr r1, [r3] 3000b298: e59f005c ldr r0, [pc, #92] ; 3000b2fc <pthread_rwlock_destroy+0x74> 3000b29c: e1a0200d mov r2, sp 3000b2a0: eb000ada bl 3000de10 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b2a4: e59d3000 ldr r3, [sp] 3000b2a8: e1a04000 mov r4, r0 3000b2ac: e3530000 cmp r3, #0
3000b2b0: 1a00000f bne 3000b2f4 <pthread_rwlock_destroy+0x6c>
case OBJECTS_LOCAL:
/*
* If there is at least one thread waiting, then do not delete it.
*/
if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) {
3000b2b4: e2800010 add r0, r0, #16 3000b2b8: eb00103e bl 3000f3b8 <_Thread_queue_First> 3000b2bc: e2505000 subs r5, r0, #0
3000b2c0: 0a000002 beq 3000b2d0 <pthread_rwlock_destroy+0x48>
_Thread_Enable_dispatch();
3000b2c4: eb000e3c bl 3000ebbc <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000b2c8: e3a00010 mov r0, #16 <== NOT EXECUTED 3000b2cc: ea000009 b 3000b2f8 <pthread_rwlock_destroy+0x70> <== NOT EXECUTED
/*
* POSIX doesn't require behavior when it is locked.
*/
_Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object );
3000b2d0: e59f0024 ldr r0, [pc, #36] ; 3000b2fc <pthread_rwlock_destroy+0x74> 3000b2d4: e1a01004 mov r1, r4 3000b2d8: eb0009ca bl 3000da08 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free (
POSIX_RWLock_Control *the_RWLock
)
{
_Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object );
3000b2dc: e59f0018 ldr r0, [pc, #24] ; 3000b2fc <pthread_rwlock_destroy+0x74> 3000b2e0: e1a01004 mov r1, r4 3000b2e4: eb000a74 bl 3000dcbc <_Objects_Free>
_POSIX_RWLock_Free( the_rwlock );
_Thread_Enable_dispatch();
3000b2e8: eb000e33 bl 3000ebbc <_Thread_Enable_dispatch>
return 0;
3000b2ec: e1a00005 mov r0, r5 3000b2f0: ea000000 b 3000b2f8 <pthread_rwlock_destroy+0x70>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b2f4: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b2f8: e8bd8038 pop {r3, r4, r5, pc}
3000a848 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
3000a848: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr}
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
3000a84c: e2507000 subs r7, r0, #0
3000a850: 0a000023 beq 3000a8e4 <pthread_rwlock_init+0x9c>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
3000a854: e3510000 cmp r1, #0
3000a858: 1a000002 bne 3000a868 <pthread_rwlock_init+0x20>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
3000a85c: e1a0000d mov r0, sp <== NOT EXECUTED 3000a860: eb0001b3 bl 3000af34 <pthread_rwlockattr_init> <== NOT EXECUTED
the_attr = &default_attr;
3000a864: e1a0100d mov r1, sp <== NOT EXECUTED
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
3000a868: e5913000 ldr r3, [r1] 3000a86c: e3530000 cmp r3, #0
3000a870: 0a00001b beq 3000a8e4 <pthread_rwlock_init+0x9c>
return EINVAL;
switch ( the_attr->process_shared ) {
3000a874: e5915004 ldr r5, [r1, #4] 3000a878: e3550000 cmp r5, #0
3000a87c: 1a000018 bne 3000a8e4 <pthread_rwlock_init+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;
3000a880: e59f3064 ldr r3, [pc, #100] ; 3000a8ec <pthread_rwlock_init+0xa4>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
3000a884: e58d5008 str r5, [sp, #8] 3000a888: e5932000 ldr r2, [r3]
++level;
3000a88c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000a890: e5832000 str r2, [r3]
* This function allocates a RWLock control block from
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
3000a894: e59f6054 ldr r6, [pc, #84] ; 3000a8f0 <pthread_rwlock_init+0xa8> 3000a898: e1a00006 mov r0, r6 3000a89c: eb000a0b bl 3000d0d0 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
3000a8a0: e2504000 subs r4, r0, #0
3000a8a4: 1a000002 bne 3000a8b4 <pthread_rwlock_init+0x6c>
_Thread_Enable_dispatch();
3000a8a8: eb000ece bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000a8ac: e3a0000b mov r0, #11 <== NOT EXECUTED 3000a8b0: ea00000c b 3000a8e8 <pthread_rwlock_init+0xa0> <== NOT EXECUTED
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
3000a8b4: e2840010 add r0, r4, #16 3000a8b8: e28d1008 add r1, sp, #8 3000a8bc: eb00087b bl 3000cab0 <_CORE_RWLock_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a8c0: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000a8c4: e5943008 ldr r3, [r4, #8] 3000a8c8: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a8cc: e7824101 str r4, [r2, r1, lsl #2]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000a8d0: e584500c str r5, [r4, #12]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
3000a8d4: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
3000a8d8: eb000ec2 bl 3000e3e8 <_Thread_Enable_dispatch>
return 0;
3000a8dc: e1a00005 mov r0, r5 3000a8e0: ea000000 b 3000a8e8 <pthread_rwlock_init+0xa0>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
3000a8e4: e3a00016 mov r0, #22 <== NOT EXECUTED
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000a8e8: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc}
3000b3ac <pthread_rwlock_rdlock>:
*/
int pthread_rwlock_rdlock(
pthread_rwlock_t *rwlock
)
{
3000b3ac: e92d4013 push {r0, r1, r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b3b0: e2504000 subs r4, r0, #0
3000b3b4: 0a000011 beq 3000b400 <pthread_rwlock_rdlock+0x54>
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
3000b3b8: e59f0048 ldr r0, [pc, #72] ; 3000b408 <pthread_rwlock_rdlock+0x5c> 3000b3bc: e5941000 ldr r1, [r4] 3000b3c0: e28d2004 add r2, sp, #4 3000b3c4: eb000a91 bl 3000de10 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b3c8: e59d3004 ldr r3, [sp, #4] 3000b3cc: e3530000 cmp r3, #0
3000b3d0: 1a00000a bne 3000b400 <pthread_rwlock_rdlock+0x54>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000b3d4: e58d3000 str r3, [sp] 3000b3d8: e2800010 add r0, r0, #16 3000b3dc: e5941000 ldr r1, [r4] 3000b3e0: e3a02001 mov r2, #1 3000b3e4: eb00073f bl 3000d0e8 <_CORE_RWLock_Obtain_for_reading>
true, /* we are willing to wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
3000b3e8: eb000df3 bl 3000ebbc <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b3ec: e59f3018 ldr r3, [pc, #24] ; 3000b40c <pthread_rwlock_rdlock+0x60> 3000b3f0: e5933008 ldr r3, [r3, #8]
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b3f4: e5930034 ldr r0, [r3, #52] ; 0x34 3000b3f8: eb00005e bl 3000b578 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000b3fc: ea000000 b 3000b404 <pthread_rwlock_rdlock+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b400: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b404: e8bd801c pop {r2, r3, r4, pc}
3000b410 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000b410: e92d4077 push {r0, r1, r2, r4, r5, r6, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000b414: e2506000 subs r6, r0, #0
3000b418: 0a000025 beq 3000b4b4 <pthread_rwlock_timedrdlock+0xa4> * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000b41c: e1a00001 mov r0, r1 3000b420: e28d1008 add r1, sp, #8 3000b424: eb00180c bl 3001145c <_POSIX_Absolute_timeout_to_ticks> 3000b428: e5961000 ldr r1, [r6] 3000b42c: e1a04000 mov r4, r0 3000b430: e28d2004 add r2, sp, #4 3000b434: e59f0080 ldr r0, [pc, #128] ; 3000b4bc <pthread_rwlock_timedrdlock+0xac> 3000b438: eb000a74 bl 3000de10 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b43c: e59d3004 ldr r3, [sp, #4] 3000b440: e3530000 cmp r3, #0
3000b444: 1a00001a bne 3000b4b4 <pthread_rwlock_timedrdlock+0xa4> int _EXFUN(pthread_rwlock_init, (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr)); int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedrdlock,
3000b448: e2442003 sub r2, r4, #3 3000b44c: e2725000 rsbs r5, r2, #0 3000b450: e0a55002 adc r5, r5, r2
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000b454: e58d3000 str r3, [sp] 3000b458: e2800010 add r0, r0, #16 3000b45c: e59d3008 ldr r3, [sp, #8] 3000b460: e5961000 ldr r1, [r6] 3000b464: e1a02005 mov r2, r5 3000b468: eb00071e bl 3000d0e8 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
3000b46c: eb000dd2 bl 3000ebbc <_Thread_Enable_dispatch>
if ( !do_wait ) {
3000b470: e3550000 cmp r5, #0 3000b474: e59f3044 ldr r3, [pc, #68] ; 3000b4c0 <pthread_rwlock_timedrdlock+0xb0>
3000b478: 1a000009 bne 3000b4a4 <pthread_rwlock_timedrdlock+0x94>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
3000b47c: e5932008 ldr r2, [r3, #8] 3000b480: e5922034 ldr r2, [r2, #52] ; 0x34 3000b484: e3520002 cmp r2, #2
3000b488: 1a000005 bne 3000b4a4 <pthread_rwlock_timedrdlock+0x94> if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000b48c: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b490: 0a000007 beq 3000b4b4 <pthread_rwlock_timedrdlock+0xa4> <== NOT EXECUTED
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000b494: e2444001 sub r4, r4, #1 <== NOT EXECUTED 3000b498: e3540001 cmp r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
3000b49c: 93a00074 movls r0, #116 ; 0x74 <== NOT EXECUTED
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000b4a0: 9a000004 bls 3000b4b8 <pthread_rwlock_timedrdlock+0xa8> <== NOT EXECUTED
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b4a4: e5933008 ldr r3, [r3, #8]
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b4a8: e5930034 ldr r0, [r3, #52] ; 0x34 3000b4ac: eb000031 bl 3000b578 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000b4b0: ea000000 b 3000b4b8 <pthread_rwlock_timedrdlock+0xa8>
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
3000b4b4: e3a00016 mov r0, #22 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000b4b8: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc}
3000b4c4 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000b4c4: e92d4077 push {r0, r1, r2, r4, r5, r6, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000b4c8: e2506000 subs r6, r0, #0
3000b4cc: 0a000025 beq 3000b568 <pthread_rwlock_timedwrlock+0xa4> * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000b4d0: e1a00001 mov r0, r1 3000b4d4: e28d1008 add r1, sp, #8 3000b4d8: eb0017df bl 3001145c <_POSIX_Absolute_timeout_to_ticks> 3000b4dc: e5961000 ldr r1, [r6] 3000b4e0: e1a04000 mov r4, r0 3000b4e4: e28d2004 add r2, sp, #4 3000b4e8: e59f0080 ldr r0, [pc, #128] ; 3000b570 <pthread_rwlock_timedwrlock+0xac> 3000b4ec: eb000a47 bl 3000de10 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b4f0: e59d3004 ldr r3, [sp, #4] 3000b4f4: e3530000 cmp r3, #0
3000b4f8: 1a00001a bne 3000b568 <pthread_rwlock_timedwrlock+0xa4>
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
3000b4fc: e2442003 sub r2, r4, #3 3000b500: e2725000 rsbs r5, r2, #0 3000b504: e0a55002 adc r5, r5, r2
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000b508: e58d3000 str r3, [sp] 3000b50c: e2800010 add r0, r0, #16 3000b510: e59d3008 ldr r3, [sp, #8] 3000b514: e5961000 ldr r1, [r6] 3000b518: e1a02005 mov r2, r5 3000b51c: eb000720 bl 3000d1a4 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
3000b520: eb000da5 bl 3000ebbc <_Thread_Enable_dispatch>
if ( !do_wait &&
3000b524: e3550000 cmp r5, #0 3000b528: e59f3044 ldr r3, [pc, #68] ; 3000b574 <pthread_rwlock_timedwrlock+0xb0>
3000b52c: 1a000009 bne 3000b558 <pthread_rwlock_timedwrlock+0x94>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
3000b530: e5932008 ldr r2, [r3, #8]
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
3000b534: e5922034 ldr r2, [r2, #52] ; 0x34 3000b538: e3520002 cmp r2, #2
3000b53c: 1a000005 bne 3000b558 <pthread_rwlock_timedwrlock+0x94>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000b540: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b544: 0a000007 beq 3000b568 <pthread_rwlock_timedwrlock+0xa4> <== NOT EXECUTED
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000b548: e2444001 sub r4, r4, #1 <== NOT EXECUTED 3000b54c: e3540001 cmp r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
3000b550: 93a00074 movls r0, #116 ; 0x74 <== NOT EXECUTED
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000b554: 9a000004 bls 3000b56c <pthread_rwlock_timedwrlock+0xa8> <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b558: e5933008 ldr r3, [r3, #8]
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b55c: e5930034 ldr r0, [r3, #52] ; 0x34 3000b560: eb000004 bl 3000b578 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000b564: ea000000 b 3000b56c <pthread_rwlock_timedwrlock+0xa8>
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
3000b568: e3a00016 mov r0, #22 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000b56c: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc}
3000b588 <pthread_rwlock_tryrdlock>:
*/
int pthread_rwlock_tryrdlock(
pthread_rwlock_t *rwlock
)
{
3000b588: e92d4013 push {r0, r1, r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b58c: e2504000 subs r4, r0, #0
3000b590: 0a000011 beq 3000b5dc <pthread_rwlock_tryrdlock+0x54>
3000b594: e28d2004 add r2, sp, #4 3000b598: e59f0044 ldr r0, [pc, #68] ; 3000b5e4 <pthread_rwlock_tryrdlock+0x5c> 3000b59c: e5941000 ldr r1, [r4] 3000b5a0: eb000a1a bl 3000de10 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b5a4: e59d2004 ldr r2, [sp, #4] 3000b5a8: e3520000 cmp r2, #0
3000b5ac: 1a00000a bne 3000b5dc <pthread_rwlock_tryrdlock+0x54>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000b5b0: e58d2000 str r2, [sp] 3000b5b4: e1a03002 mov r3, r2 3000b5b8: e2800010 add r0, r0, #16 3000b5bc: e5941000 ldr r1, [r4] 3000b5c0: eb0006c8 bl 3000d0e8 <_CORE_RWLock_Obtain_for_reading>
0,
NULL
);
_Thread_Enable_dispatch();
3000b5c4: eb000d7c bl 3000ebbc <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b5c8: e59f3018 ldr r3, [pc, #24] ; 3000b5e8 <pthread_rwlock_tryrdlock+0x60> 3000b5cc: e5933008 ldr r3, [r3, #8]
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b5d0: e5930034 ldr r0, [r3, #52] ; 0x34 3000b5d4: ebffffe7 bl 3000b578 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000b5d8: ea000000 b 3000b5e0 <pthread_rwlock_tryrdlock+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b5dc: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b5e0: e8bd801c pop {r2, r3, r4, pc}
3000b5ec <pthread_rwlock_trywrlock>:
*/
int pthread_rwlock_trywrlock(
pthread_rwlock_t *rwlock
)
{
3000b5ec: e92d4013 push {r0, r1, r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b5f0: e2504000 subs r4, r0, #0
3000b5f4: 0a000011 beq 3000b640 <pthread_rwlock_trywrlock+0x54>
3000b5f8: e28d2004 add r2, sp, #4 3000b5fc: e59f0044 ldr r0, [pc, #68] ; 3000b648 <pthread_rwlock_trywrlock+0x5c> 3000b600: e5941000 ldr r1, [r4] 3000b604: eb000a01 bl 3000de10 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b608: e59d2004 ldr r2, [sp, #4] 3000b60c: e3520000 cmp r2, #0
3000b610: 1a00000a bne 3000b640 <pthread_rwlock_trywrlock+0x54>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000b614: e58d2000 str r2, [sp] 3000b618: e1a03002 mov r3, r2 3000b61c: e2800010 add r0, r0, #16 3000b620: e5941000 ldr r1, [r4] 3000b624: eb0006de bl 3000d1a4 <_CORE_RWLock_Obtain_for_writing>
false, /* we are not willing to wait */
0,
NULL
);
_Thread_Enable_dispatch();
3000b628: eb000d63 bl 3000ebbc <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b62c: e59f3018 ldr r3, [pc, #24] ; 3000b64c <pthread_rwlock_trywrlock+0x60> 3000b630: e5933008 ldr r3, [r3, #8]
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b634: e5930034 ldr r0, [r3, #52] ; 0x34 3000b638: ebffffce bl 3000b578 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000b63c: ea000000 b 3000b644 <pthread_rwlock_trywrlock+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b640: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b644: e8bd801c pop {r2, r3, r4, pc}
3000b650 <pthread_rwlock_unlock>:
{
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
CORE_RWLock_Status status;
if ( !rwlock )
3000b650: e2503000 subs r3, r0, #0
*/
int pthread_rwlock_unlock(
pthread_rwlock_t *rwlock
)
{
3000b654: e92d4011 push {r0, r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
CORE_RWLock_Status status;
if ( !rwlock )
3000b658: 0a00000d beq 3000b694 <pthread_rwlock_unlock+0x44>
3000b65c: e5931000 ldr r1, [r3] 3000b660: e59f0034 ldr r0, [pc, #52] ; 3000b69c <pthread_rwlock_unlock+0x4c> 3000b664: e1a0200d mov r2, sp 3000b668: eb0009e8 bl 3000de10 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b66c: e59d3000 ldr r3, [sp] 3000b670: e3530000 cmp r3, #0
3000b674: 1a000006 bne 3000b694 <pthread_rwlock_unlock+0x44>
case OBJECTS_LOCAL:
status = _CORE_RWLock_Release( &the_rwlock->RWLock );
3000b678: e2800010 add r0, r0, #16 3000b67c: eb0006eb bl 3000d230 <_CORE_RWLock_Release> 3000b680: e1a04000 mov r4, r0
_Thread_Enable_dispatch();
3000b684: eb000d4c bl 3000ebbc <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code( status );
3000b688: e1a00004 mov r0, r4 3000b68c: ebffffb9 bl 3000b578 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000b690: ea000000 b 3000b698 <pthread_rwlock_unlock+0x48>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b694: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b698: e8bd8018 pop {r3, r4, pc}
3000b6a0 <pthread_rwlock_wrlock>:
*/
int pthread_rwlock_wrlock(
pthread_rwlock_t *rwlock
)
{
3000b6a0: e92d4013 push {r0, r1, r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b6a4: e2504000 subs r4, r0, #0
3000b6a8: 0a000011 beq 3000b6f4 <pthread_rwlock_wrlock+0x54>
3000b6ac: e59f0048 ldr r0, [pc, #72] ; 3000b6fc <pthread_rwlock_wrlock+0x5c> 3000b6b0: e5941000 ldr r1, [r4] 3000b6b4: e28d2004 add r2, sp, #4 3000b6b8: eb0009d4 bl 3000de10 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b6bc: e59d3004 ldr r3, [sp, #4] 3000b6c0: e3530000 cmp r3, #0
3000b6c4: 1a00000a bne 3000b6f4 <pthread_rwlock_wrlock+0x54>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000b6c8: e58d3000 str r3, [sp] 3000b6cc: e2800010 add r0, r0, #16 3000b6d0: e5941000 ldr r1, [r4] 3000b6d4: e3a02001 mov r2, #1 3000b6d8: eb0006b1 bl 3000d1a4 <_CORE_RWLock_Obtain_for_writing>
true, /* do not timeout -- wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
3000b6dc: eb000d36 bl 3000ebbc <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b6e0: e59f3018 ldr r3, [pc, #24] ; 3000b700 <pthread_rwlock_wrlock+0x60> 3000b6e4: e5933008 ldr r3, [r3, #8]
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b6e8: e5930034 ldr r0, [r3, #52] ; 0x34 3000b6ec: ebffffa1 bl 3000b578 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000b6f0: ea000000 b 3000b6f8 <pthread_rwlock_wrlock+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b6f4: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b6f8: e8bd801c pop {r2, r3, r4, pc}
3000bc5c <pthread_rwlockattr_destroy>:
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000bc5c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000bc60: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000bc64: 012fff1e bxeq lr <== NOT EXECUTED 3000bc68: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000bc6c: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000bc70: 13a00000 movne r0, #0 <== NOT EXECUTED 3000bc74: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000bc78: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000bc7c: e12fff1e bx lr <== NOT EXECUTED
3000bc80 <pthread_rwlockattr_getpshared>:
int pthread_rwlockattr_getpshared(
const pthread_rwlockattr_t *attr,
int *pshared
)
{
if ( !attr )
3000bc80: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000bc84: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_rwlockattr_getpshared(
const pthread_rwlockattr_t *attr,
int *pshared
)
{
if ( !attr )
3000bc88: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000bc8c: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000bc90: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000bc94: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000bc98: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
3000bc9c: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0;
3000bca0: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000bca4: e12fff1e bx lr <== NOT EXECUTED
3000bcc4 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
3000bcc4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bcc8: 0a000007 beq 3000bcec <pthread_rwlockattr_setpshared+0x28> <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000bccc: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000bcd0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bcd4: 0a000004 beq 3000bcec <pthread_rwlockattr_setpshared+0x28> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000bcd8: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000bcdc: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000bce0: 93a00000 movls r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000bce4: 912fff1e bxls lr <== NOT EXECUTED 3000bce8: ea000001 b 3000bcf4 <pthread_rwlockattr_setpshared+0x30> <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000bcec: e3a00016 mov r0, #22 <== NOT EXECUTED 3000bcf0: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000bcf4: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000bcf8: e12fff1e bx lr <== NOT EXECUTED
3001d0d0 <pthread_self>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
pthread_t pthread_self( void )
{
return _Thread_Executing->Object.id;
3001d0d0: e59f3008 ldr r3, [pc, #8] ; 3001d0e0 <pthread_self+0x10> <== NOT EXECUTED 3001d0d4: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
}
3001d0d8: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3001d0dc: e12fff1e bx lr <== NOT EXECUTED
30009c20 <pthread_setcancelstate>:
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009c20: e59f3060 ldr r3, [pc, #96] ; 30009c88 <pthread_setcancelstate+0x68><== NOT EXECUTED
int pthread_setcancelstate(
int state,
int *oldstate
)
{
30009c24: e92d4010 push {r4, lr} <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009c28: e5934000 ldr r4, [r3] <== NOT EXECUTED 30009c2c: e3540000 cmp r4, #0 <== NOT EXECUTED
return EPROTO;
30009c30: 13a00047 movne r0, #71 ; 0x47 <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009c34: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return EPROTO;
if ( !oldstate )
30009c38: e3510000 cmp r1, #0 <== NOT EXECUTED
return EINVAL;
30009c3c: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
if ( !oldstate )
30009c40: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
30009c44: e3500001 cmp r0, #1 <== NOT EXECUTED 30009c48: 8a00000c bhi 30009c80 <pthread_setcancelstate+0x60> <== 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;
30009c4c: e59fc038 ldr ip, [pc, #56] ; 30009c8c <pthread_setcancelstate+0x6c><== NOT EXECUTED
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30009c50: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 30009c54: e59ce000 ldr lr, [ip] <== NOT EXECUTED 30009c58: e59220f4 ldr r2, [r2, #244] ; 0xf4 <== NOT EXECUTED
++level;
30009c5c: e28ee001 add lr, lr, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30009c60: e58ce000 str lr, [ip] <== NOT EXECUTED
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
30009c64: e592c0d8 ldr ip, [r2, #216] ; 0xd8 <== NOT EXECUTED 30009c68: e581c000 str ip, [r1] <== NOT EXECUTED
thread_support->cancelability_state = state;
30009c6c: e58200d8 str r0, [r2, #216] ; 0xd8 <== NOT EXECUTED
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
30009c70: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 30009c74: eb00144e bl 3000edb4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
30009c78: e1a00004 mov r0, r4 <== NOT EXECUTED
30009c7c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !oldstate )
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
return EINVAL;
30009c80: e3a00016 mov r0, #22 <== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
30009c84: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30009c90 <pthread_setcanceltype>:
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009c90: e59f3060 ldr r3, [pc, #96] ; 30009cf8 <pthread_setcanceltype+0x68><== NOT EXECUTED
int pthread_setcanceltype(
int type,
int *oldtype
)
{
30009c94: e92d4010 push {r4, lr} <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009c98: e5934000 ldr r4, [r3] <== NOT EXECUTED 30009c9c: e3540000 cmp r4, #0 <== NOT EXECUTED
return EPROTO;
30009ca0: 13a00047 movne r0, #71 ; 0x47 <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009ca4: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return EPROTO;
if ( !oldtype )
30009ca8: e3510000 cmp r1, #0 <== NOT EXECUTED
return EINVAL;
30009cac: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
if ( !oldtype )
30009cb0: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
30009cb4: e3500001 cmp r0, #1 <== NOT EXECUTED 30009cb8: 8a00000c bhi 30009cf0 <pthread_setcanceltype+0x60> <== 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;
30009cbc: e59fc038 ldr ip, [pc, #56] ; 30009cfc <pthread_setcanceltype+0x6c><== NOT EXECUTED
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30009cc0: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 30009cc4: e59ce000 ldr lr, [ip] <== NOT EXECUTED 30009cc8: e59220f4 ldr r2, [r2, #244] ; 0xf4 <== NOT EXECUTED
++level;
30009ccc: e28ee001 add lr, lr, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30009cd0: e58ce000 str lr, [ip] <== NOT EXECUTED
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
30009cd4: e592c0dc ldr ip, [r2, #220] ; 0xdc <== NOT EXECUTED 30009cd8: e581c000 str ip, [r1] <== NOT EXECUTED
thread_support->cancelability_type = type;
30009cdc: e58200dc str r0, [r2, #220] ; 0xdc <== NOT EXECUTED
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
30009ce0: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 30009ce4: eb001432 bl 3000edb4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
30009ce8: e1a00004 mov r0, r4 <== NOT EXECUTED
30009cec: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !oldtype )
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
return EINVAL;
30009cf0: e3a00016 mov r0, #22 <== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
30009cf4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cc6c <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
3000cc6c: e92d41f7 push {r0, r1, r2, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int rc;
/*
* Check all the parameters
*/
if ( !param )
3000cc70: e2528000 subs r8, r2, #0 <== NOT EXECUTED
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
3000cc74: e1a04000 mov r4, r0 <== NOT EXECUTED 3000cc78: e1a06001 mov r6, r1 <== NOT EXECUTED
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
3000cc7c: 03a07016 moveq r7, #22 <== NOT EXECUTED
int rc;
/*
* Check all the parameters
*/
if ( !param )
3000cc80: 0a000038 beq 3000cd68 <pthread_setschedparam+0xfc> <== NOT EXECUTED
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
3000cc84: e1a00001 mov r0, r1 <== NOT EXECUTED 3000cc88: e1a0200d mov r2, sp <== NOT EXECUTED 3000cc8c: e1a01008 mov r1, r8 <== NOT EXECUTED 3000cc90: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000cc94: eb0015f6 bl 30012474 <_POSIX_Thread_Translate_sched_param> <== NOT EXECUTED
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
3000cc98: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000cc9c: 1a000031 bne 3000cd68 <pthread_setschedparam+0xfc> <== NOT EXECUTED
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
3000cca0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cca4: e28d1008 add r1, sp, #8 <== NOT EXECUTED 3000cca8: eb000b50 bl 3000f9f0 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000ccac: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
3000ccb0: e1a05000 mov r5, r0 <== NOT EXECUTED
switch ( location ) {
3000ccb4: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000ccb8: 13a07003 movne r7, #3 <== NOT EXECUTED
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000ccbc: 1a000029 bne 3000cd68 <pthread_setschedparam+0xfc> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000ccc0: e59040f4 ldr r4, [r0, #244] ; 0xf4 <== NOT EXECUTED
if ( api->schedpolicy == SCHED_SPORADIC )
3000ccc4: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED 3000ccc8: e3530004 cmp r3, #4 <== NOT EXECUTED
(void) _Watchdog_Remove( &api->Sporadic_timer );
3000cccc: 028400a8 addeq r0, r4, #168 ; 0xa8 <== NOT EXECUTED 3000ccd0: 0b000f01 bleq 300108dc <_Watchdog_Remove> <== NOT EXECUTED
api->schedpolicy = policy;
3000ccd4: e5846084 str r6, [r4, #132] ; 0x84 <== NOT EXECUTED
api->schedparam = *param;
3000ccd8: e284c088 add ip, r4, #136 ; 0x88 <== NOT EXECUTED
3000ccdc: e8b8000f ldm r8!, {r0, r1, r2, r3} <== NOT EXECUTED
3000cce0: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
the_thread->budget_algorithm = budget_algorithm;
3000cce4: e59d3000 ldr r3, [sp] <== NOT EXECUTED
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
3000cce8: e8980007 ldm r8, {r0, r1, r2} <== NOT EXECUTED
3000ccec: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
the_thread->budget_algorithm = budget_algorithm;
3000ccf0: e5853078 str r3, [r5, #120] ; 0x78 <== NOT EXECUTED
the_thread->budget_callout = budget_callout;
3000ccf4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
switch ( api->schedpolicy ) {
3000ccf8: e3560000 cmp r6, #0 <== NOT EXECUTED
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
3000ccfc: e585307c str r3, [r5, #124] ; 0x7c <== NOT EXECUTED
switch ( api->schedpolicy ) {
3000cd00: ba000017 blt 3000cd64 <pthread_setschedparam+0xf8> <== NOT EXECUTED 3000cd04: e3560002 cmp r6, #2 <== NOT EXECUTED 3000cd08: da000002 ble 3000cd18 <pthread_setschedparam+0xac> <== NOT EXECUTED 3000cd0c: e3560004 cmp r6, #4 <== NOT EXECUTED 3000cd10: 1a000013 bne 3000cd64 <pthread_setschedparam+0xf8> <== NOT EXECUTED 3000cd14: ea00000b b 3000cd48 <pthread_setschedparam+0xdc> <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000cd18: e59f3050 ldr r3, [pc, #80] ; 3000cd70 <pthread_setschedparam+0x104><== NOT EXECUTED
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
3000cd1c: e1a00005 mov r0, r5 <== NOT EXECUTED
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000cd20: e5933000 ldr r3, [r3] <== NOT EXECUTED
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
3000cd24: e3a02001 mov r2, #1 <== NOT EXECUTED
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000cd28: e5853074 str r3, [r5, #116] ; 0x74 <== NOT EXECUTED 3000cd2c: e59f3040 ldr r3, [pc, #64] ; 3000cd74 <pthread_setschedparam+0x108><== NOT EXECUTED 3000cd30: e5d31000 ldrb r1, [r3] <== NOT EXECUTED 3000cd34: e5943088 ldr r3, [r4, #136] ; 0x88 <== NOT EXECUTED 3000cd38: e0631001 rsb r1, r3, r1 <== NOT EXECUTED
the_thread->real_priority =
3000cd3c: e5851018 str r1, [r5, #24] <== NOT EXECUTED
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
3000cd40: eb000a09 bl 3000f56c <_Thread_Change_priority> <== NOT EXECUTED
the_thread,
the_thread->real_priority,
true
);
break;
3000cd44: ea000006 b 3000cd64 <pthread_setschedparam+0xf8> <== NOT EXECUTED
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
3000cd48: e5943088 ldr r3, [r4, #136] ; 0x88 <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
3000cd4c: e28400a8 add r0, r4, #168 ; 0xa8 <== NOT EXECUTED
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
3000cd50: e58430a4 str r3, [r4, #164] ; 0xa4 <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
3000cd54: eb000ee0 bl 300108dc <_Watchdog_Remove> <== NOT EXECUTED
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
3000cd58: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cd5c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000cd60: ebffff7b bl 3000cb54 <_POSIX_Threads_Sporadic_budget_TSR> <== NOT EXECUTED
break;
}
_Thread_Enable_dispatch();
3000cd64: eb000b19 bl 3000f9d0 <_Thread_Enable_dispatch> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
3000cd68: e1a00007 mov r0, r7 <== NOT EXECUTED
3000cd6c: e8bd81fe pop {r1, r2, r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001050c <pthread_sigmask>:
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
3001050c: e271c001 rsbs ip, r1, #1 <== NOT EXECUTED 30010510: 33a0c000 movcc ip, #0 <== NOT EXECUTED 30010514: e3520000 cmp r2, #0 <== NOT EXECUTED 30010518: 03510000 cmpeq r1, #0 <== NOT EXECUTED
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
3001051c: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set && !oset )
30010520: 0a00001f beq 300105a4 <pthread_sigmask+0x98> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30010524: e59f30a0 ldr r3, [pc, #160] ; 300105cc <pthread_sigmask+0xc0><== NOT EXECUTED
if ( oset )
30010528: e3520000 cmp r2, #0 <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set && !oset )
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3001052c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30010530: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED
if ( oset )
*oset = api->signals_blocked;
30010534: 159340d0 ldrne r4, [r3, #208] ; 0xd0 <== NOT EXECUTED 30010538: 15824000 strne r4, [r2] <== NOT EXECUTED
if ( !set )
3001053c: e35c0000 cmp ip, #0 <== NOT EXECUTED 30010540: 1a00001f bne 300105c4 <pthread_sigmask+0xb8> <== NOT EXECUTED
return 0;
switch ( how ) {
30010544: e3500001 cmp r0, #1 <== NOT EXECUTED 30010548: 0a000005 beq 30010564 <pthread_sigmask+0x58> <== NOT EXECUTED 3001054c: e3500002 cmp r0, #2 <== NOT EXECUTED 30010550: 0a000007 beq 30010574 <pthread_sigmask+0x68> <== NOT EXECUTED 30010554: e3500000 cmp r0, #0 <== NOT EXECUTED
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
break;
case SIG_SETMASK:
api->signals_blocked = *set;
30010558: 05912000 ldreq r2, [r1] <== NOT EXECUTED
*oset = api->signals_blocked;
if ( !set )
return 0;
switch ( how ) {
3001055c: 0a000007 beq 30010580 <pthread_sigmask+0x74> <== NOT EXECUTED 30010560: ea00000f b 300105a4 <pthread_sigmask+0x98> <== NOT EXECUTED
case SIG_BLOCK:
api->signals_blocked |= *set;
30010564: e59300d0 ldr r0, [r3, #208] ; 0xd0 <== NOT EXECUTED 30010568: e5912000 ldr r2, [r1] <== NOT EXECUTED 3001056c: e1802002 orr r2, r0, r2 <== NOT EXECUTED 30010570: ea000002 b 30010580 <pthread_sigmask+0x74> <== NOT EXECUTED
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
30010574: e5911000 ldr r1, [r1] <== NOT EXECUTED 30010578: e59320d0 ldr r2, [r3, #208] ; 0xd0 <== NOT EXECUTED 3001057c: e1c22001 bic r2, r2, r1 <== NOT EXECUTED
break;
case SIG_SETMASK:
api->signals_blocked = *set;
30010580: e58320d0 str r2, [r3, #208] ; 0xd0 <== NOT EXECUTED
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
30010584: e59f2044 ldr r2, [pc, #68] ; 300105d0 <pthread_sigmask+0xc4><== NOT EXECUTED 30010588: e5920000 ldr r0, [r2] <== NOT EXECUTED 3001058c: e59320d4 ldr r2, [r3, #212] ; 0xd4 <== NOT EXECUTED
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
30010590: e59330d0 ldr r3, [r3, #208] ; 0xd0 <== NOT EXECUTED
(api->signals_pending | _POSIX_signals_Pending) ) {
30010594: e1800002 orr r0, r0, r2 <== NOT EXECUTED
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
30010598: e1d00003 bics r0, r0, r3 <== NOT EXECUTED
3001059c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
300105a0: ea000004 b 300105b8 <pthread_sigmask+0xac> <== NOT EXECUTED
break;
case SIG_SETMASK:
api->signals_blocked = *set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
300105a4: eb0008ef bl 30012968 <__errno> <== NOT EXECUTED
300105a8: e3a03016 mov r3, #22 <== NOT EXECUTED
300105ac: e5803000 str r3, [r0] <== NOT EXECUTED
300105b0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300105b4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
300105b8: ebfff3cd bl 3000d4f4 <_Thread_Dispatch> <== NOT EXECUTED
}
return 0;
300105bc: e3a00000 mov r0, #0 <== NOT EXECUTED
300105c0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( oset )
*oset = api->signals_blocked;
if ( !set )
return 0;
300105c4: e3a00000 mov r0, #0 <== NOT EXECUTED
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
300105c8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a20c <pthread_spin_destroy>:
)
{
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
if ( !spinlock )
3000a20c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
* source of the error.
*/
int pthread_spin_destroy(
pthread_spinlock_t *spinlock
)
{
3000a210: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
if ( !spinlock )
3000a214: 0a000016 beq 3000a274 <pthread_spin_destroy+0x68> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get (
pthread_spinlock_t *spinlock,
Objects_Locations *location
)
{
return (POSIX_Spinlock_Control *) _Objects_Get(
3000a218: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a21c: e59f0058 ldr r0, [pc, #88] ; 3000a27c <pthread_spin_destroy+0x70><== NOT EXECUTED 3000a220: e1a0200d mov r2, sp <== NOT EXECUTED 3000a224: eb000864 bl 3000c3bc <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000a228: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a22c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a230: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a234: 1a00000e bne 3000a274 <pthread_spin_destroy+0x68> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _CORE_spinlock_Is_busy(
CORE_spinlock_Control *the_spinlock
)
{
return (the_spinlock->users != 0);
3000a238: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) {
3000a23c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a240: 0a000002 beq 3000a250 <pthread_spin_destroy+0x44> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a244: eb000bc7 bl 3000d168 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000a248: e3a00010 mov r0, #16 <== NOT EXECUTED 3000a24c: ea000009 b 3000a278 <pthread_spin_destroy+0x6c> <== NOT EXECUTED
}
_Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object );
3000a250: e59f0024 ldr r0, [pc, #36] ; 3000a27c <pthread_spin_destroy+0x70><== NOT EXECUTED 3000a254: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a258: eb000755 bl 3000bfb4 <_Objects_Close> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _POSIX_Spinlock_Free (
POSIX_Spinlock_Control *the_spinlock
)
{
_Objects_Free( &_POSIX_Spinlock_Information, &the_spinlock->Object );
3000a25c: e59f0018 ldr r0, [pc, #24] ; 3000a27c <pthread_spin_destroy+0x70><== NOT EXECUTED 3000a260: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a264: eb0007ff bl 3000c268 <_Objects_Free> <== NOT EXECUTED
_POSIX_Spinlock_Free( the_spinlock );
_Thread_Enable_dispatch();
3000a268: eb000bbe bl 3000d168 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a26c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a270: ea000000 b 3000a278 <pthread_spin_destroy+0x6c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a274: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a278: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000a8f4 <pthread_spin_init>:
int pthread_spin_init(
pthread_spinlock_t *spinlock,
int pshared
)
{
3000a8f4: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock;
CORE_spinlock_Attributes attributes;
if ( !spinlock )
3000a8f8: e2507000 subs r7, r0, #0 <== NOT EXECUTED
int pthread_spin_init(
pthread_spinlock_t *spinlock,
int pshared
)
{
3000a8fc: e1a05001 mov r5, r1 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock;
CORE_spinlock_Attributes attributes;
if ( !spinlock )
3000a900: 0a00001b beq 3000a974 <pthread_spin_init+0x80> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000a904: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a908: 1a000019 bne 3000a974 <pthread_spin_init+0x80> <== 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;
3000a90c: e59f3068 ldr r3, [pc, #104] ; 3000a97c <pthread_spin_init+0x88><== NOT EXECUTED 3000a910: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3000a914: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000a918: e5832000 str r2, [r3] <== NOT EXECUTED
* This function allocates a spinlock control block from
* the inactive chain of free spinlock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Allocate( void )
{
return (POSIX_Spinlock_Control *)
3000a91c: e59f605c ldr r6, [pc, #92] ; 3000a980 <pthread_spin_init+0x8c><== NOT EXECUTED 3000a920: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a924: eb0009e9 bl 3000d0d0 <_Objects_Allocate> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_spinlock = _POSIX_Spinlock_Allocate();
if ( !the_spinlock ) {
3000a928: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000a92c: 1a000002 bne 3000a93c <pthread_spin_init+0x48> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a930: eb000eac bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000a934: e3a0000b mov r0, #11 <== NOT EXECUTED 3000a938: ea00000e b 3000a978 <pthread_spin_init+0x84> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _CORE_spinlock_Initialize_attributes(
CORE_spinlock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
3000a93c: e28d1004 add r1, sp, #4 <== NOT EXECUTED
}
_CORE_spinlock_Initialize_attributes( &attributes );
_CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes );
3000a940: e2840010 add r0, r4, #16 <== NOT EXECUTED 3000a944: e5215004 str r5, [r1, #-4]! <== NOT EXECUTED 3000a948: e1a0100d mov r1, sp <== NOT EXECUTED 3000a94c: eb00087f bl 3000cb50 <_CORE_spinlock_Initialize> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a950: e596201c ldr r2, [r6, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000a954: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000a958: e1d410b8 ldrh r1, [r4, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a95c: e7824101 str r4, [r2, r1, lsl #2] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000a960: e584500c str r5, [r4, #12] <== NOT EXECUTED
_Objects_Open_u32( &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 );
*spinlock = the_spinlock->Object.id;
3000a964: e5873000 str r3, [r7] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a968: eb000e9e bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a96c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a970: ea000000 b 3000a978 <pthread_spin_init+0x84> <== NOT EXECUTED
switch ( pshared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
3000a974: e3a00016 mov r0, #22 <== NOT EXECUTED
*spinlock = the_spinlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000a978: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a310 <pthread_spin_lock>:
{
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a310: e2503000 subs r3, r0, #0 <== NOT EXECUTED
* source of the error.
*/
int pthread_spin_lock(
pthread_spinlock_t *spinlock
)
{
3000a314: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a318: 0a00000e beq 3000a358 <pthread_spin_lock+0x48> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get (
pthread_spinlock_t *spinlock,
Objects_Locations *location
)
{
return (POSIX_Spinlock_Control *) _Objects_Get(
3000a31c: e1a0200d mov r2, sp <== NOT EXECUTED 3000a320: e59f0038 ldr r0, [pc, #56] ; 3000a360 <pthread_spin_lock+0x50><== NOT EXECUTED 3000a324: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a328: eb000823 bl 3000c3bc <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000a32c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000a330: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a334: 1a000007 bne 3000a358 <pthread_spin_lock+0x48> <== NOT EXECUTED
case OBJECTS_LOCAL:
status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, true, 0 );
3000a338: e3a01001 mov r1, #1 <== NOT EXECUTED 3000a33c: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000a340: eb00056a bl 3000b8f0 <_CORE_spinlock_Wait> <== NOT EXECUTED 3000a344: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a348: eb000b86 bl 3000d168 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
3000a34c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a350: eb000003 bl 3000a364 <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 3000a354: ea000000 b 3000a35c <pthread_spin_lock+0x4c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a358: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a35c: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000a374 <pthread_spin_trylock>:
{
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a374: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_trylock(
pthread_spinlock_t *spinlock
)
{
3000a378: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a37c: 0a00000e beq 3000a3bc <pthread_spin_trylock+0x48> <== NOT EXECUTED 3000a380: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a384: e59f0038 ldr r0, [pc, #56] ; 3000a3c4 <pthread_spin_trylock+0x50><== NOT EXECUTED 3000a388: e1a0200d mov r2, sp <== NOT EXECUTED 3000a38c: eb00080a bl 3000c3bc <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000a390: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000a394: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a398: 1a000007 bne 3000a3bc <pthread_spin_trylock+0x48> <== NOT EXECUTED
case OBJECTS_LOCAL:
status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, false, 0 );
3000a39c: e1a02001 mov r2, r1 <== NOT EXECUTED 3000a3a0: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000a3a4: eb000551 bl 3000b8f0 <_CORE_spinlock_Wait> <== NOT EXECUTED 3000a3a8: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a3ac: eb000b6d bl 3000d168 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
3000a3b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a3b4: ebffffea bl 3000a364 <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 3000a3b8: ea000000 b 3000a3c0 <pthread_spin_trylock+0x4c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a3bc: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a3c0: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000a3c8 <pthread_spin_unlock>:
{
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a3c8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_unlock(
pthread_spinlock_t *spinlock
)
{
3000a3cc: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a3d0: 0a00000d beq 3000a40c <pthread_spin_unlock+0x44> <== NOT EXECUTED 3000a3d4: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a3d8: e59f0034 ldr r0, [pc, #52] ; 3000a414 <pthread_spin_unlock+0x4c><== NOT EXECUTED 3000a3dc: e1a0200d mov r2, sp <== NOT EXECUTED 3000a3e0: eb0007f5 bl 3000c3bc <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000a3e4: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a3e8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a3ec: 1a000006 bne 3000a40c <pthread_spin_unlock+0x44> <== NOT EXECUTED
case OBJECTS_LOCAL:
status = _CORE_spinlock_Release( &the_spinlock->Spinlock );
3000a3f0: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000a3f4: eb000521 bl 3000b880 <_CORE_spinlock_Release> <== NOT EXECUTED 3000a3f8: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a3fc: eb000b59 bl 3000d168 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
3000a400: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a404: ebffffd6 bl 3000a364 <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 3000a408: ea000000 b 3000a410 <pthread_spin_unlock+0x48> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a40c: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a410: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000a5d8 <pthread_testcancel>:
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
3000a5d8: e59f305c ldr r3, [pc, #92] ; 3000a63c <pthread_testcancel+0x64><== NOT EXECUTED
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
3000a5dc: e92d4010 push {r4, lr} <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
3000a5e0: e5934000 ldr r4, [r3] <== NOT EXECUTED
3000a5e4: e3540000 cmp r4, #0 <== NOT EXECUTED
3000a5e8: 18bd8010 popne {r4, pc} <== 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;
3000a5ec: e59f204c ldr r2, [pc, #76] ; 3000a640 <pthread_testcancel+0x68><== NOT EXECUTED
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000a5f0: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000a5f4: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000a5f8: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED
++level;
3000a5fc: e2811001 add r1, r1, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000a600: e5821000 str r1, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
3000a604: e59320d8 ldr r2, [r3, #216] ; 0xd8 <== NOT EXECUTED 3000a608: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a60c: 1a000002 bne 3000a61c <pthread_testcancel+0x44> <== NOT EXECUTED
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
3000a610: e59340e0 ldr r4, [r3, #224] ; 0xe0 <== NOT EXECUTED 3000a614: e2944000 adds r4, r4, #0 <== NOT EXECUTED 3000a618: 13a04001 movne r4, #1 <== NOT EXECUTED
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
3000a61c: eb000ae2 bl 3000d1ac <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( cancel )
3000a620: e3540000 cmp r4, #0 <== NOT EXECUTED
3000a624: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
3000a628: e59f300c ldr r3, [pc, #12] ; 3000a63c <pthread_testcancel+0x64><== NOT EXECUTED 3000a62c: e3e01000 mvn r1, #0 <== NOT EXECUTED 3000a630: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
}
3000a634: e8bd4010 pop {r4, lr} <== NOT EXECUTED
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
3000a638: ea0015b4 b 3000fd10 <_POSIX_Thread_Exit> <== NOT EXECUTED
3000aa48 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
3000aa48: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
3000aa4c: e59f41e4 ldr r4, [pc, #484] ; 3000ac38 <rtems_aio_enqueue+0x1f0><== NOT EXECUTED
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
3000aa50: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED 3000aa54: e1a06000 mov r6, r0 <== NOT EXECUTED
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
3000aa58: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aa5c: eb000255 bl 3000b3b8 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0) {
3000aa60: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000aa64: 0a000002 beq 3000aa74 <rtems_aio_enqueue+0x2c> <== NOT EXECUTED
free (req);
3000aa68: e1a00006 mov r0, r6 <== NOT EXECUTED 3000aa6c: ebfff02a bl 30006b1c <free> <== NOT EXECUTED
return result;
3000aa70: ea00006d b 3000ac2c <rtems_aio_enqueue+0x1e4> <== NOT EXECUTED
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
3000aa74: eb000464 bl 3000bc0c <pthread_self> <== NOT EXECUTED 3000aa78: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000aa7c: e1a0200d mov r2, sp <== NOT EXECUTED 3000aa80: eb000370 bl 3000b848 <pthread_getschedparam> <== NOT EXECUTED
req->caller_thread = pthread_self ();
3000aa84: eb000460 bl 3000bc0c <pthread_self> <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
3000aa88: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000aa8c: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000aa90: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
3000aa94: e5860010 str r0, [r6, #16] <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
3000aa98: e0622001 rsb r2, r2, r1 <== NOT EXECUTED 3000aa9c: e586200c str r2, [r6, #12] <== NOT EXECUTED
req->policy = policy;
3000aaa0: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000aaa4: e5862008 str r2, [r6, #8] <== NOT EXECUTED
req->aiocbp->error_code = EINPROGRESS;
3000aaa8: e3a02077 mov r2, #119 ; 0x77 <== NOT EXECUTED 3000aaac: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
3000aab0: e5942068 ldr r2, [r4, #104] ; 0x68 <== NOT EXECUTED
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
3000aab4: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
3000aab8: e3520000 cmp r2, #0 <== NOT EXECUTED 3000aabc: 1a00002d bne 3000ab78 <rtems_aio_enqueue+0x130> <== NOT EXECUTED 3000aac0: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED 3000aac4: e3520004 cmp r2, #4 <== NOT EXECUTED 3000aac8: ca00002a bgt 3000ab78 <rtems_aio_enqueue+0x130> <== NOT EXECUTED
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
3000aacc: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000aad0: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000aad4: e3a02001 mov r2, #1 <== NOT EXECUTED 3000aad8: ebffff83 bl 3000a8ec <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000aadc: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
3000aae0: e1a07000 mov r7, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000aae4: e3530001 cmp r3, #1 <== NOT EXECUTED 3000aae8: e2808008 add r8, r0, #8 <== NOT EXECUTED 3000aaec: 1a000017 bne 3000ab50 <rtems_aio_enqueue+0x108> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
3000aaf0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000aaf4: e1a00008 mov r0, r8 <== NOT EXECUTED 3000aaf8: eb000890 bl 3000cd40 <_Chain_Insert> <== NOT EXECUTED
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
3000aafc: e1a01005 mov r1, r5 <== NOT EXECUTED
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
if (r_chain->new_fd == 1) {
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
3000ab00: e5875018 str r5, [r7, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
3000ab04: e287001c add r0, r7, #28 <== NOT EXECUTED 3000ab08: eb0001d9 bl 3000b274 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
3000ab0c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ab10: e2870020 add r0, r7, #32 <== NOT EXECUTED 3000ab14: eb0000ef bl 3000aed8 <pthread_cond_init> <== NOT EXECUTED
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
3000ab18: e1a03007 mov r3, r7 <== NOT EXECUTED 3000ab1c: e28d001c add r0, sp, #28 <== NOT EXECUTED 3000ab20: e2841008 add r1, r4, #8 <== NOT EXECUTED 3000ab24: e59f2110 ldr r2, [pc, #272] ; 3000ac3c <rtems_aio_enqueue+0x1f4><== NOT EXECUTED 3000ab28: eb0002b1 bl 3000b5f4 <pthread_create> <== NOT EXECUTED
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
3000ab2c: e2506000 subs r6, r0, #0 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
3000ab30: 05943064 ldreq r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000ab34: 02833001 addeq r3, r3, #1 <== NOT EXECUTED 3000ab38: 05843064 streq r3, [r4, #100] ; 0x64 <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
3000ab3c: 0a000038 beq 3000ac24 <rtems_aio_enqueue+0x1dc> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000ab40: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ab44: eb00023a bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
3000ab48: e1a05006 mov r5, r6 <== NOT EXECUTED 3000ab4c: ea000036 b 3000ac2c <rtems_aio_enqueue+0x1e4> <== NOT EXECUTED
}
++aio_request_queue.active_threads;
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
3000ab50: e280401c add r4, r0, #28 <== NOT EXECUTED 3000ab54: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ab58: eb000216 bl 3000b3b8 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
3000ab5c: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ab60: e1a01006 mov r1, r6 <== NOT EXECUTED 3000ab64: ebffff1c bl 3000a7dc <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
3000ab68: e2870020 add r0, r7, #32 <== NOT EXECUTED 3000ab6c: eb000109 bl 3000af98 <pthread_cond_signal> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000ab70: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ab74: ea00000e b 3000abb4 <rtems_aio_enqueue+0x16c> <== NOT EXECUTED
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
3000ab78: e59f00c0 ldr r0, [pc, #192] ; 3000ac40 <rtems_aio_enqueue+0x1f8><== NOT EXECUTED 3000ab7c: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000ab80: e3a02000 mov r2, #0 <== NOT EXECUTED 3000ab84: ebffff58 bl 3000a8ec <rtems_aio_search_fd> <== NOT EXECUTED
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
3000ab88: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000ab8c: 0a00000a beq 3000abbc <rtems_aio_enqueue+0x174> <== NOT EXECUTED
{
pthread_mutex_lock (&r_chain->mutex);
3000ab90: e284701c add r7, r4, #28 <== NOT EXECUTED 3000ab94: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ab98: eb000206 bl 3000b3b8 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
3000ab9c: e2840008 add r0, r4, #8 <== NOT EXECUTED 3000aba0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000aba4: ebffff0c bl 3000a7dc <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
3000aba8: e2840020 add r0, r4, #32 <== NOT EXECUTED 3000abac: eb0000f9 bl 3000af98 <pthread_cond_signal> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000abb0: e1a00007 mov r0, r7 <== NOT EXECUTED 3000abb4: eb00021e bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED 3000abb8: ea000019 b 3000ac24 <rtems_aio_enqueue+0x1dc> <== NOT EXECUTED
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
3000abbc: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000abc0: e59f007c ldr r0, [pc, #124] ; 3000ac44 <rtems_aio_enqueue+0x1fc><== NOT EXECUTED 3000abc4: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000abc8: e3a02001 mov r2, #1 <== NOT EXECUTED 3000abcc: ebffff46 bl 3000a8ec <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000abd0: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
3000abd4: e1a07000 mov r7, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000abd8: e3530001 cmp r3, #1 <== NOT EXECUTED 3000abdc: e1a01006 mov r1, r6 <== NOT EXECUTED 3000abe0: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000abe4: 1a000008 bne 3000ac0c <rtems_aio_enqueue+0x1c4> <== NOT EXECUTED 3000abe8: eb000854 bl 3000cd40 <_Chain_Insert> <== NOT EXECUTED
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
3000abec: e1a01004 mov r1, r4 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
3000abf0: e5874018 str r4, [r7, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
3000abf4: e287001c add r0, r7, #28 <== NOT EXECUTED 3000abf8: eb00019d bl 3000b274 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
3000abfc: e2870020 add r0, r7, #32 <== NOT EXECUTED 3000ac00: e1a01004 mov r1, r4 <== NOT EXECUTED 3000ac04: eb0000b3 bl 3000aed8 <pthread_cond_init> <== NOT EXECUTED 3000ac08: ea000000 b 3000ac10 <rtems_aio_enqueue+0x1c8> <== NOT EXECUTED
} else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
3000ac0c: ebfffef2 bl 3000a7dc <rtems_aio_insert_prio> <== NOT EXECUTED
if (aio_request_queue.idle_threads > 0)
3000ac10: e59f0020 ldr r0, [pc, #32] ; 3000ac38 <rtems_aio_enqueue+0x1f0><== NOT EXECUTED 3000ac14: e5903068 ldr r3, [r0, #104] ; 0x68 <== NOT EXECUTED 3000ac18: e3530000 cmp r3, #0 <== NOT EXECUTED
pthread_cond_signal (&aio_request_queue.new_req);
3000ac1c: c2800004 addgt r0, r0, #4 <== NOT EXECUTED 3000ac20: cb0000dc blgt 3000af98 <pthread_cond_signal> <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
3000ac24: e59f000c ldr r0, [pc, #12] ; 3000ac38 <rtems_aio_enqueue+0x1f0><== NOT EXECUTED 3000ac28: eb000201 bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
return 0; }
3000ac2c: e1a00005 mov r0, r5 <== NOT EXECUTED
3000ac30: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
3000ac34: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000a570 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
3000a570: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
3000a574: e59f425c ldr r4, [pc, #604] ; 3000a7d8 <rtems_aio_handle+0x268><== NOT EXECUTED
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
3000a578: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED 3000a57c: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
3000a580: e284904c add r9, r4, #76 ; 0x4c <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
3000a584: e285801c add r8, r5, #28 <== NOT EXECUTED 3000a588: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a58c: eb000389 bl 3000b3b8 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
3000a590: e250a000 subs sl, r0, #0 <== NOT EXECUTED 3000a594: 1a00008c bne 3000a7cc <rtems_aio_handle+0x25c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000a598: e5956008 ldr r6, [r5, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000a59c: e285300c add r3, r5, #12 <== NOT EXECUTED
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
3000a5a0: e1560003 cmp r6, r3 <== NOT EXECUTED 3000a5a4: 0a000035 beq 3000a680 <rtems_aio_handle+0x110> <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
3000a5a8: eb000597 bl 3000bc0c <pthread_self> <== NOT EXECUTED 3000a5ac: e28d1028 add r1, sp, #40 ; 0x28 <== NOT EXECUTED 3000a5b0: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000a5b4: eb0004a3 bl 3000b848 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
3000a5b8: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 3000a5bc: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
3000a5c0: eb000591 bl 3000bc0c <pthread_self> <== NOT EXECUTED 3000a5c4: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000a5c8: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 3000a5cc: eb000593 bl 3000bc20 <pthread_setschedparam> <== NOT EXECUTED 3000a5d0: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a5d4: eb0009c4 bl 3000ccec <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
3000a5d8: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a5dc: eb000394 bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
3000a5e0: e5962014 ldr r2, [r6, #20] <== NOT EXECUTED 3000a5e4: e592302c ldr r3, [r2, #44] ; 0x2c <== NOT EXECUTED 3000a5e8: e3530002 cmp r3, #2 <== NOT EXECUTED 3000a5ec: 0a00000b beq 3000a620 <rtems_aio_handle+0xb0> <== NOT EXECUTED 3000a5f0: e3530003 cmp r3, #3 <== NOT EXECUTED 3000a5f4: 0a000011 beq 3000a640 <rtems_aio_handle+0xd0> <== NOT EXECUTED 3000a5f8: e3530001 cmp r3, #1 <== NOT EXECUTED 3000a5fc: 1a000013 bne 3000a650 <rtems_aio_handle+0xe0> <== NOT EXECUTED
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
3000a600: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED 3000a604: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED 3000a608: e58d1000 str r1, [sp] <== NOT EXECUTED 3000a60c: e592100c ldr r1, [r2, #12] <== NOT EXECUTED 3000a610: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000a614: e5922010 ldr r2, [r2, #16] <== NOT EXECUTED 3000a618: eb00281b bl 3001468c <pread> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
3000a61c: ea000009 b 3000a648 <rtems_aio_handle+0xd8> <== NOT EXECUTED
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
3000a620: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED 3000a624: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED 3000a628: e58d1000 str r1, [sp] <== NOT EXECUTED 3000a62c: e592100c ldr r1, [r2, #12] <== NOT EXECUTED 3000a630: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000a634: e5922010 ldr r2, [r2, #16] <== NOT EXECUTED 3000a638: eb002856 bl 30014798 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
3000a63c: ea000001 b 3000a648 <rtems_aio_handle+0xd8> <== NOT EXECUTED
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
3000a640: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000a644: eb001907 bl 30010a68 <fsync> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
3000a648: e3700001 cmn r0, #1 <== NOT EXECUTED 3000a64c: 1a000006 bne 3000a66c <rtems_aio_handle+0xfc> <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000a650: e5966014 ldr r6, [r6, #20] <== NOT EXECUTED 3000a654: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000a658: e5863034 str r3, [r6, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
3000a65c: eb002530 bl 30013b24 <__errno> <== NOT EXECUTED 3000a660: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000a664: e5863030 str r3, [r6, #48] ; 0x30 <== NOT EXECUTED 3000a668: eaffffc5 b 3000a584 <rtems_aio_handle+0x14> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
3000a66c: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
req->aiocbp->error_code = 0;
3000a670: e3a02000 mov r2, #0 <== NOT EXECUTED
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
3000a674: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = 0;
3000a678: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED 3000a67c: eaffffc0 b 3000a584 <rtems_aio_handle+0x14> <== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
3000a680: e59f7150 ldr r7, [pc, #336] ; 3000a7d8 <rtems_aio_handle+0x268><== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
3000a684: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a688: eb000369 bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
3000a68c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a690: eb000348 bl 3000b3b8 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
3000a694: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000a698: e1530006 cmp r3, r6 <== NOT EXECUTED 3000a69c: 1a000047 bne 3000a7c0 <rtems_aio_handle+0x250> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
3000a6a0: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000a6a4: e3a00001 mov r0, #1 <== NOT EXECUTED 3000a6a8: eb0001b0 bl 3000ad70 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
3000a6ac: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
3000a6b0: e2856020 add r6, r5, #32 <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
3000a6b4: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
3000a6b8: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a6bc: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a6c0: e28d2020 add r2, sp, #32 <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
3000a6c4: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
3000a6c8: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
3000a6cc: eb000248 bl 3000aff4 <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
3000a6d0: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 3000a6d4: 1a000039 bne 3000a7c0 <rtems_aio_handle+0x250> <== NOT EXECUTED 3000a6d8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a6dc: eb000982 bl 3000ccec <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
3000a6e0: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a6e4: eb000296 bl 3000b144 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
3000a6e8: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a6ec: eb0001c9 bl 3000ae18 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
3000a6f0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a6f4: ebfff108 bl 30006b1c <free> <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
3000a6f8: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 3000a6fc: e2873058 add r3, r7, #88 ; 0x58 <== NOT EXECUTED 3000a700: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a704: 1a000018 bne 3000a76c <rtems_aio_handle+0x1fc> <== NOT EXECUTED
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
3000a708: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED
--aio_request_queue.active_threads; clock_gettime (CLOCK_REALTIME, &timeout);
3000a70c: e28d1020 add r1, sp, #32 <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
3000a710: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000a714: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
--aio_request_queue.active_threads;
3000a718: e5943064 ldr r3, [r4, #100] ; 0x64 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
3000a71c: e3a00001 mov r0, #1 <== NOT EXECUTED
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
3000a720: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000a724: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
3000a728: eb000190 bl 3000ad70 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
3000a72c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000a730: e2870004 add r0, r7, #4 <== NOT EXECUTED
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
3000a734: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000a738: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a73c: e28d2020 add r2, sp, #32 <== NOT EXECUTED
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
3000a740: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
3000a744: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000a748: eb000229 bl 3000aff4 <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
3000a74c: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 3000a750: 1a000005 bne 3000a76c <rtems_aio_handle+0x1fc> <== NOT EXECUTED
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
3000a754: e5973068 ldr r3, [r7, #104] ; 0x68 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a758: e1a00007 mov r0, r7 <== NOT EXECUTED
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
3000a75c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000a760: e5873068 str r3, [r7, #104] ; 0x68 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a764: eb000332 bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
3000a768: ea000017 b 3000a7cc <rtems_aio_handle+0x25c> <== NOT EXECUTED
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
3000a76c: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000a770: e5945054 ldr r5, [r4, #84] ; 0x54 <== NOT EXECUTED 3000a774: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000a778: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
++aio_request_queue.active_threads;
3000a77c: e5943064 ldr r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000a780: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a784: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000a788: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000a78c: eb000956 bl 3000ccec <_Chain_Extract> <== NOT EXECUTED 3000a790: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
3000a794: e5952014 ldr r2, [r5, #20] <== NOT EXECUTED 3000a798: ea000000 b 3000a7a0 <rtems_aio_handle+0x230> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000a79c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a7a0: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED 3000a7a4: e1510002 cmp r1, r2 <== NOT EXECUTED 3000a7a8: aa000001 bge 3000a7b4 <rtems_aio_handle+0x244> <== NOT EXECUTED 3000a7ac: e1530009 cmp r3, r9 <== NOT EXECUTED 3000a7b0: 1afffff9 bne 3000a79c <rtems_aio_handle+0x22c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
3000a7b4: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 3000a7b8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a7bc: eb00095f bl 3000cd40 <_Chain_Insert> <== NOT EXECUTED
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a7c0: e59f0010 ldr r0, [pc, #16] ; 3000a7d8 <rtems_aio_handle+0x268><== NOT EXECUTED 3000a7c4: eb00031a bl 3000b434 <pthread_mutex_unlock> <== NOT EXECUTED 3000a7c8: eaffff6d b 3000a584 <rtems_aio_handle+0x14> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a7cc: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a7d0: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
3000a7d4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000a82c <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
3000a82c: e92d4010 push {r4, lr} <== NOT EXECUTED
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
3000a830: e59f00a4 ldr r0, [pc, #164] ; 3000a8dc <rtems_aio_init+0xb0><== NOT EXECUTED 3000a834: eb00034f bl 3000b578 <pthread_attr_init> <== NOT EXECUTED
if (result != 0)
3000a838: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000a83c: 1a000024 bne 3000a8d4 <rtems_aio_init+0xa8> <== NOT EXECUTED
return result;
result =
3000a840: e59f0094 ldr r0, [pc, #148] ; 3000a8dc <rtems_aio_init+0xb0><== NOT EXECUTED 3000a844: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a848: eb00035b bl 3000b5bc <pthread_attr_setdetachstate> <== NOT EXECUTED
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
3000a84c: e3500000 cmp r0, #0 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000a850: 159f0084 ldrne r0, [pc, #132] ; 3000a8dc <rtems_aio_init+0xb0><== NOT EXECUTED 3000a854: 1b00033e blne 3000b554 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
3000a858: e59f0080 ldr r0, [pc, #128] ; 3000a8e0 <rtems_aio_init+0xb4><== NOT EXECUTED 3000a85c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a860: eb000283 bl 3000b274 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
3000a864: e3500000 cmp r0, #0 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000a868: 159f006c ldrne r0, [pc, #108] ; 3000a8dc <rtems_aio_init+0xb0><== NOT EXECUTED 3000a86c: 1b000338 blne 3000b554 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
3000a870: e59f006c ldr r0, [pc, #108] ; 3000a8e4 <rtems_aio_init+0xb8><== NOT EXECUTED 3000a874: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a878: eb000196 bl 3000aed8 <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
3000a87c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000a880: 0a000003 beq 3000a894 <rtems_aio_init+0x68> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
3000a884: e59f0054 ldr r0, [pc, #84] ; 3000a8e0 <rtems_aio_init+0xb4><== NOT EXECUTED 3000a888: eb00022d bl 3000b144 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000a88c: e59f0048 ldr r0, [pc, #72] ; 3000a8dc <rtems_aio_init+0xb0><== NOT EXECUTED 3000a890: eb00032f bl 3000b554 <pthread_attr_destroy> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a894: e59f3044 ldr r3, [pc, #68] ; 3000a8e0 <rtems_aio_init+0xb4><== NOT EXECUTED 3000a898: e283204c add r2, r3, #76 ; 0x4c <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3000a89c: e2831048 add r1, r3, #72 ; 0x48 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a8a0: e5832048 str r2, [r3, #72] ; 0x48 <== NOT EXECUTED
head->previous = NULL;
3000a8a4: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a8a8: e583204c str r2, [r3, #76] ; 0x4c <== NOT EXECUTED
tail->previous = head;
3000a8ac: e5831050 str r1, [r3, #80] ; 0x50 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3000a8b0: e5832058 str r2, [r3, #88] ; 0x58 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a8b4: e2831058 add r1, r3, #88 ; 0x58 <== NOT EXECUTED
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
3000a8b8: e5832064 str r2, [r3, #100] ; 0x64 <== NOT EXECUTED
aio_request_queue.idle_threads = 0;
3000a8bc: e5832068 str r2, [r3, #104] ; 0x68 <== NOT EXECUTED
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
3000a8c0: e59f2020 ldr r2, [pc, #32] ; 3000a8e8 <rtems_aio_init+0xbc><== NOT EXECUTED 3000a8c4: e5831054 str r1, [r3, #84] ; 0x54 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3000a8c8: e2831054 add r1, r3, #84 ; 0x54 <== NOT EXECUTED 3000a8cc: e583105c str r1, [r3, #92] ; 0x5c <== NOT EXECUTED 3000a8d0: e5832060 str r2, [r3, #96] ; 0x60 <== NOT EXECUTED
return result;
}
3000a8d4: e1a00004 mov r0, r4 <== NOT EXECUTED
3000a8d8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a7dc <rtems_aio_insert_prio>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000a7dc: e1a02000 mov r2, r0 <== NOT EXECUTED 3000a7e0: e4923004 ldr r3, [r2], #4 <== NOT EXECUTED
* NONE
*/
static void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
3000a7e4: e1a0c001 mov ip, r1 <== NOT EXECUTED
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
3000a7e8: e1530002 cmp r3, r2 <== NOT EXECUTED 3000a7ec: 0a00000d beq 3000a828 <rtems_aio_insert_prio+0x4c> <== NOT EXECUTED
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
3000a7f0: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED
while (req->aiocbp->aio_reqprio > prio &&
3000a7f4: e59c0014 ldr r0, [ip, #20] <== NOT EXECUTED
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
3000a7f8: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED
while (req->aiocbp->aio_reqprio > prio &&
3000a7fc: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED 3000a800: ea000002 b 3000a810 <rtems_aio_insert_prio+0x34> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000a804: e5933000 ldr r3, [r3] <== NOT EXECUTED
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
3000a808: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED 3000a80c: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
3000a810: e1500001 cmp r0, r1 <== NOT EXECUTED 3000a814: da000001 ble 3000a820 <rtems_aio_insert_prio+0x44> <== NOT EXECUTED 3000a818: e1530002 cmp r3, r2 <== NOT EXECUTED 3000a81c: 1afffff8 bne 3000a804 <rtems_aio_insert_prio+0x28> <== NOT EXECUTED 3000a820: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 3000a824: e1a0100c mov r1, ip <== NOT EXECUTED 3000a828: ea000944 b 3000cd40 <_Chain_Insert> <== NOT EXECUTED
3000a998 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
3000a998: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000a99c: e5904008 ldr r4, [r0, #8] <== NOT EXECUTED
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 ));
3000a9a0: e280700c add r7, r0, #12 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
3000a9a4: e3a0608c mov r6, #140 ; 0x8c <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000a9a8: e3e05000 mvn r5, #0 <== NOT EXECUTED
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
3000a9ac: ea000008 b 3000a9d4 <rtems_aio_remove_fd+0x3c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000a9b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a9b4: eb0008cc bl 3000ccec <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
3000a9b8: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000a9bc: e5948000 ldr r8, [r4] <== NOT EXECUTED
req->aiocbp->return_value = -1;
free (req);
3000a9c0: e1a00004 mov r0, r4 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
3000a9c4: e5836030 str r6, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000a9c8: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
3000a9cc: ebfff052 bl 30006b1c <free> <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
3000a9d0: e1a04008 mov r4, r8 <== NOT EXECUTED
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
3000a9d4: e1540007 cmp r4, r7 <== NOT EXECUTED 3000a9d8: 1afffff4 bne 3000a9b0 <rtems_aio_remove_fd+0x18> <== NOT EXECUTED
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
3000a9dc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000a9e0 <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
3000a9e0: e92d4010 push {r4, lr} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000a9e4: e4904004 ldr r4, [r0], #4 <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
3000a9e8: e1540000 cmp r4, r0 <== NOT EXECUTED 3000a9ec: 1a000005 bne 3000aa08 <rtems_aio_remove_req+0x28> <== NOT EXECUTED 3000a9f0: ea000012 b 3000aa40 <rtems_aio_remove_req+0x60> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000a9f4: e5944000 ldr r4, [r4] <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
3000a9f8: e1540000 cmp r4, r0 <== NOT EXECUTED 3000a9fc: 1a000001 bne 3000aa08 <rtems_aio_remove_req+0x28> <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
3000aa00: e3a00001 mov r0, #1 <== NOT EXECUTED
3000aa04: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
3000aa08: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000aa0c: e1530001 cmp r3, r1 <== NOT EXECUTED 3000aa10: 1afffff7 bne 3000a9f4 <rtems_aio_remove_req+0x14> <== NOT EXECUTED 3000aa14: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aa18: eb0008b3 bl 3000ccec <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
3000aa1c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000aa20: e3a0208c mov r2, #140 ; 0x8c <== NOT EXECUTED 3000aa24: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
current->aiocbp->return_value = -1;
3000aa28: e3e02000 mvn r2, #0 <== NOT EXECUTED
free (current);
3000aa2c: e1a00004 mov r0, r4 <== NOT EXECUTED
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
3000aa30: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
free (current);
3000aa34: ebfff038 bl 30006b1c <free> <== NOT EXECUTED
}
return AIO_CANCELED;
3000aa38: e3a00000 mov r0, #0 <== NOT EXECUTED
3000aa3c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
3000aa40: e3a00002 mov r0, #2 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
3000aa44: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a8ec <rtems_aio_search_fd>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000a8ec: e1a03000 mov r3, r0 <== NOT EXECUTED
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
3000a8f0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000a8f4: e1a04000 mov r4, r0 <== NOT EXECUTED
3000a8f8: e1a05001 mov r5, r1 <== NOT EXECUTED
3000a8fc: e4937004 ldr r7, [r3], #4 <== NOT EXECUTED
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
3000a900: ea000000 b 3000a908 <rtems_aio_search_fd+0x1c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000a904: e5977000 ldr r7, [r7] <== NOT EXECUTED 3000a908: e5971014 ldr r1, [r7, #20] <== NOT EXECUTED 3000a90c: e1510005 cmp r1, r5 <== NOT EXECUTED 3000a910: ba000001 blt 3000a91c <rtems_aio_search_fd+0x30> <== NOT EXECUTED
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
3000a914: 1a000006 bne 3000a934 <rtems_aio_search_fd+0x48> <== NOT EXECUTED 3000a918: ea000002 b 3000a928 <rtems_aio_search_fd+0x3c> <== NOT EXECUTED
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
3000a91c: e1570003 cmp r7, r3 <== NOT EXECUTED 3000a920: 1afffff7 bne 3000a904 <rtems_aio_search_fd+0x18> <== NOT EXECUTED 3000a924: ea000002 b 3000a934 <rtems_aio_search_fd+0x48> <== NOT EXECUTED
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
3000a928: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a92c: e5873018 str r3, [r7, #24] <== NOT EXECUTED 3000a930: ea000016 b 3000a990 <rtems_aio_search_fd+0xa4> <== NOT EXECUTED
else {
if (create == 0)
3000a934: e3520000 cmp r2, #0 <== NOT EXECUTED
r_chain = NULL;
3000a938: 01a07002 moveq r7, r2 <== NOT EXECUTED
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
3000a93c: 0a000013 beq 3000a990 <rtems_aio_search_fd+0xa4> <== NOT EXECUTED
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
3000a940: e3a00024 mov r0, #36 ; 0x24 <== NOT EXECUTED 3000a944: ebfff184 bl 30006f5c <malloc> <== 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 );
3000a948: e280200c add r2, r0, #12 <== NOT EXECUTED
head->next = tail;
3000a94c: e5802008 str r2, [r0, #8] <== NOT EXECUTED
head->previous = NULL;
3000a950: e3a02000 mov r2, #0 <== 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 );
3000a954: e2803008 add r3, r0, #8 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
3000a958: e580200c str r2, [r0, #12] <== NOT EXECUTED
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
3000a95c: e5942000 ldr r2, [r4] <== NOT EXECUTED
tail->previous = head;
3000a960: e5803010 str r3, [r0, #16] <== 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 );
3000a964: e2843004 add r3, r4, #4 <== NOT EXECUTED
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
3000a968: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
3000a96c: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a970: 15970004 ldrne r0, [r7, #4] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
3000a974: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000a978: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a97c: eb0008ef bl 3000cd40 <_Chain_Insert> <== NOT EXECUTED
rtems_chain_prepend (chain, &r_chain->next_fd);
else
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
r_chain->new_fd = 1;
3000a980: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a984: e5863018 str r3, [r6, #24] <== NOT EXECUTED
r_chain->fildes = fildes;
3000a988: e5865014 str r5, [r6, #20] <== NOT EXECUTED 3000a98c: e1a07006 mov r7, r6 <== NOT EXECUTED
}
}
return r_chain;
}
3000a990: e1a00007 mov r0, r7 <== NOT EXECUTED
3000a994: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3001199c <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
3001199c: 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 ) )
300119a0: e2508000 subs r8, r0, #0
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
300119a4: e1a04001 mov r4, r1 300119a8: e1a06003 mov r6, r3
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
300119ac: 03a00003 moveq r0, #3
)
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
300119b0: 0a000024 beq 30011a48 <rtems_barrier_create+0xac>
return RTEMS_INVALID_NAME;
if ( !id )
300119b4: e3530000 cmp r3, #0
return RTEMS_INVALID_ADDRESS;
300119b8: 03a00009 moveq r0, #9
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
300119bc: 0a000021 beq 30011a48 <rtems_barrier_create+0xac>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
300119c0: 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;
300119c4: 03a03001 moveq r3, #1 300119c8: 058d3000 streq r3, [sp]
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
300119cc: 0a000004 beq 300119e4 <rtems_barrier_create+0x48>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
300119d0: e3a03000 mov r3, #0 <== NOT EXECUTED
if ( maximum_waiters == 0 )
300119d4: 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;
300119d8: e58d3000 str r3, [sp] <== NOT EXECUTED
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
300119dc: 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 )
300119e0: 0a000018 beq 30011a48 <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;
300119e4: e59f3060 ldr r3, [pc, #96] ; 30011a4c <rtems_barrier_create+0xb0>
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
300119e8: e58d2004 str r2, [sp, #4] 300119ec: e5932000 ldr r2, [r3]
++level;
300119f0: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
300119f4: 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 );
300119f8: e59f7050 ldr r7, [pc, #80] ; 30011a50 <rtems_barrier_create+0xb4> 300119fc: e1a00007 mov r0, r7 30011a00: ebffed07 bl 3000ce24 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
30011a04: e2505000 subs r5, r0, #0
30011a08: 1a000002 bne 30011a18 <rtems_barrier_create+0x7c>
_Thread_Enable_dispatch();
30011a0c: ebfff193 bl 3000e060 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30011a10: e3a00005 mov r0, #5 <== NOT EXECUTED 30011a14: ea00000b b 30011a48 <rtems_barrier_create+0xac> <== NOT EXECUTED
}
the_barrier->attribute_set = attribute_set;
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
30011a18: e2850014 add r0, r5, #20 30011a1c: e1a0100d mov r1, sp
if ( !the_barrier ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
30011a20: e5854010 str r4, [r5, #16]
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
30011a24: eb0001e6 bl 300121c4 <_CORE_barrier_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30011a28: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30011a2c: e5953008 ldr r3, [r5, #8] 30011a30: e1d510b8 ldrh r1, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30011a34: e7825101 str r5, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30011a38: e585800c str r8, [r5, #12]
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
30011a3c: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
30011a40: ebfff186 bl 3000e060 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30011a44: e3a00000 mov r0, #0
}
30011a48: 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: eb000156 bl 3000b378 <_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: eb000167 bl 3000b3e8 <_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: eb000166 bl 3000b438 <_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: eb000184 bl 3000b4d4 <_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
3000aab4 <rtems_clock_get_seconds_since_epoch>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
3000aab4: e92d4010 push {r4, lr}
if ( !the_interval )
3000aab8: e2504000 subs r4, r0, #0
return RTEMS_INVALID_ADDRESS;
3000aabc: 03a00009 moveq r0, #9
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000aac0: 08bd8010 popeq {r4, pc}
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
3000aac4: e59f302c ldr r3, [pc, #44] ; 3000aaf8 <rtems_clock_get_seconds_since_epoch+0x44> 3000aac8: e5d32014 ldrb r2, [r3, #20] 3000aacc: e3520000 cmp r2, #0
3000aad0: 0a000006 beq 3000aaf0 <rtems_clock_get_seconds_since_epoch+0x3c>
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
3000aad4: e8930003 ldm r3, {r0, r1}
3000aad8: e59f201c ldr r2, [pc, #28] ; 3000aafc <rtems_clock_get_seconds_since_epoch+0x48>
3000aadc: e3a03000 mov r3, #0
3000aae0: eb004a43 bl 3001d3f4 <__divdi3>
3000aae4: e5840000 str r0, [r4]
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
return RTEMS_SUCCESSFUL;
3000aae8: e3a00000 mov r0, #0
3000aaec: e8bd8010 pop {r4, pc}
{
if ( !the_interval )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
3000aaf0: e3a0000b mov r0, #11 <== NOT EXECUTED
*the_interval = _TOD_Seconds_since_epoch();
return RTEMS_SUCCESSFUL;
}
3000aaf4: 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: eb00435f bl 3001a930 <__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
30017708 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
30017708: e92d40d3 push {r0, r1, r4, r6, r7, lr} <== NOT EXECUTED
if ( !time )
3001770c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30017710: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
30017714: 0a000017 beq 30017778 <rtems_clock_get_tod_timeval+0x70> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
30017718: e59f105c ldr r1, [pc, #92] ; 3001777c <rtems_clock_get_tod_timeval+0x74><== NOT EXECUTED 3001771c: e5d13014 ldrb r3, [r1, #20] <== NOT EXECUTED 30017720: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30017724: 03a0000b moveq r0, #11 <== NOT EXECUTED
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
30017728: 0a000012 beq 30017778 <rtems_clock_get_tod_timeval+0x70> <== NOT EXECUTED
)
{
Timestamp_Control snapshot_as_timestamp;
Timestamp_Control *snapshot_as_timestamp_ptr;
snapshot_as_timestamp_ptr =
3001772c: e1a0000d mov r0, sp <== NOT EXECUTED 30017730: ebffd688 bl 3000d158 <_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);
30017734: e59f2044 ldr r2, [pc, #68] ; 30017780 <rtems_clock_get_tod_timeval+0x78><== NOT EXECUTED
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
30017738: e89000c0 ldm r0, {r6, r7} <== NOT EXECUTED
3001773c: e3a03000 mov r3, #0 <== NOT EXECUTED
30017740: e1a00006 mov r0, r6 <== NOT EXECUTED
30017744: e1a01007 mov r1, r7 <== NOT EXECUTED
30017748: ebffb839 bl 30005834 <__divdi3> <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
3001774c: e59f202c ldr r2, [pc, #44] ; 30017780 <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);
30017750: e5840000 str r0, [r4] <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
30017754: e3a03000 mov r3, #0 <== NOT EXECUTED 30017758: e1a00006 mov r0, r6 <== NOT EXECUTED 3001775c: e1a01007 mov r1, r7 <== NOT EXECUTED 30017760: eb004db5 bl 3002ae3c <__moddi3> <== NOT EXECUTED 30017764: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 30017768: e3a03000 mov r3, #0 <== NOT EXECUTED 3001776c: ebffb830 bl 30005834 <__divdi3> <== NOT EXECUTED 30017770: e5840004 str r0, [r4, #4] <== NOT EXECUTED
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
30017774: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30017778: e8bd80dc pop {r2, r3, r4, r6, r7, pc} <== NOT EXECUTED
30026880 <rtems_clock_get_uptime>:
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
30026880: e3500000 cmp r0, #0 <== NOT EXECUTED
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
30026884: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !uptime )
30026888: 0a000002 beq 30026898 <rtems_clock_get_uptime+0x18> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
3002688c: eb000234 bl 30027164 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30026890: e3a00000 mov r0, #0 <== NOT EXECUTED
30026894: 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;
30026898: e3a00009 mov r0, #9 <== NOT EXECUTED
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
3002689c: 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: eb005be3 bl 3002ce24 <__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: eb0011b8 bl 3001a598 <_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: eb005bd5 bl 3002ce24 <__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: eb005d0a bl 3002d310 <__moddi3> <== NOT EXECUTED 30015ee4: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 30015ee8: e3a03000 mov r3, #0 <== NOT EXECUTED 30015eec: eb005bcc bl 3002ce24 <__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: eb000534 bl 3000b0c4 <_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: eb000e89 bl 3000d620 <_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: 0b000aba bleq 3000c710 <_Thread_Dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
30009c24: e3a00000 mov r0, #0
30009c28: e49df004 pop {pc} ; (ldr pc, [sp], #4)
3000df54 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000df54: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Extension_Control *the_extension;
if ( !id )
3000df58: e2527000 subs r7, r2, #0
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000df5c: e1a05000 mov r5, r0 3000df60: e1a08001 mov r8, r1
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000df64: 03a00009 moveq r0, #9
rtems_id *id
)
{
Extension_Control *the_extension;
if ( !id )
3000df68: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
3000df6c: e3550000 cmp r5, #0
3000df70: 0a00001c beq 3000dfe8 <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;
3000df74: e59f3074 ldr r3, [pc, #116] ; 3000dff0 <rtems_extension_create+0x9c> 3000df78: e5932000 ldr r2, [r3]
++level;
3000df7c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000df80: 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 );
3000df84: e59f6068 ldr r6, [pc, #104] ; 3000dff4 <rtems_extension_create+0xa0> 3000df88: e1a00006 mov r0, r6 3000df8c: eb00036a bl 3000ed3c <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
3000df90: e2504000 subs r4, r0, #0
3000df94: 1a000002 bne 3000dfa4 <rtems_extension_create+0x50>
_Thread_Enable_dispatch();
3000df98: eb00083d bl 30010094 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000df9c: e3a00005 mov r0, #5 <== NOT EXECUTED
3000dfa0: 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;
3000dfa4: e284c024 add ip, r4, #36 ; 0x24
3000dfa8: e1a0e008 mov lr, r8
3000dfac: e8be000f ldm lr!, {r0, r1, r2, r3}
3000dfb0: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000dfb4: e89e000f ldm lr, {r0, r1, r2, r3}
3000dfb8: e88c000f stm ip, {r0, r1, r2, r3}
_User_extensions_Add_set( extension );
3000dfbc: e2840010 add r0, r4, #16 3000dfc0: eb000aa0 bl 30010a48 <_User_extensions_Add_set>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000dfc4: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000dfc8: e5943008 ldr r3, [r4, #8] 3000dfcc: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000dfd0: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000dfd4: e584500c str r5, [r4, #12]
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
3000dfd8: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
3000dfdc: eb00082c bl 30010094 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000dfe0: e3a00000 mov r0, #0
3000dfe4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000dfe8: e3a00003 mov r0, #3 <== NOT EXECUTED
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000dfec: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c658 <rtems_extension_ident>:
rtems_status_code rtems_extension_ident(
rtems_name name,
rtems_id *id
)
{
3000c658: e1a02000 mov r2, r0 <== NOT EXECUTED
3000c65c: e1a03001 mov r3, r1 <== NOT EXECUTED
3000c660: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
status = _Objects_Name_to_id_u32(
3000c664: e1a01002 mov r1, r2 <== NOT EXECUTED 3000c668: e59f0010 ldr r0, [pc, #16] ; 3000c680 <rtems_extension_ident+0x28><== NOT EXECUTED 3000c66c: e3e02102 mvn r2, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000c670: eb0004b9 bl 3000d95c <_Objects_Name_to_id_u32> <== NOT EXECUTED
OBJECTS_SEARCH_LOCAL_NODE,
id
);
return _Status_Object_name_errors_to_status[ status ];
}
3000c674: e59f3008 ldr r3, [pc, #8] ; 3000c684 <rtems_extension_ident+0x2c><== NOT EXECUTED
3000c678: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
3000c67c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c598 <rtems_get_version_string>:
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
}
3000c598: e59f0000 ldr r0, [pc] ; 3000c5a0 <rtems_get_version_string+0x8><== NOT EXECUTED 3000c59c: 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
300115d4 <rtems_io_close>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300115d4: e59fc044 ldr ip, [pc, #68] ; 30011620 <rtems_io_close+0x4c>
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300115d8: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300115dc: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300115e0: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300115e4: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
300115e8: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300115ec: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
300115f0: e59fc02c ldr ip, [pc, #44] ; 30011624 <rtems_io_close+0x50> 300115f4: e3a04018 mov r4, #24 300115f8: e59cc000 ldr ip, [ip] 300115fc: e023c394 mla r3, r4, r3, ip 30011600: e5933008 ldr r3, [r3, #8]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30011604: e3530000 cmp r3, #0
30011608: 0a000002 beq 30011618 <rtems_io_close+0x44>
3001160c: e1a0e00f mov lr, pc
30011610: e12fff13 bx r3
30011614: e8bd8010 pop {r4, pc}
30011618: e1a00003 mov r0, r3 <== NOT EXECUTED
}
3001161c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30011628 <rtems_io_control>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011628: e59fc044 ldr ip, [pc, #68] ; 30011674 <rtems_io_control+0x4c>
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
3001162c: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011630: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011634: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011638: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
3001163c: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011640: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
30011644: e59fc02c ldr ip, [pc, #44] ; 30011678 <rtems_io_control+0x50> 30011648: e3a04018 mov r4, #24 3001164c: e59cc000 ldr ip, [ip] 30011650: e023c394 mla r3, r4, r3, ip 30011654: e5933014 ldr r3, [r3, #20]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30011658: e3530000 cmp r3, #0
3001165c: 0a000002 beq 3001166c <rtems_io_control+0x44>
30011660: e1a0e00f mov lr, pc
30011664: e12fff13 bx r3
30011668: e8bd8010 pop {r4, pc}
3001166c: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30011670: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3001167c <rtems_io_open>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001167c: e59fc044 ldr ip, [pc, #68] ; 300116c8 <rtems_io_open+0x4c>
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011680: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011684: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011688: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001168c: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30011690: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011694: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
30011698: e59fc02c ldr ip, [pc, #44] ; 300116cc <rtems_io_open+0x50> 3001169c: e3a04018 mov r4, #24 300116a0: e59cc000 ldr ip, [ip] 300116a4: e023c394 mla r3, r4, r3, ip 300116a8: e5933004 ldr r3, [r3, #4]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
300116ac: e3530000 cmp r3, #0
300116b0: 0a000002 beq 300116c0 <rtems_io_open+0x44>
300116b4: e1a0e00f mov lr, pc
300116b8: e12fff13 bx r3
300116bc: e8bd8010 pop {r4, pc}
300116c0: e1a00003 mov r0, r3 <== NOT EXECUTED
}
300116c4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300116d0 <rtems_io_read>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300116d0: e59fc044 ldr ip, [pc, #68] ; 3001171c <rtems_io_read+0x4c>
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300116d4: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300116d8: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300116dc: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300116e0: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
300116e4: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300116e8: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
300116ec: e59fc02c ldr ip, [pc, #44] ; 30011720 <rtems_io_read+0x50> 300116f0: e3a04018 mov r4, #24 300116f4: e59cc000 ldr ip, [ip] 300116f8: e023c394 mla r3, r4, r3, ip 300116fc: e593300c ldr r3, [r3, #12]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30011700: e3530000 cmp r3, #0
30011704: 0a000002 beq 30011714 <rtems_io_read+0x44>
30011708: e1a0e00f mov lr, pc
3001170c: e12fff13 bx r3
30011710: e8bd8010 pop {r4, pc}
30011714: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30011718: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000beb4 <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
)
{
3000beb4: e92d4010 push {r4, lr}
3000beb8: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000bebc: e59f0158 ldr r0, [pc, #344] ; 3000c01c <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;
3000bec0: e59f3158 ldr r3, [pc, #344] ; 3000c020 <rtems_io_register_driver+0x16c>
if ( rtems_interrupt_is_in_progress() )
3000bec4: 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;
3000bec8: e5933000 ldr r3, [r3]
if ( rtems_interrupt_is_in_progress() )
3000becc: e3500000 cmp r0, #0
return RTEMS_CALLED_FROM_ISR;
3000bed0: 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() )
3000bed4: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
3000bed8: e3520000 cmp r2, #0
3000bedc: 0a000041 beq 3000bfe8 <rtems_io_register_driver+0x134>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
3000bee0: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
3000bee4: e5823000 str r3, [r2]
if ( driver_table == NULL )
3000bee8: 0a00003e beq 3000bfe8 <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;
3000beec: e5910000 ldr r0, [r1] 3000bef0: e3500000 cmp r0, #0
3000bef4: 1a00003f bne 3000bff8 <rtems_io_register_driver+0x144>
3000bef8: e5910004 ldr r0, [r1, #4] 3000befc: e3500000 cmp r0, #0
3000bf00: 1a00003c bne 3000bff8 <rtems_io_register_driver+0x144>
3000bf04: ea000037 b 3000bfe8 <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;
3000bf08: e59f3114 ldr r3, [pc, #276] ; 3000c024 <rtems_io_register_driver+0x170> 3000bf0c: e5930000 ldr r0, [r3]
++level;
3000bf10: e2800001 add r0, r0, #1
_Thread_Dispatch_disable_level = level;
3000bf14: e5830000 str r0, [r3]
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
3000bf18: e3540000 cmp r4, #0 3000bf1c: e59f0104 ldr r0, [pc, #260] ; 3000c028 <rtems_io_register_driver+0x174>
3000bf20: 1a000010 bne 3000bf68 <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;
3000bf24: e59f30f4 ldr r3, [pc, #244] ; 3000c020 <rtems_io_register_driver+0x16c> 3000bf28: e593c000 ldr ip, [r3] 3000bf2c: e5903000 ldr r3, [r0] 3000bf30: ea000006 b 3000bf50 <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;
3000bf34: e5930000 ldr r0, [r3] 3000bf38: e3500000 cmp r0, #0
3000bf3c: 1a000030 bne 3000c004 <rtems_io_register_driver+0x150>
3000bf40: e5930004 ldr r0, [r3, #4] 3000bf44: e3500000 cmp r0, #0
3000bf48: 1a00002d bne 3000c004 <rtems_io_register_driver+0x150>
3000bf4c: ea000001 b 3000bf58 <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 ) {
3000bf50: e154000c cmp r4, ip
3000bf54: 1afffff6 bne 3000bf34 <rtems_io_register_driver+0x80>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
3000bf58: e154000c cmp r4, ip
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000bf5c: e5824000 str r4, [r2]
if ( m != n )
3000bf60: 1a000011 bne 3000bfac <rtems_io_register_driver+0xf8>
3000bf64: ea000029 b 3000c010 <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;
3000bf68: e3a03018 mov r3, #24 <== NOT EXECUTED 3000bf6c: e0030394 mul r3, r4, r3 <== NOT EXECUTED 3000bf70: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000bf74: 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;
3000bf78: e7903003 ldr r3, [r0, r3] <== NOT EXECUTED 3000bf7c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf80: 13a03000 movne r3, #0 <== NOT EXECUTED 3000bf84: 1a000002 bne 3000bf94 <rtems_io_register_driver+0xe0> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
}
rtems_status_code rtems_io_register_driver(
3000bf88: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 3000bf8c: e2733001 rsbs r3, r3, #1 <== NOT EXECUTED 3000bf90: 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 ) ) {
3000bf94: e3530000 cmp r3, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
3000bf98: 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 ) ) {
3000bf9c: 1a000002 bne 3000bfac <rtems_io_register_driver+0xf8> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000bfa0: eb0007be bl 3000dea0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3000bfa4: e3a0000c mov r0, #12 <== NOT EXECUTED
3000bfa8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
3000bfac: e59f3074 ldr r3, [pc, #116] ; 3000c028 <rtems_io_register_driver+0x174>
3000bfb0: e3a0c018 mov ip, #24
3000bfb4: e5933000 ldr r3, [r3]
3000bfb8: e1a0e001 mov lr, r1
3000bfbc: e02c3c94 mla ip, r4, ip, r3
3000bfc0: e8be000f ldm lr!, {r0, r1, r2, r3}
3000bfc4: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000bfc8: e89e0003 ldm lr, {r0, r1}
3000bfcc: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
3000bfd0: eb0007b2 bl 3000dea0 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
3000bfd4: e3a01000 mov r1, #0 3000bfd8: e1a00004 mov r0, r4 3000bfdc: e1a02001 mov r2, r1
}
3000bfe0: e8bd4010 pop {r4, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
3000bfe4: ea001ed5 b 30013b40 <rtems_io_initialize>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
3000bfe8: e3a00009 mov r0, #9 <== NOT EXECUTED
3000bfec: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
3000bff0: e3a0000a mov r0, #10 <== NOT EXECUTED
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
3000bff4: 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 )
3000bff8: e1540003 cmp r4, r3
3000bffc: 2afffffb bcs 3000bff0 <rtems_io_register_driver+0x13c>
3000c000: eaffffc0 b 3000bf08 <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 ) {
3000c004: e2844001 add r4, r4, #1 3000c008: e2833018 add r3, r3, #24 3000c00c: eaffffcf b 3000bf50 <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();
3000c010: eb0007a2 bl 3000dea0 <_Thread_Enable_dispatch> <== NOT EXECUTED
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
3000c014: 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;
3000c018: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c02c <rtems_io_unregister_driver>:
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000c02c: e59f305c ldr r3, [pc, #92] ; 3000c090 <rtems_io_unregister_driver+0x64>
#include <string.h>
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
3000c030: e92d4010 push {r4, lr}
if ( rtems_interrupt_is_in_progress() )
3000c034: e5934000 ldr r4, [r3] 3000c038: e3540000 cmp r4, #0
return RTEMS_CALLED_FROM_ISR;
3000c03c: 13a00012 movne r0, #18
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000c040: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
3000c044: e59f3048 ldr r3, [pc, #72] ; 3000c094 <rtems_io_unregister_driver+0x68> 3000c048: e5933000 ldr r3, [r3] 3000c04c: e1500003 cmp r0, r3
3000c050: 2a00000c bcs 3000c088 <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;
3000c054: e59f303c ldr r3, [pc, #60] ; 3000c098 <rtems_io_unregister_driver+0x6c> 3000c058: e5932000 ldr r2, [r3]
++level;
3000c05c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000c060: e5832000 str r2, [r3]
_Thread_Disable_dispatch();
memset(
3000c064: e59f3030 ldr r3, [pc, #48] ; 3000c09c <rtems_io_unregister_driver+0x70>
&_IO_Driver_address_table[major],
3000c068: 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(
3000c06c: e5933000 ldr r3, [r3] 3000c070: e1a01004 mov r1, r4 3000c074: e0203092 mla r0, r2, r0, r3 3000c078: eb00295e bl 300165f8 <memset>
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
3000c07c: eb000787 bl 3000dea0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c080: e1a00004 mov r0, r4
3000c084: e8bd8010 pop {r4, pc}
}
return RTEMS_UNSATISFIED;
3000c088: e3a0000d mov r0, #13 <== NOT EXECUTED
}
3000c08c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30011724 <rtems_io_write>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011724: e59fc044 ldr ip, [pc, #68] ; 30011770 <rtems_io_write+0x4c>
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011728: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001172c: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011730: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011734: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30011738: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001173c: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
30011740: e59fc02c ldr ip, [pc, #44] ; 30011774 <rtems_io_write+0x50> 30011744: e3a04018 mov r4, #24 30011748: e59cc000 ldr ip, [ip] 3001174c: e023c394 mla r3, r4, r3, ip 30011750: e5933010 ldr r3, [r3, #16]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30011754: e3530000 cmp r3, #0
30011758: 0a000002 beq 30011768 <rtems_io_write+0x44>
3001175c: e1a0e00f mov lr, pc
30011760: e12fff13 bx r3
30011764: e8bd8010 pop {r4, pc}
30011768: e1a00003 mov r0, r3 <== NOT EXECUTED
}
3001176c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cacc <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)
{
3000cacc: 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 )
3000cad0: e2508000 subs r8, r0, #0 <== NOT EXECUTED
3000cad4: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000cad8: e59f4048 ldr r4, [pc, #72] ; 3000cb28 <rtems_iterate_over_all_threads+0x5c><== NOT EXECUTED
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
3000cadc: e284700c add r7, r4, #12 <== NOT EXECUTED
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
3000cae0: e5b43004 ldr r3, [r4, #4]! <== NOT EXECUTED 3000cae4: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED
if ( !information )
3000cae8: e3560000 cmp r6, #0 <== NOT EXECUTED 3000caec: 13a05001 movne r5, #1 <== NOT EXECUTED 3000caf0: 1a000006 bne 3000cb10 <rtems_iterate_over_all_threads+0x44><== NOT EXECUTED 3000caf4: ea000008 b 3000cb1c <rtems_iterate_over_all_threads+0x50> <== NOT EXECUTED
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
3000caf8: e596301c ldr r3, [r6, #28] <== NOT EXECUTED 3000cafc: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED
if ( !the_thread )
3000cb00: e3500000 cmp r0, #0 <== NOT EXECUTED
continue;
(*routine)(the_thread);
3000cb04: 11a0e00f movne lr, pc <== NOT EXECUTED 3000cb08: 112fff18 bxne r8 <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000cb0c: e2855001 add r5, r5, #1 <== NOT EXECUTED 3000cb10: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 3000cb14: e1550003 cmp r5, r3 <== NOT EXECUTED 3000cb18: 9afffff6 bls 3000caf8 <rtems_iterate_over_all_threads+0x2c><== NOT EXECUTED
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
3000cb1c: e1540007 cmp r4, r7 <== NOT EXECUTED
3000cb20: 1affffee bne 3000cae0 <rtems_iterate_over_all_threads+0x14><== NOT EXECUTED
3000cb24: 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: eb0014e5 bl 3001ba7c <_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: eb000db4 bl 30019de0 <_CORE_message_queue_Broadcast>
3001670c: e1a04000 mov r4, r0
NULL,
#endif
count
);
_Thread_Enable_dispatch();
30016710: eb001866 bl 3001c8b0 <_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: eb0017ab bl 3001771c <_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: eb000c6d bl 30014a30 <_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: eb0004ad bl 30012b64 <_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: eb000879 bl 30013aa8 <_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: eb000c5a bl 30014a30 <_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: eb000c50 bl 30014a30 <_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: eb001464 bl 3001ba7c <_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: eb0017ea bl 3001c8b0 <_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: eb0008a6 bl 30013bfc <_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: eb0004a4 bl 30012c30 <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
3001199c: eb000c23 bl 30014a30 <_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}
30009ff0 <rtems_object_api_maximum_class>:
int rtems_object_api_maximum_class(
int api
)
{
return _Objects_API_maximum_class(api);
30009ff0: ea0005b2 b 3000b6c0 <_Objects_API_maximum_class> <== NOT EXECUTED
30009ff4 <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 )
30009ff4: e2400001 sub r0, r0, #1 <== NOT EXECUTED
int api
)
{
if ( _Objects_Is_api_valid( api ) )
return 1;
return -1;
30009ff8: e3500003 cmp r0, #3 <== NOT EXECUTED
}
30009ffc: 33a00001 movcc r0, #1 <== NOT EXECUTED 3000a000: 23e00000 mvncs r0, #0 <== NOT EXECUTED 3000a004: e12fff1e bx lr <== NOT EXECUTED
3000a008 <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
3000a008: e3500001 cmp r0, #1 <== NOT EXECUTED
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
3000a00c: 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 )
3000a010: 0a000005 beq 3000a02c <rtems_object_get_api_class_name+0x24><== NOT EXECUTED
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
3000a014: e3500002 cmp r0, #2 <== NOT EXECUTED 3000a018: 0a000005 beq 3000a034 <rtems_object_get_api_class_name+0x2c><== NOT EXECUTED
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
3000a01c: e3500003 cmp r0, #3 <== NOT EXECUTED
api_assoc = rtems_object_api_posix_assoc;
3000a020: 059f0034 ldreq r0, [pc, #52] ; 3000a05c <rtems_object_get_api_class_name+0x54><== NOT EXECUTED
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
3000a024: 1a000008 bne 3000a04c <rtems_object_get_api_class_name+0x44><== NOT EXECUTED 3000a028: ea000002 b 3000a038 <rtems_object_get_api_class_name+0x30> <== 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;
3000a02c: e59f002c ldr r0, [pc, #44] ; 3000a060 <rtems_object_get_api_class_name+0x58><== NOT EXECUTED 3000a030: ea000000 b 3000a038 <rtems_object_get_api_class_name+0x30> <== NOT EXECUTED
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
3000a034: e59f0028 ldr r0, [pc, #40] ; 3000a064 <rtems_object_get_api_class_name+0x5c><== 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 );
3000a038: eb001178 bl 3000e620 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( class_assoc )
3000a03c: e3500000 cmp r0, #0 <== NOT EXECUTED
return class_assoc->name;
3000a040: 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 )
3000a044: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
3000a048: ea000001 b 3000a054 <rtems_object_get_api_class_name+0x4c> <== 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";
3000a04c: e59f0014 ldr r0, [pc, #20] ; 3000a068 <rtems_object_get_api_class_name+0x60><== NOT EXECUTED
3000a050: 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";
3000a054: e59f0010 ldr r0, [pc, #16] ; 3000a06c <rtems_object_get_api_class_name+0x64><== NOT EXECUTED
}
3000a058: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a070 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
3000a070: e1a01000 mov r1, r0 <== NOT EXECUTED
3000a074: 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 );
3000a078: e59f0010 ldr r0, [pc, #16] ; 3000a090 <rtems_object_get_api_name+0x20><== NOT EXECUTED 3000a07c: eb001167 bl 3000e620 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( api_assoc )
3000a080: e3500000 cmp r0, #0 <== NOT EXECUTED
return api_assoc->name;
3000a084: 15900000 ldrne r0, [r0] <== NOT EXECUTED
return "BAD CLASS";
3000a088: 059f0004 ldreq r0, [pc, #4] ; 3000a094 <rtems_object_get_api_name+0x24><== NOT EXECUTED
}
3000a08c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000baa4 <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
)
{
3000baa4: e92d4010 push {r4, lr} <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000baa8: e2524000 subs r4, r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000baac: 03a00009 moveq r0, #9 <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000bab0: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
3000bab4: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000bab8: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000babc: eb0006d4 bl 3000d614 <_Objects_Get_information> <== NOT EXECUTED
if ( !obj_info )
3000bac0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bac4: 0a000014 beq 3000bb1c <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;
3000bac8: 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;
3000bacc: 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;
3000bad0: e5843000 str r3, [r4] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000bad4: 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++ )
3000bad8: 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;
3000badc: e5843004 str r3, [r4, #4] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000bae0: e5d03012 ldrb r3, [r0, #18] <== NOT EXECUTED
info->maximum = obj_info->maximum;
3000bae4: 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;
3000bae8: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000baec: e3a03001 mov r3, #1 <== NOT EXECUTED 3000baf0: ea000004 b 3000bb08 <rtems_object_get_class_information+0x64><== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000baf4: e590c01c ldr ip, [r0, #28] <== NOT EXECUTED 3000baf8: 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++ )
3000bafc: e2833001 add r3, r3, #1 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000bb00: e35c0000 cmp ip, #0 <== NOT EXECUTED
unallocated++;
3000bb04: 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++ )
3000bb08: e1530001 cmp r3, r1 <== NOT EXECUTED 3000bb0c: 9afffff8 bls 3000baf4 <rtems_object_get_class_information+0x50><== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
3000bb10: e5842010 str r2, [r4, #16] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000bb14: e3a00000 mov r0, #0 <== NOT EXECUTED
3000bb18: 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;
3000bb1c: e3a0000a mov r0, #10 <== NOT EXECUTED
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
3000bb20: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3001546c <rtems_object_get_name>:
Objects_Id id,
size_t length,
char *name
)
{
return _Objects_Get_name_as_string( id, length, name );
3001546c: ea00033a b 3001615c <_Objects_Get_name_as_string> <== NOT EXECUTED
3000bb28 <rtems_object_id_api_maximum>:
#undef rtems_object_id_api_maximum
int rtems_object_id_api_maximum(void)
{
return OBJECTS_APIS_LAST;
}
3000bb28: e3a00003 mov r0, #3 <== NOT EXECUTED 3000bb2c: e12fff1e bx lr <== NOT EXECUTED
3000bb30 <rtems_object_id_api_minimum>:
#undef rtems_object_id_api_minimum
int rtems_object_id_api_minimum(void)
{
return OBJECTS_INTERNAL_API;
}
3000bb30: e3a00001 mov r0, #1 <== NOT EXECUTED 3000bb34: e12fff1e bx lr <== NOT EXECUTED
3000bb38 <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);
3000bb38: e1a00c20 lsr r0, r0, #24 <== NOT EXECUTED
int rtems_object_id_get_api(
rtems_id id
)
{
return _Objects_Get_API( id );
}
3000bb3c: e2000007 and r0, r0, #7 <== NOT EXECUTED 3000bb40: e12fff1e bx lr <== NOT EXECUTED
3000bb44 <rtems_object_id_get_class>:
int rtems_object_id_get_class(
rtems_id id
)
{
return _Objects_Get_class( id );
}
3000bb44: e1a00da0 lsr r0, r0, #27 <== NOT EXECUTED 3000bb48: e12fff1e bx lr <== NOT EXECUTED
3000bb4c <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 );
3000bb4c: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
}
3000bb50: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 3000bb54: e12fff1e bx lr <== NOT EXECUTED
3000bb58 <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;
3000bb58: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
int rtems_object_id_get_node(
rtems_id id
)
{
return _Objects_Get_node( id );
}
3000bb5c: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 3000bb60: e12fff1e bx lr <== NOT EXECUTED
3000a09c <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
3000a09c: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000a0a0: e2515000 subs r5, r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000a0a4: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000a0a8: 0a000016 beq 3000a108 <rtems_object_set_name+0x6c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000a0ac: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a0b0: 059f3054 ldreq r3, [pc, #84] ; 3000a10c <rtems_object_set_name+0x70><== NOT EXECUTED 3000a0b4: 11a04000 movne r4, r0 <== NOT EXECUTED 3000a0b8: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED 3000a0bc: 05934008 ldreq r4, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3000a0c0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a0c4: eb00064e bl 3000ba04 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
3000a0c8: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000a0cc: 0a00000c beq 3000a104 <rtems_object_set_name+0x68> <== NOT EXECUTED
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
3000a0d0: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a0d4: e1a0200d mov r2, sp <== NOT EXECUTED 3000a0d8: eb0006c3 bl 3000bbec <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000a0dc: 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 );
3000a0e0: e1a01000 mov r1, r0 <== NOT EXECUTED
switch ( location ) {
3000a0e4: e3540000 cmp r4, #0 <== NOT EXECUTED 3000a0e8: 1a000005 bne 3000a104 <rtems_object_set_name+0x68> <== NOT EXECUTED
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
3000a0ec: e1a02005 mov r2, r5 <== NOT EXECUTED 3000a0f0: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a0f4: eb000712 bl 3000bd44 <_Objects_Set_name> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a0f8: eb000a55 bl 3000ca54 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a0fc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a100: ea000000 b 3000a108 <rtems_object_set_name+0x6c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a104: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000a108: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000b58c <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000b58c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
3000b590: e2508000 subs r8, r0, #0
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000b594: e1a05001 mov r5, r1 3000b598: e1a09002 mov r9, r2 3000b59c: e1a0a003 mov sl, r3
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000b5a0: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
3000b5a4: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_NAME;
if ( !starting_address )
3000b5a8: e3510000 cmp r1, #0
3000b5ac: 0a000030 beq 3000b674 <rtems_partition_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( !id )
3000b5b0: e59d2028 ldr r2, [sp, #40] ; 0x28 3000b5b4: e3520000 cmp r2, #0
3000b5b8: 0a00002d beq 3000b674 <rtems_partition_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
3000b5bc: e3590000 cmp r9, #0 3000b5c0: 13530000 cmpne r3, #0
3000b5c4: 0a00002c beq 3000b67c <rtems_partition_create+0xf0>
3000b5c8: e1590003 cmp r9, r3
3000b5cc: 3a00002a bcc 3000b67c <rtems_partition_create+0xf0>
3000b5d0: e3130003 tst r3, #3
3000b5d4: 1a000028 bne 3000b67c <rtems_partition_create+0xf0>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
3000b5d8: e2116007 ands r6, r1, #7
3000b5dc: 1a000028 bne 3000b684 <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;
3000b5e0: e59f30a4 ldr r3, [pc, #164] ; 3000b68c <rtems_partition_create+0x100> 3000b5e4: e5932000 ldr r2, [r3]
++level;
3000b5e8: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000b5ec: 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 );
3000b5f0: e59f7098 ldr r7, [pc, #152] ; 3000b690 <rtems_partition_create+0x104> 3000b5f4: e1a00007 mov r0, r7 3000b5f8: eb0006b4 bl 3000d0d0 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
3000b5fc: e2504000 subs r4, r0, #0
3000b600: 1a000002 bne 3000b610 <rtems_partition_create+0x84>
_Thread_Enable_dispatch();
3000b604: eb000b77 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000b608: e3a00005 mov r0, #5 <== NOT EXECUTED
3000b60c: 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;
3000b610: e59d3024 ldr r3, [sp, #36] ; 0x24
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
3000b614: 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;
3000b618: e584301c str r3, [r4, #28]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
3000b61c: e5845010 str r5, [r4, #16]
the_partition->length = length;
3000b620: e5849014 str r9, [r4, #20]
the_partition->buffer_size = buffer_size;
3000b624: e584a018 str sl, [r4, #24]
the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0;
3000b628: e5846020 str r6, [r4, #32]
_Chain_Initialize( &the_partition->Memory, starting_address,
3000b62c: e1a00009 mov r0, r9 3000b630: eb004443 bl 3001c744 <__aeabi_uidiv> 3000b634: e284b024 add fp, r4, #36 ; 0x24 3000b638: e1a02000 mov r2, r0 3000b63c: e1a01005 mov r1, r5 3000b640: e1a0000b mov r0, fp 3000b644: e1a0300a mov r3, sl 3000b648: eb000439 bl 3000c734 <_Chain_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b64c: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000b650: e1d410b8 ldrh r1, [r4, #8] 3000b654: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b658: e7824101 str r4, [r2, r1, lsl #2]
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
3000b65c: e59d2028 ldr r2, [sp, #40] ; 0x28
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000b660: e584800c str r8, [r4, #12] 3000b664: e5823000 str r3, [r2]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
3000b668: eb000b5e bl 3000e3e8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b66c: e1a00006 mov r0, r6
3000b670: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000b674: e3a00009 mov r0, #9 <== NOT EXECUTED
3000b678: 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;
3000b67c: e3a00008 mov r0, #8 <== NOT EXECUTED
3000b680: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
3000b684: e3a00009 mov r0, #9 <== NOT EXECUTED
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000b688: 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: eb00139f bl 3001ba7c <_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: eb001284 bl 3001b63c <_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: eb00132e bl 3001b8f0 <_Objects_Free>
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
30016c34: eb00171d bl 3001c8b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30016c38: e1a00005 mov r0, r5 30016c3c: ea000001 b 30016c48 <rtems_partition_delete+0x60>
}
_Thread_Enable_dispatch();
30016c40: eb00171a bl 3001c8b0 <_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: eb001359 bl 3001ba7c <_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: eb00556f bl 3002c31c <__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: eb000bf3 bl 30019d40 <_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: eb0016cb bl 3001c8b0 <_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: eb0016c8 bl 3001c8b0 <_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: eb001502 bl 3001b5b4 <_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: eb0019be bl 3001c8b0 <_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: eb0019b1 bl 3001c8b0 <_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: eb001333 bl 3001ba7c <_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: eb0016b5 bl 3001c8b0 <_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: eb001a5e bl 3001d764 <_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: eb0016aa bl 3001c8b0 <_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}
3000b694 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000b694: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000b698: e2508000 subs r8, r0, #0
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000b69c: e1a06001 mov r6, r1
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000b6a0: 03a00003 moveq r0, #3
rtems_id *id
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000b6a4: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_NAME;
if ( !id )
3000b6a8: e3510000 cmp r1, #0
3000b6ac: 0a000027 beq 3000b750 <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;
3000b6b0: e59f30a0 ldr r3, [pc, #160] ; 3000b758 <rtems_rate_monotonic_create+0xc4> 3000b6b4: e5932000 ldr r2, [r3]
++level;
3000b6b8: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000b6bc: 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 *)
3000b6c0: e59f7094 ldr r7, [pc, #148] ; 3000b75c <rtems_rate_monotonic_create+0xc8> 3000b6c4: e1a00007 mov r0, r7 3000b6c8: eb000680 bl 3000d0d0 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
3000b6cc: e2504000 subs r4, r0, #0
3000b6d0: 1a000002 bne 3000b6e0 <rtems_rate_monotonic_create+0x4c>
_Thread_Enable_dispatch();
3000b6d4: eb000b43 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000b6d8: e3a00005 mov r0, #5 <== NOT EXECUTED
3000b6dc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
the_period->owner = _Thread_Executing;
3000b6e0: e59f3078 ldr r3, [pc, #120] ; 3000b760 <rtems_rate_monotonic_create+0xcc>
the_period->state = RATE_MONOTONIC_INACTIVE;
3000b6e4: e3a05000 mov r5, #0
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000b6e8: 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 );
3000b6ec: e1a01005 mov r1, r5
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000b6f0: 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 );
3000b6f4: e3a02038 mov r2, #56 ; 0x38
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
the_period->state = RATE_MONOTONIC_INACTIVE;
3000b6f8: e5845038 str r5, [r4, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000b6fc: e5845018 str r5, [r4, #24]
the_watchdog->routine = routine;
3000b700: e584502c str r5, [r4, #44] ; 0x2c
the_watchdog->id = id;
3000b704: e5845030 str r5, [r4, #48] ; 0x30
the_watchdog->user_data = user_data;
3000b708: e5845034 str r5, [r4, #52] ; 0x34
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000b70c: e2840054 add r0, r4, #84 ; 0x54 3000b710: eb002275 bl 300140ec <memset>
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
3000b714: e59f2048 ldr r2, [pc, #72] ; 3000b764 <rtems_rate_monotonic_create+0xd0> 3000b718: e59f3048 ldr r3, [pc, #72] ; 3000b768 <rtems_rate_monotonic_create+0xd4>
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000b71c: e1d410b8 ldrh r1, [r4, #8] 3000b720: e584205c str r2, [r4, #92] ; 0x5c 3000b724: e5843060 str r3, [r4, #96] ; 0x60 3000b728: e5842074 str r2, [r4, #116] ; 0x74 3000b72c: e5843078 str r3, [r4, #120] ; 0x78
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b730: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000b734: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b738: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000b73c: e584800c str r8, [r4, #12]
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
3000b740: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
3000b744: eb000b27 bl 3000e3e8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b748: e1a00005 mov r0, r5
3000b74c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000b750: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000b754: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300321b4 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
300321b4: 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 )
300321b8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
300321bc: 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;
300321c0: 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 )
300321c4: 0a000062 beq 30032354 <rtems_rate_monotonic_get_statistics+0x1a0><== NOT EXECUTED 300321c8: e59f0188 ldr r0, [pc, #392] ; 30032358 <rtems_rate_monotonic_get_statistics+0x1a4><== NOT EXECUTED 300321cc: e1a01003 mov r1, r3 <== NOT EXECUTED 300321d0: e1a0200d mov r2, sp <== NOT EXECUTED 300321d4: ebff682d bl 3000c290 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300321d8: e59d8000 ldr r8, [sp] <== NOT EXECUTED 300321dc: e1a05000 mov r5, r0 <== NOT EXECUTED 300321e0: e3580000 cmp r8, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300321e4: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300321e8: 1a000059 bne 30032354 <rtems_rate_monotonic_get_statistics+0x1a0><== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
300321ec: e5953054 ldr r3, [r5, #84] ; 0x54 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300321f0: e285705c add r7, r5, #92 ; 0x5c <== NOT EXECUTED
300321f4: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
300321f8: e5843000 str r3, [r4] <== NOT EXECUTED
dst->missed_count = src->missed_count;
300321fc: 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);
30032200: e1a00006 mov r0, r6 <== NOT EXECUTED 30032204: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30032208: e1a01007 mov r1, r7 <== NOT EXECUTED 3003220c: e59f2148 ldr r2, [pc, #328] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30032210: e3a03000 mov r3, #0 <== NOT EXECUTED 30032214: eb0075da bl 3004f984 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032218: 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);
3003221c: e5840008 str r0, [r4, #8] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032220: e59f2134 ldr r2, [pc, #308] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30032224: e1a00006 mov r0, r6 <== NOT EXECUTED 30032228: e3a03000 mov r3, #0 <== NOT EXECUTED 3003222c: eb00770f bl 3004fe70 <__moddi3> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30032230: e2857064 add r7, r5, #100 ; 0x64 <== NOT EXECUTED
30032234: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
30032238: 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);
3003223c: e1a01007 mov r1, r7 <== NOT EXECUTED 30032240: e1a00006 mov r0, r6 <== NOT EXECUTED 30032244: e59f2110 ldr r2, [pc, #272] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30032248: e3a03000 mov r3, #0 <== NOT EXECUTED 3003224c: eb0075cc bl 3004f984 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032250: 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);
30032254: e5840010 str r0, [r4, #16] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032258: e59f20fc ldr r2, [pc, #252] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
3003225c: e1a00006 mov r0, r6 <== NOT EXECUTED
30032260: e3a03000 mov r3, #0 <== NOT EXECUTED
30032264: eb007701 bl 3004fe70 <__moddi3> <== NOT EXECUTED
30032268: e285706c add r7, r5, #108 ; 0x6c <== NOT EXECUTED
3003226c: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
30032270: 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);
30032274: e1a01007 mov r1, r7 <== NOT EXECUTED 30032278: e1a00006 mov r0, r6 <== NOT EXECUTED 3003227c: e59f20d8 ldr r2, [pc, #216] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30032280: e3a03000 mov r3, #0 <== NOT EXECUTED 30032284: eb0075be bl 3004f984 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032288: 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);
3003228c: e5840018 str r0, [r4, #24] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032290: e59f20c4 ldr r2, [pc, #196] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
30032294: e1a00006 mov r0, r6 <== NOT EXECUTED
30032298: e3a03000 mov r3, #0 <== NOT EXECUTED
3003229c: eb0076f3 bl 3004fe70 <__moddi3> <== NOT EXECUTED
300322a0: e2857074 add r7, r5, #116 ; 0x74 <== NOT EXECUTED
300322a4: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
300322a8: 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);
300322ac: e1a01007 mov r1, r7 <== NOT EXECUTED 300322b0: e1a00006 mov r0, r6 <== NOT EXECUTED 300322b4: e59f20a0 ldr r2, [pc, #160] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 300322b8: e3a03000 mov r3, #0 <== NOT EXECUTED 300322bc: eb0075b0 bl 3004f984 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
300322c0: 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);
300322c4: e5840020 str r0, [r4, #32] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
300322c8: e59f208c ldr r2, [pc, #140] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
300322cc: e1a00006 mov r0, r6 <== NOT EXECUTED
300322d0: e3a03000 mov r3, #0 <== NOT EXECUTED
300322d4: eb0076e5 bl 3004fe70 <__moddi3> <== NOT EXECUTED
300322d8: e285707c add r7, r5, #124 ; 0x7c <== NOT EXECUTED
300322dc: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
300322e0: 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);
300322e4: e1a01007 mov r1, r7 <== NOT EXECUTED 300322e8: e1a00006 mov r0, r6 <== NOT EXECUTED 300322ec: e59f2068 ldr r2, [pc, #104] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 300322f0: e3a03000 mov r3, #0 <== NOT EXECUTED 300322f4: eb0075a2 bl 3004f984 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
300322f8: 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);
300322fc: e5840028 str r0, [r4, #40] ; 0x28 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032300: e59f2054 ldr r2, [pc, #84] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
30032304: e1a00006 mov r0, r6 <== NOT EXECUTED
30032308: e3a03000 mov r3, #0 <== NOT EXECUTED
3003230c: eb0076d7 bl 3004fe70 <__moddi3> <== NOT EXECUTED
30032310: e2857084 add r7, r5, #132 ; 0x84 <== NOT EXECUTED
30032314: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
30032318: 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);
3003231c: e59f2038 ldr r2, [pc, #56] ; 3003235c <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30032320: e3a03000 mov r3, #0 <== NOT EXECUTED 30032324: e1a00006 mov r0, r6 <== NOT EXECUTED 30032328: e1a01007 mov r1, r7 <== NOT EXECUTED 3003232c: eb007594 bl 3004f984 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032330: e59f2024 ldr r2, [pc, #36] ; 3003235c <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);
30032334: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032338: e3a03000 mov r3, #0 <== NOT EXECUTED 3003233c: e1a00006 mov r0, r6 <== NOT EXECUTED 30032340: e1a01007 mov r1, r7 <== NOT EXECUTED 30032344: eb0076c9 bl 3004fe70 <__moddi3> <== NOT EXECUTED 30032348: 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();
3003234c: ebff6b3a bl 3000d03c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30032350: e1a00008 mov r0, r8 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30032354: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30032360 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
30032360: 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 )
30032364: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
30032368: e1a03000 mov r3, r0 <== NOT EXECUTED 3003236c: 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;
30032370: 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 )
30032374: 0a000038 beq 3003245c <rtems_rate_monotonic_get_status+0xfc><== NOT EXECUTED 30032378: e1a01003 mov r1, r3 <== NOT EXECUTED 3003237c: e28d2010 add r2, sp, #16 <== NOT EXECUTED 30032380: e59f00dc ldr r0, [pc, #220] ; 30032464 <rtems_rate_monotonic_get_status+0x104><== NOT EXECUTED 30032384: ebff67c1 bl 3000c290 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30032388: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3003238c: e1a03000 mov r3, r0 <== NOT EXECUTED 30032390: e3520000 cmp r2, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30032394: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !status )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30032398: 1a00002f bne 3003245c <rtems_rate_monotonic_get_status+0xfc><== NOT EXECUTED
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
3003239c: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
status->state = the_period->state;
300323a0: 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;
300323a4: 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 ) {
300323a8: 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;
300323ac: e5842000 str r2, [r4] <== NOT EXECUTED
status->state = the_period->state;
300323b0: 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 );
300323b4: 05843008 streq r3, [r4, #8] <== NOT EXECUTED 300323b8: 0584300c streq r3, [r4, #12] <== NOT EXECUTED
_Timespec_Set_to_zero( &status->executed_since_last_period );
300323bc: 05843010 streq r3, [r4, #16] <== NOT EXECUTED 300323c0: 05843014 streq r3, [r4, #20] <== NOT EXECUTED 300323c4: 0a000022 beq 30032454 <rtems_rate_monotonic_get_status+0xf4><== NOT EXECUTED
} else {
/*
* Grab the current status.
*/
valid_status =
300323c8: e28d1008 add r1, sp, #8 <== NOT EXECUTED 300323cc: e1a0200d mov r2, sp <== NOT EXECUTED 300323d0: eb000025 bl 3003246c <_Rate_monotonic_Get_status> <== NOT EXECUTED
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
300323d4: e3500000 cmp r0, #0 <== NOT EXECUTED 300323d8: 1a000002 bne 300323e8 <rtems_rate_monotonic_get_status+0x88><== NOT EXECUTED
_Thread_Enable_dispatch();
300323dc: ebff6b16 bl 3000d03c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
300323e0: e3a0000b mov r0, #11 <== NOT EXECUTED 300323e4: ea00001c b 3003245c <rtems_rate_monotonic_get_status+0xfc> <== NOT EXECUTED
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
300323e8: e28d7008 add r7, sp, #8 <== NOT EXECUTED
300323ec: 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);
300323f0: e59f2070 ldr r2, [pc, #112] ; 30032468 <rtems_rate_monotonic_get_status+0x108><== NOT EXECUTED 300323f4: e1a00006 mov r0, r6 <== NOT EXECUTED 300323f8: e1a01007 mov r1, r7 <== NOT EXECUTED 300323fc: e3a03000 mov r3, #0 <== NOT EXECUTED 30032400: eb00755f bl 3004f984 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032404: 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);
30032408: e5840008 str r0, [r4, #8] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3003240c: e59f2054 ldr r2, [pc, #84] ; 30032468 <rtems_rate_monotonic_get_status+0x108><== NOT EXECUTED 30032410: e1a00006 mov r0, r6 <== NOT EXECUTED 30032414: e3a03000 mov r3, #0 <== NOT EXECUTED 30032418: eb007694 bl 3004fe70 <__moddi3> <== NOT EXECUTED
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
3003241c: e89d00c0 ldm sp, {r6, r7} <== NOT EXECUTED
30032420: 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);
30032424: e59f203c ldr r2, [pc, #60] ; 30032468 <rtems_rate_monotonic_get_status+0x108><== NOT EXECUTED 30032428: e3a03000 mov r3, #0 <== NOT EXECUTED 3003242c: e1a00006 mov r0, r6 <== NOT EXECUTED 30032430: e1a01007 mov r1, r7 <== NOT EXECUTED 30032434: eb007552 bl 3004f984 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032438: 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);
3003243c: e5840010 str r0, [r4, #16] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30032440: e59f2020 ldr r2, [pc, #32] ; 30032468 <rtems_rate_monotonic_get_status+0x108><== NOT EXECUTED 30032444: e1a00006 mov r0, r6 <== NOT EXECUTED 30032448: e3a03000 mov r3, #0 <== NOT EXECUTED 3003244c: eb007687 bl 3004fe70 <__moddi3> <== NOT EXECUTED 30032450: e5840014 str r0, [r4, #20] <== NOT EXECUTED
status->since_last_period = since_last_period;
status->executed_since_last_period = executed;
#endif
}
_Thread_Enable_dispatch();
30032454: ebff6af8 bl 3000d03c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30032458: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3003245c: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30032460: e8bd80d0 pop {r4, r6, r7, pc} <== NOT EXECUTED
3003266c <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
3003266c: e92d40f1 push {r0, r4, r5, r6, r7, lr}
30032670: e1a05000 mov r5, r0
30032674: e1a04001 mov r4, r1
30032678: e59f0180 ldr r0, [pc, #384] ; 30032800 <rtems_rate_monotonic_period+0x194>
3003267c: e1a01005 mov r1, r5
30032680: e1a0200d mov r2, sp
30032684: ebff6701 bl 3000c290 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30032688: e59d3000 ldr r3, [sp] 3003268c: e1a06000 mov r6, r0 30032690: e3530000 cmp r3, #0
30032694: 1a000056 bne 300327f4 <rtems_rate_monotonic_period+0x188>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
30032698: e59f3164 ldr r3, [pc, #356] ; 30032804 <rtems_rate_monotonic_period+0x198> 3003269c: e5902040 ldr r2, [r0, #64] ; 0x40 300326a0: e5933008 ldr r3, [r3, #8] 300326a4: e1520003 cmp r2, r3
300326a8: 0a000002 beq 300326b8 <rtems_rate_monotonic_period+0x4c>
_Thread_Enable_dispatch();
300326ac: ebff6a62 bl 3000d03c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
300326b0: e3a04017 mov r4, #23 <== NOT EXECUTED 300326b4: ea00004f b 300327f8 <rtems_rate_monotonic_period+0x18c> <== NOT EXECUTED
}
if ( length == RTEMS_PERIOD_STATUS ) {
300326b8: e3540000 cmp r4, #0
300326bc: 1a000005 bne 300326d8 <rtems_rate_monotonic_period+0x6c>
switch ( the_period->state ) {
300326c0: e5903038 ldr r3, [r0, #56] ; 0x38 300326c4: e3530004 cmp r3, #4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300326c8: 959f2138 ldrls r2, [pc, #312] ; 30032808 <rtems_rate_monotonic_period+0x19c> 300326cc: 97d24003 ldrbls r4, [r2, r3]
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
300326d0: ebff6a59 bl 3000d03c <_Thread_Enable_dispatch>
return( return_value );
300326d4: ea000047 b 300327f8 <rtems_rate_monotonic_period+0x18c>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
300326d8: e10f7000 mrs r7, CPSR 300326dc: e3873080 orr r3, r7, #128 ; 0x80 300326e0: e129f003 msr CPSR_fc, r3
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
300326e4: e5903038 ldr r3, [r0, #56] ; 0x38 300326e8: e3530000 cmp r3, #0
300326ec: 1a000011 bne 30032738 <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 (
300326f0: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
the_period->next_length = length;
300326f4: e580403c str r4, [r0, #60] ; 0x3c
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
300326f8: ebffffb9 bl 300325e4 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
300326fc: e3a03002 mov r3, #2 30032700: e5863038 str r3, [r6, #56] ; 0x38
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30032704: e59f3100 ldr r3, [pc, #256] ; 3003280c <rtems_rate_monotonic_period+0x1a0>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30032708: e3a07000 mov r7, #0
the_watchdog->routine = routine;
3003270c: e586302c str r3, [r6, #44] ; 0x2c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30032710: e586401c str r4, [r6, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30032714: e59f00f4 ldr r0, [pc, #244] ; 30032810 <rtems_rate_monotonic_period+0x1a4> 30032718: e2861010 add r1, r6, #16
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3003271c: e5867018 str r7, [r6, #24]
the_watchdog->routine = routine; the_watchdog->id = id;
30032720: e5865030 str r5, [r6, #48] ; 0x30
the_watchdog->user_data = user_data;
30032724: e5867034 str r7, [r6, #52] ; 0x34
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30032728: ebff6d2f bl 3000dbec <_Watchdog_Insert>
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
3003272c: e1a04007 mov r4, r7
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
30032730: ebff6a41 bl 3000d03c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30032734: ea00002f b 300327f8 <rtems_rate_monotonic_period+0x18c>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
30032738: e3530002 cmp r3, #2
3003273c: 1a000019 bne 300327a8 <rtems_rate_monotonic_period+0x13c>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
30032740: ebffff70 bl 30032508 <_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;
30032744: e3a03001 mov r3, #1 30032748: e5863038 str r3, [r6, #56] ; 0x38
the_period->next_length = length;
3003274c: e586403c str r4, [r6, #60] ; 0x3c 30032750: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
30032754: e59f30a8 ldr r3, [pc, #168] ; 30032804 <rtems_rate_monotonic_period+0x198>
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
30032758: 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;
3003275c: e5930008 ldr r0, [r3, #8] 30032760: e5963008 ldr r3, [r6, #8] 30032764: e5803020 str r3, [r0, #32]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
30032768: ebff6c45 bl 3000d884 <_Thread_Set_state>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3003276c: e10f2000 mrs r2, CPSR 30032770: e3823080 orr r3, r2, #128 ; 0x80 30032774: 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;
30032778: e3a01002 mov r1, #2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
3003277c: e5963038 ldr r3, [r6, #56] ; 0x38
the_period->state = RATE_MONOTONIC_ACTIVE;
30032780: 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 (
30032784: 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 )
30032788: e3530003 cmp r3, #3
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3003278c: 059f3070 ldreq r3, [pc, #112] ; 30032804 <rtems_rate_monotonic_period+0x198> 30032790: 03a01901 moveq r1, #16384 ; 0x4000 30032794: 05930008 ldreq r0, [r3, #8] 30032798: 0bff694c bleq 3000ccd0 <_Thread_Clear_state>
_Thread_Enable_dispatch();
3003279c: ebff6a26 bl 3000d03c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300327a0: e3a04000 mov r4, #0 <== NOT EXECUTED 300327a4: ea000013 b 300327f8 <rtems_rate_monotonic_period+0x18c> <== NOT EXECUTED
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
300327a8: e3530004 cmp r3, #4 <== NOT EXECUTED 300327ac: 1a000010 bne 300327f4 <rtems_rate_monotonic_period+0x188> <== NOT EXECUTED
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
300327b0: ebffff54 bl 30032508 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED 300327b4: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
300327b8: e3a03002 mov r3, #2 <== NOT EXECUTED 300327bc: e5863038 str r3, [r6, #56] ; 0x38 <== NOT EXECUTED
the_period->next_length = length;
300327c0: e586403c str r4, [r6, #60] ; 0x3c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
300327c4: e586401c str r4, [r6, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
300327c8: e59f0040 ldr r0, [pc, #64] ; 30032810 <rtems_rate_monotonic_period+0x1a4><== NOT EXECUTED 300327cc: e2861010 add r1, r6, #16 <== NOT EXECUTED 300327d0: ebff6d05 bl 3000dbec <_Watchdog_Insert> <== NOT EXECUTED 300327d4: e5960040 ldr r0, [r6, #64] ; 0x40 <== NOT EXECUTED 300327d8: e596103c ldr r1, [r6, #60] ; 0x3c <== NOT EXECUTED 300327dc: e59f3030 ldr r3, [pc, #48] ; 30032814 <rtems_rate_monotonic_period+0x1a8><== NOT EXECUTED 300327e0: e1a0e00f mov lr, pc <== NOT EXECUTED 300327e4: 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;
300327e8: 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();
300327ec: ebff6a12 bl 3000d03c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TIMEOUT;
300327f0: ea000000 b 300327f8 <rtems_rate_monotonic_period+0x18c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300327f4: e3a04004 mov r4, #4 <== NOT EXECUTED
}
300327f8: e1a00004 mov r0, r4
300327fc: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
30026c78 <rtems_rate_monotonic_report_statistics>:
void rtems_rate_monotonic_report_statistics( void )
{
rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
30026c78: e59f1004 ldr r1, [pc, #4] ; 30026c84 <rtems_rate_monotonic_report_statistics+0xc><== NOT EXECUTED 30026c7c: e3a00000 mov r0, #0 <== NOT EXECUTED 30026c80: eaffff7f b 30026a84 <rtems_rate_monotonic_report_statistics_with_plugin><== NOT EXECUTED
30026a84 <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30026a84: 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 )
30026a88: e2514000 subs r4, r1, #0 <== NOT EXECUTED
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30026a8c: e24dd070 sub sp, sp, #112 ; 0x70 <== NOT EXECUTED 30026a90: 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 )
30026a94: 0a00006b beq 30026c48 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c4><== NOT EXECUTED
return;
(*print)( context, "Period information by period\n" );
30026a98: e59f11b0 ldr r1, [pc, #432] ; 30026c50 <rtems_rate_monotonic_report_statistics_with_plugin+0x1cc><== NOT EXECUTED 30026a9c: e1a0e00f mov lr, pc <== NOT EXECUTED 30026aa0: e12fff14 bx r4 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
30026aa4: e59f11a8 ldr r1, [pc, #424] ; 30026c54 <rtems_rate_monotonic_report_statistics_with_plugin+0x1d0><== NOT EXECUTED 30026aa8: e1a00005 mov r0, r5 <== NOT EXECUTED 30026aac: e1a0e00f mov lr, pc <== NOT EXECUTED 30026ab0: e12fff14 bx r4 <== NOT EXECUTED
(*print)( context, "--- Wall times are in seconds ---\n" );
30026ab4: e59f119c ldr r1, [pc, #412] ; 30026c58 <rtems_rate_monotonic_report_statistics_with_plugin+0x1d4><== NOT EXECUTED 30026ab8: e1a00005 mov r0, r5 <== NOT EXECUTED 30026abc: e1a0e00f mov lr, pc <== NOT EXECUTED 30026ac0: 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 ;
30026ac4: e59f7190 ldr r7, [pc, #400] ; 30026c5c <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 "
30026ac8: e59f1190 ldr r1, [pc, #400] ; 30026c60 <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NOT EXECUTED 30026acc: e1a00005 mov r0, r5 <== NOT EXECUTED 30026ad0: e1a0e00f mov lr, pc <== NOT EXECUTED 30026ad4: e12fff14 bx r4 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
30026ad8: e1a00005 mov r0, r5 <== NOT EXECUTED 30026adc: e59f1180 ldr r1, [pc, #384] ; 30026c64 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e0><== NOT EXECUTED 30026ae0: e1a0e00f mov lr, pc <== NOT EXECUTED 30026ae4: 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;
30026ae8: 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 ;
30026aec: e5976008 ldr r6, [r7, #8] <== NOT EXECUTED 30026af0: ea000051 b 30026c3c <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 );
30026af4: e1a00006 mov r0, r6 <== NOT EXECUTED 30026af8: e28d1010 add r1, sp, #16 <== NOT EXECUTED 30026afc: eb002dac bl 300321b4 <rtems_rate_monotonic_get_statistics> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL )
30026b00: e3500000 cmp r0, #0 <== NOT EXECUTED 30026b04: 1a00004b bne 30026c38 <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 );
30026b08: e28d1048 add r1, sp, #72 ; 0x48 <== NOT EXECUTED 30026b0c: e1a00006 mov r0, r6 <== NOT EXECUTED 30026b10: eb002e12 bl 30032360 <rtems_rate_monotonic_get_status> <== NOT EXECUTED
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
30026b14: e3a01005 mov r1, #5 <== NOT EXECUTED 30026b18: e28d2068 add r2, sp, #104 ; 0x68 <== NOT EXECUTED 30026b1c: e59d0048 ldr r0, [sp, #72] ; 0x48 <== NOT EXECUTED 30026b20: ebffacc5 bl 30011e3c <rtems_object_get_name> <== NOT EXECUTED
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
30026b24: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30026b28: e59f1138 ldr r1, [pc, #312] ; 30026c68 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e4><== NOT EXECUTED 30026b2c: e58d3000 str r3, [sp] <== NOT EXECUTED 30026b30: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 30026b34: e1a00005 mov r0, r5 <== NOT EXECUTED 30026b38: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 30026b3c: e1a02006 mov r2, r6 <== NOT EXECUTED 30026b40: e28d3068 add r3, sp, #104 ; 0x68 <== NOT EXECUTED 30026b44: e1a0e00f mov lr, pc <== NOT EXECUTED 30026b48: e12fff14 bx r4 <== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
30026b4c: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 30026b50: e3510000 cmp r1, #0 <== NOT EXECUTED 30026b54: 1a000004 bne 30026b6c <rtems_rate_monotonic_report_statistics_with_plugin+0xe8><== NOT EXECUTED
(*print)( context, "\n" );
30026b58: e1a00005 mov r0, r5 <== NOT EXECUTED 30026b5c: e59f1108 ldr r1, [pc, #264] ; 30026c6c <rtems_rate_monotonic_report_statistics_with_plugin+0x1e8><== NOT EXECUTED 30026b60: e1a0e00f mov lr, pc <== NOT EXECUTED 30026b64: e12fff14 bx r4 <== NOT EXECUTED
continue;
30026b68: ea000032 b 30026c38 <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 );
30026b6c: e28d2060 add r2, sp, #96 ; 0x60 <== NOT EXECUTED 30026b70: e1a00008 mov r0, r8 <== NOT EXECUTED 30026b74: eb000279 bl 30027560 <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
30026b78: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED 30026b7c: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30026b80: eb009ffc bl 3004eb78 <__aeabi_idiv> <== NOT EXECUTED 30026b84: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 30026b88: e1a0a000 mov sl, r0 <== NOT EXECUTED 30026b8c: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30026b90: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 30026b94: e58d3000 str r3, [sp] <== NOT EXECUTED 30026b98: eb009ff6 bl 3004eb78 <__aeabi_idiv> <== NOT EXECUTED 30026b9c: e59d3060 ldr r3, [sp, #96] ; 0x60 <== NOT EXECUTED 30026ba0: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 30026ba4: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30026ba8: e59d0064 ldr r0, [sp, #100] ; 0x64 <== NOT EXECUTED 30026bac: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 30026bb0: eb009ff0 bl 3004eb78 <__aeabi_idiv> <== NOT EXECUTED 30026bb4: e1a0300a mov r3, sl <== NOT EXECUTED 30026bb8: e58d000c str r0, [sp, #12] <== NOT EXECUTED 30026bbc: e59f10ac ldr r1, [pc, #172] ; 30026c70 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ec><== NOT EXECUTED 30026bc0: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 30026bc4: e1a00005 mov r0, r5 <== NOT EXECUTED 30026bc8: e1a0e00f mov lr, pc <== NOT EXECUTED 30026bcc: 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);
30026bd0: e28d2060 add r2, sp, #96 ; 0x60 <== NOT EXECUTED 30026bd4: e28d0040 add r0, sp, #64 ; 0x40 <== NOT EXECUTED 30026bd8: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 30026bdc: eb00025f bl 30027560 <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
30026be0: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30026be4: e59d0034 ldr r0, [sp, #52] ; 0x34 <== NOT EXECUTED 30026be8: eb009fe2 bl 3004eb78 <__aeabi_idiv> <== NOT EXECUTED 30026bec: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED 30026bf0: e1a0a000 mov sl, r0 <== NOT EXECUTED 30026bf4: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30026bf8: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED 30026bfc: e58d3000 str r3, [sp] <== NOT EXECUTED 30026c00: eb009fdc bl 3004eb78 <__aeabi_idiv> <== NOT EXECUTED 30026c04: e59d3060 ldr r3, [sp, #96] ; 0x60 <== NOT EXECUTED 30026c08: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 30026c0c: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30026c10: e59d0064 ldr r0, [sp, #100] ; 0x64 <== NOT EXECUTED 30026c14: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 30026c18: eb009fd6 bl 3004eb78 <__aeabi_idiv> <== NOT EXECUTED 30026c1c: e59f1050 ldr r1, [pc, #80] ; 30026c74 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f0><== NOT EXECUTED 30026c20: e58d000c str r0, [sp, #12] <== NOT EXECUTED 30026c24: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED 30026c28: e1a00005 mov r0, r5 <== NOT EXECUTED 30026c2c: e1a0300a mov r3, sl <== NOT EXECUTED 30026c30: e1a0e00f mov lr, pc <== NOT EXECUTED 30026c34: 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++ ) {
30026c38: 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 ;
30026c3c: e597300c ldr r3, [r7, #12] <== NOT EXECUTED 30026c40: e1560003 cmp r6, r3 <== NOT EXECUTED 30026c44: 9affffaa bls 30026af4 <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
}
}
}
30026c48: e28dd070 add sp, sp, #112 ; 0x70 <== NOT EXECUTED
30026c4c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30026c88 <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;
30026c88: e59f3038 ldr r3, [pc, #56] ; 30026cc8 <rtems_rate_monotonic_reset_all_statistics+0x40><== NOT EXECUTED
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
30026c8c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30026c90: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
30026c94: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30026c98: 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 ;
30026c9c: e59f5028 ldr r5, [pc, #40] ; 30026ccc <rtems_rate_monotonic_reset_all_statistics+0x44><== NOT EXECUTED 30026ca0: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED 30026ca4: ea000002 b 30026cb4 <rtems_rate_monotonic_reset_all_statistics+0x2c><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
30026ca8: e1a00004 mov r0, r4 <== NOT EXECUTED 30026cac: eb000007 bl 30026cd0 <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++ ) {
30026cb0: 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 ;
30026cb4: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 30026cb8: e1540003 cmp r4, r3 <== NOT EXECUTED 30026cbc: 9afffff9 bls 30026ca8 <rtems_rate_monotonic_reset_all_statistics+0x20><== NOT EXECUTED
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
30026cc0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
30026cc4: eaff98dc b 3000d03c <_Thread_Enable_dispatch> <== NOT EXECUTED
30026cd0 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
30026cd0: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
30026cd4: 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 *)
30026cd8: e1a0200d mov r2, sp <== NOT EXECUTED 30026cdc: e59f0048 ldr r0, [pc, #72] ; 30026d2c <rtems_rate_monotonic_reset_statistics+0x5c><== NOT EXECUTED 30026ce0: ebff956a bl 3000c290 <_Objects_Get> <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30026ce4: e59d4000 ldr r4, [sp] <== NOT EXECUTED 30026ce8: e1a05000 mov r5, r0 <== NOT EXECUTED 30026cec: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30026cf0: 13a00004 movne r0, #4 <== NOT EXECUTED
{
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30026cf4: 1a00000b bne 30026d28 <rtems_rate_monotonic_reset_statistics+0x58><== NOT EXECUTED
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
30026cf8: e1a01004 mov r1, r4 <== NOT EXECUTED 30026cfc: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 30026d00: e2850054 add r0, r5, #84 ; 0x54 <== NOT EXECUTED 30026d04: eb0048c4 bl 3003901c <memset> <== NOT EXECUTED 30026d08: e59f2020 ldr r2, [pc, #32] ; 30026d30 <rtems_rate_monotonic_reset_statistics+0x60><== NOT EXECUTED 30026d0c: e59f3020 ldr r3, [pc, #32] ; 30026d34 <rtems_rate_monotonic_reset_statistics+0x64><== NOT EXECUTED 30026d10: e585205c str r2, [r5, #92] ; 0x5c <== NOT EXECUTED 30026d14: e5853060 str r3, [r5, #96] ; 0x60 <== NOT EXECUTED 30026d18: e5852074 str r2, [r5, #116] ; 0x74 <== NOT EXECUTED 30026d1c: e5853078 str r3, [r5, #120] ; 0x78 <== NOT EXECUTED
_Thread_Enable_dispatch();
30026d20: ebff98c5 bl 3000d03c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30026d24: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30026d28: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000b2e8 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
3000b2e8: 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;
3000b2ec: e5906030 ldr r6, [r0, #48] ; 0x30 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
3000b2f0: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b2f4: 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;
3000b2f8: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b2fc: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b300: eb00424f bl 3001bc44 <__umodsi3> <== NOT EXECUTED
if (excess > 0) {
3000b304: e3500000 cmp r0, #0 <== NOT EXECUTED
value += alignment - excess;
3000b308: 10856006 addne r6, r5, r6 <== NOT EXECUTED 3000b30c: 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) {
3000b310: 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) {
3000b314: e1550006 cmp r5, r6 <== NOT EXECUTED 3000b318: 83a00000 movhi r0, #0 <== NOT EXECUTED 3000b31c: 93a00001 movls r0, #1 <== NOT EXECUTED 3000b320: e3550000 cmp r5, #0 <== NOT EXECUTED 3000b324: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000b328: e3500000 cmp r0, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000b32c: 11a02004 movne r2, r4 <== NOT EXECUTED 3000b330: 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;
3000b334: 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) {
3000b338: 1a000005 bne 3000b354 <rtems_rbheap_allocate+0x6c> <== NOT EXECUTED
3000b33c: 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) {
3000b340: e593701c ldr r7, [r3, #28] <== NOT EXECUTED 3000b344: e1570006 cmp r7, r6 <== NOT EXECUTED 3000b348: 21a07003 movcs r7, r3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000b34c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000b350: 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) {
3000b354: e2778001 rsbs r8, r7, #1 <== NOT EXECUTED 3000b358: 33a08000 movcc r8, #0 <== NOT EXECUTED 3000b35c: e1530002 cmp r3, r2 <== NOT EXECUTED 3000b360: 03a08000 moveq r8, #0 <== NOT EXECUTED 3000b364: e3580000 cmp r8, #0 <== NOT EXECUTED 3000b368: 1afffff4 bne 3000b340 <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) {
3000b36c: e3570000 cmp r7, #0 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
3000b370: 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) {
3000b374: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
uintptr_t free_size = free_chunk->size;
3000b378: e597901c ldr r9, [r7, #28] <== NOT EXECUTED
if (free_size > aligned_size) {
3000b37c: e1590006 cmp r9, r6 <== NOT EXECUTED 3000b380: 9a00001f bls 3000b404 <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;
3000b384: e1a0a004 mov sl, r4 <== NOT EXECUTED 3000b388: 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 );
3000b38c: 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))
3000b390: 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;
3000b394: 15953000 ldrne r3, [r5] <== NOT EXECUTED
head->next = new_first;
3000b398: 1584300c strne r3, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
3000b39c: 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))
3000b3a0: 1a000009 bne 3000b3cc <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);
3000b3a4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b3a8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b3ac: 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;
3000b3b0: 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))
3000b3b4: e1530005 cmp r3, r5 <== NOT EXECUTED 3000b3b8: 0a000018 beq 3000b420 <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;
3000b3bc: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
3000b3c0: 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;
3000b3c4: e584200c str r2, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
3000b3c8: 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;
3000b3cc: 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;
3000b3d0: e0669009 rsb r9, r6, r9 <== NOT EXECUTED
free_chunk->size = new_free_size;
3000b3d4: e587901c str r9, [r7, #28] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
3000b3d8: e1a01005 mov r1, r5 <== NOT EXECUTED
new_chunk->begin = free_chunk->begin + new_free_size;
3000b3dc: e0899003 add r9, r9, r3 <== NOT EXECUTED 3000b3e0: e3a03000 mov r3, #0 <== NOT EXECUTED 3000b3e4: e5859018 str r9, [r5, #24] <== NOT EXECUTED
new_chunk->size = aligned_size;
3000b3e8: e585601c str r6, [r5, #28] <== NOT EXECUTED 3000b3ec: e5853004 str r3, [r5, #4] <== NOT EXECUTED 3000b3f0: 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);
3000b3f4: e2840018 add r0, r4, #24 <== NOT EXECUTED 3000b3f8: eb000650 bl 3000cd40 <_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;
3000b3fc: e5950018 ldr r0, [r5, #24] <== NOT EXECUTED
3000b400: 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;
3000b404: 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;
3000b408: e5970018 ldr r0, [r7, #24] <== NOT EXECUTED
next->previous = previous;
3000b40c: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000b410: e5832000 str r2, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
3000b414: e5878004 str r8, [r7, #4] <== NOT EXECUTED
3000b418: e5878000 str r8, [r7] <== NOT EXECUTED
3000b41c: 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;
3000b420: e1a00008 mov r0, r8 <== NOT EXECUTED
}
}
}
return ptr;
}
3000b424: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000b5a8 <rtems_rbheap_extend_descriptors_never>:
void rtems_rbheap_extend_descriptors_never(rtems_rbheap_control *control)
{
/* Do nothing */
}
3000b5a8: e12fff1e bx lr <== NOT EXECUTED
3000b5ac <rtems_rbheap_extend_descriptors_with_malloc>:
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
3000b5ac: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b5b0: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
3000b5b4: e3a00020 mov r0, #32 <== NOT EXECUTED 3000b5b8: ebffee8e bl 30006ff8 <malloc> <== NOT EXECUTED
if (chunk != NULL) {
3000b5bc: e3500000 cmp r0, #0 <== NOT EXECUTED
3000b5c0: 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);
3000b5c4: e284300c add r3, r4, #12 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b5c8: e5803004 str r3, [r0, #4] <== NOT EXECUTED
before_node = after_node->next;
3000b5cc: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
after_node->next = the_node;
3000b5d0: e584000c str r0, [r4, #12] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b5d4: 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;
3000b5d8: e5803000 str r3, [r0] <== NOT EXECUTED
3000b5dc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b428 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
3000b428: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
3000b42c: 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)
{
3000b430: e24dd020 sub sp, sp, #32 <== NOT EXECUTED 3000b434: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
3000b438: 0a000057 beq 3000b59c <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 };
3000b43c: e1a0000d mov r0, sp <== NOT EXECUTED 3000b440: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b444: 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;
3000b448: e3a04000 mov r4, #0 <== NOT EXECUTED 3000b44c: eb002035 bl 30013528 <memset> <== NOT EXECUTED
return rtems_rbheap_chunk_of_node(
3000b450: 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 };
3000b454: e58d6018 str r6, [sp, #24] <== NOT EXECUTED
return rtems_rbheap_chunk_of_node(
3000b458: 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;
3000b45c: e595601c ldr r6, [r5, #28] <== NOT EXECUTED 3000b460: ea00000d b 3000b49c <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);
3000b464: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b468: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b46c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b470: e595f028 ldr pc, [r5, #40] ; 0x28 <== NOT EXECUTED
if ( _RBTree_Is_equal( compare_result ) ) {
3000b474: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b478: 1a000003 bne 3000b48c <rtems_rbheap_free+0x64> <== NOT EXECUTED
found = iter_node;
if ( the_rbtree->is_unique )
3000b47c: e5d5302c ldrb r3, [r5, #44] ; 0x2c <== NOT EXECUTED 3000b480: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b484: 1a000007 bne 3000b4a8 <rtems_rbheap_free+0x80> <== NOT EXECUTED 3000b488: e1a04006 mov r4, r6 <== NOT EXECUTED
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
3000b48c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b490: c3a00008 movgt r0, #8 <== NOT EXECUTED 3000b494: d3a00004 movle r0, #4 <== NOT EXECUTED 3000b498: e7906006 ldr r6, [r0, r6] <== NOT EXECUTED
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
3000b49c: e3560000 cmp r6, #0 <== NOT EXECUTED 3000b4a0: 1affffef bne 3000b464 <rtems_rbheap_free+0x3c> <== NOT EXECUTED 3000b4a4: e1a06004 mov r6, r4 <== NOT EXECUTED 3000b4a8: 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) {
3000b4ac: 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;
3000b4b0: 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) {
3000b4b4: 0a000038 beq 3000b59c <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);
3000b4b8: e5163008 ldr r3, [r6, #-8] <== NOT EXECUTED 3000b4bc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b4c0: 13a0a000 movne sl, #0 <== NOT EXECUTED 3000b4c4: 1a000002 bne 3000b4d4 <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)
3000b4c8: e594a004 ldr sl, [r4, #4] <== NOT EXECUTED 3000b4cc: e27aa001 rsbs sl, sl, #1 <== NOT EXECUTED 3000b4d0: 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)) {
3000b4d4: 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;
3000b4d8: 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)) {
3000b4dc: 1a00002e bne 3000b59c <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(
3000b4e0: e2849008 add r9, r4, #8 <== NOT EXECUTED 3000b4e4: e1a0100a mov r1, sl <== NOT EXECUTED 3000b4e8: e1a00009 mov r0, r9 <== NOT EXECUTED 3000b4ec: eb000698 bl 3000cf54 <_RBTree_Next_unprotected> <== NOT EXECUTED 3000b4f0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b4f4: e1a06000 mov r6, r0 <== NOT EXECUTED 3000b4f8: e2408008 sub r8, r0, #8 <== NOT EXECUTED 3000b4fc: e1a00009 mov r0, r9 <== NOT EXECUTED 3000b500: eb000693 bl 3000cf54 <_RBTree_Next_unprotected> <== NOT EXECUTED 3000b504: 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)) {
3000b508: 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;
3000b50c: 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)) {
3000b510: 0a00000a beq 3000b540 <rtems_rbheap_free+0x118> <== NOT EXECUTED 3000b514: e5102008 ldr r2, [r0, #-8] <== NOT EXECUTED 3000b518: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b51c: 1a000002 bne 3000b52c <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)
3000b520: e510a004 ldr sl, [r0, #-4] <== NOT EXECUTED 3000b524: e27aa001 rsbs sl, sl, #1 <== NOT EXECUTED 3000b528: 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)) {
3000b52c: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000b530: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b534: 01a01007 moveq r1, r7 <== NOT EXECUTED 3000b538: 01a02004 moveq r2, r4 <== NOT EXECUTED 3000b53c: 0bffff08 bleq 3000b164 <check_and_merge.part.1> <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b540: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000b544: e3780008 cmn r8, #8 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b548: e5845004 str r5, [r4, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b54c: e5854000 str r4, [r5] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b550: 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;
3000b554: e5843000 str r3, [r4] <== NOT EXECUTED 3000b558: 0a00000e beq 3000b598 <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);
3000b55c: e5163008 ldr r3, [r6, #-8] <== NOT EXECUTED 3000b560: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b564: 13a06000 movne r6, #0 <== NOT EXECUTED 3000b568: 1a000002 bne 3000b578 <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)
3000b56c: e5166004 ldr r6, [r6, #-4] <== NOT EXECUTED 3000b570: e2766001 rsbs r6, r6, #1 <== NOT EXECUTED 3000b574: 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)) {
3000b578: e21660ff ands r6, r6, #255 ; 0xff <== NOT EXECUTED 3000b57c: 1a000005 bne 3000b598 <rtems_rbheap_free+0x170> <== NOT EXECUTED 3000b580: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b584: e1a01007 mov r1, r7 <== NOT EXECUTED 3000b588: e1a02004 mov r2, r4 <== NOT EXECUTED 3000b58c: e1a03008 mov r3, r8 <== NOT EXECUTED 3000b590: ebfffef3 bl 3000b164 <check_and_merge.part.1> <== NOT EXECUTED 3000b594: ea000000 b 3000b59c <rtems_rbheap_free+0x174> <== NOT EXECUTED
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
3000b598: e3a06000 mov r6, #0 <== NOT EXECUTED
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
3000b59c: e1a00006 mov r0, r6 <== NOT EXECUTED
3000b5a0: e28dd020 add sp, sp, #32 <== NOT EXECUTED
3000b5a4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000b1c4 <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
3000b1c4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
3000b1c8: e2538000 subs r8, r3, #0 <== NOT EXECUTED
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
3000b1cc: e1a04000 mov r4, r0 <== NOT EXECUTED 3000b1d0: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b1d4: e59d6024 ldr r6, [sp, #36] ; 0x24 <== NOT EXECUTED
}
} else {
sc = RTEMS_INVALID_ADDRESS;
}
} else {
sc = RTEMS_INVALID_NUMBER;
3000b1d8: 03a0000a moveq r0, #10 <== NOT EXECUTED
void *handler_arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
3000b1dc: 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;
3000b1e0: 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;
3000b1e4: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b1e8: e1a01008 mov r1, r8 <== NOT EXECUTED 3000b1ec: eb004294 bl 3001bc44 <__umodsi3> <== NOT EXECUTED
if (excess > 0) {
3000b1f0: e3500000 cmp r0, #0 <== NOT EXECUTED
value += alignment - excess;
3000b1f4: 10857008 addne r7, r5, r8 <== NOT EXECUTED 3000b1f8: 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) {
3000b1fc: 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) {
3000b200: e1550007 cmp r5, r7 <== NOT EXECUTED 3000b204: 9155000a cmpls r5, sl <== NOT EXECUTED 3000b208: 2a000031 bcs 3000b2d4 <rtems_rbheap_initialize+0x110> <== NOT EXECUTED
return value;
}
static uintptr_t align_down(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
3000b20c: e1a0000a mov r0, sl <== NOT EXECUTED 3000b210: e1a01008 mov r1, r8 <== NOT EXECUTED 3000b214: eb00428a bl 3001bc44 <__umodsi3> <== NOT EXECUTED
return value - excess;
3000b218: 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) {
3000b21c: e157000a cmp r7, sl <== NOT EXECUTED 3000b220: 2a00002b bcs 3000b2d4 <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 );
3000b224: e2843004 add r3, r4, #4 <== NOT EXECUTED
head->next = tail;
3000b228: 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;
3000b22c: e59f30b0 ldr r3, [pc, #176] ; 3000b2e4 <rtems_rbheap_initialize+0x120><== NOT EXECUTED
head->previous = NULL;
3000b230: e3a05000 mov r5, #0 <== NOT EXECUTED 3000b234: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
the_rbtree->is_unique = is_unique;
3000b238: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b23c: 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;
3000b240: 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 );
3000b244: 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 );
3000b248: e284900c add r9, r4, #12 <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3000b24c: e5845004 str r5, [r4, #4] <== NOT EXECUTED
tail->previous = head;
3000b250: e5844008 str r4, [r4, #8] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000b254: e584b00c str fp, [r4, #12] <== NOT EXECUTED
head->previous = NULL;
3000b258: e5845010 str r5, [r4, #16] <== NOT EXECUTED
tail->previous = head;
3000b25c: e5849014 str r9, [r4, #20] <== NOT EXECUTED
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
3000b260: e5845018 str r5, [r4, #24] <== NOT EXECUTED
the_rbtree->root = NULL;
3000b264: e584501c str r5, [r4, #28] <== NOT EXECUTED
the_rbtree->first[0] = NULL;
3000b268: e5845020 str r5, [r4, #32] <== NOT EXECUTED
the_rbtree->first[1] = NULL;
3000b26c: 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;
3000b270: e5848030 str r8, [r4, #48] ; 0x30 <== NOT EXECUTED
control->handler_arg = handler_arg;
3000b274: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
control->extend_descriptors = extend_descriptors;
3000b278: 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);
3000b27c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b280: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b284: 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;
3000b288: 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))
3000b28c: e151000b cmp r1, fp <== NOT EXECUTED 3000b290: 0a000011 beq 3000b2dc <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;
3000b294: 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;
3000b298: 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;
3000b29c: e584300c str r3, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
3000b2a0: e5839004 str r9, [r3, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b2a4: 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;
3000b2a8: 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;
3000b2ac: e5817018 str r7, [r1, #24] <== NOT EXECUTED
first->size = aligned_end - aligned_begin;
3000b2b0: e581a01c str sl, [r1, #28] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b2b4: e5814004 str r4, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b2b8: e4801018 str r1, [r0], #24 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b2bc: 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;
3000b2c0: 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);
3000b2c4: e2811008 add r1, r1, #8 <== NOT EXECUTED 3000b2c8: eb00069c bl 3000cd40 <_RBTree_Insert_unprotected> <== NOT EXECUTED
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
3000b2cc: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b2d0: 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;
3000b2d4: e3a00009 mov r0, #9 <== NOT EXECUTED
3000b2d8: 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;
3000b2dc: e3a0001a mov r0, #26 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
3000b2e0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000b76c <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000b76c: 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 ) )
3000b770: e2509000 subs r9, r0, #0
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000b774: e1a06001 mov r6, r1 3000b778: e1a07002 mov r7, r2 3000b77c: e1a08003 mov r8, r3 3000b780: e59da024 ldr sl, [sp, #36] ; 0x24 3000b784: 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;
3000b788: 03a06003 moveq r6, #3
)
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
3000b78c: 0a000031 beq 3000b858 <rtems_region_create+0xec>
return RTEMS_INVALID_NAME;
if ( !starting_address )
3000b790: e3560000 cmp r6, #0
3000b794: 0a00002e beq 3000b854 <rtems_region_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( !id )
3000b798: e35b0000 cmp fp, #0
3000b79c: 0a00002c beq 3000b854 <rtems_region_create+0xe8>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
3000b7a0: e59f30b8 ldr r3, [pc, #184] ; 3000b860 <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 );
3000b7a4: e59f50b8 ldr r5, [pc, #184] ; 3000b864 <rtems_region_create+0xf8> 3000b7a8: e5930000 ldr r0, [r3] 3000b7ac: eb0003a2 bl 3000c63c <_API_Mutex_Lock> 3000b7b0: e1a00005 mov r0, r5 3000b7b4: eb000645 bl 3000d0d0 <_Objects_Allocate>
the_region = _Region_Allocate();
if ( !the_region )
3000b7b8: e2504000 subs r4, r0, #0
return_status = RTEMS_TOO_MANY;
3000b7bc: 03a06005 moveq r6, #5
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
3000b7c0: 0a00001f beq 3000b844 <rtems_region_create+0xd8>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
3000b7c4: e2840068 add r0, r4, #104 ; 0x68 3000b7c8: e1a01006 mov r1, r6 3000b7cc: e1a02007 mov r2, r7 3000b7d0: e1a03008 mov r3, r8 3000b7d4: eb00058c bl 3000ce0c <_Heap_Initialize>
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
3000b7d8: e3500000 cmp r0, #0
if ( !the_region )
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
3000b7dc: e584005c str r0, [r4, #92] ; 0x5c
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
3000b7e0: 1a000004 bne 3000b7f8 <rtems_region_create+0x8c>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
3000b7e4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b7e8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b7ec: eb000706 bl 3000d40c <_Objects_Free> <== NOT EXECUTED
_Region_Free( the_region );
return_status = RTEMS_INVALID_SIZE;
3000b7f0: e3a06008 mov r6, #8 <== NOT EXECUTED 3000b7f4: ea000012 b 3000b844 <rtems_region_create+0xd8> <== NOT EXECUTED
}
else {
the_region->starting_address = starting_address;
3000b7f8: 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(
3000b7fc: 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;
3000b800: e3a06000 mov r6, #0
_Thread_queue_Initialize(
3000b804: 03a01000 moveq r1, #0 3000b808: 13a01001 movne r1, #1 3000b80c: e3a02040 mov r2, #64 ; 0x40 3000b810: e3a03006 mov r3, #6
}
else {
the_region->starting_address = starting_address;
the_region->length = length;
3000b814: e5847054 str r7, [r4, #84] ; 0x54
the_region->page_size = page_size;
3000b818: e5848058 str r8, [r4, #88] ; 0x58
the_region->attribute_set = attribute_set;
3000b81c: e584a060 str sl, [r4, #96] ; 0x60
the_region->number_of_used_blocks = 0;
3000b820: e5846064 str r6, [r4, #100] ; 0x64
_Thread_queue_Initialize(
3000b824: e2840010 add r0, r4, #16 3000b828: eb000cbc bl 3000eb20 <_Thread_queue_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b82c: e595201c ldr r2, [r5, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000b830: e5943008 ldr r3, [r4, #8] 3000b834: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b838: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000b83c: e584900c str r9, [r4, #12]
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
3000b840: e58b3000 str r3, [fp]
return_status = RTEMS_SUCCESSFUL;
}
}
_RTEMS_Unlock_allocator();
3000b844: e59f3014 ldr r3, [pc, #20] ; 3000b860 <rtems_region_create+0xf4> 3000b848: e5930000 ldr r0, [r3] 3000b84c: eb000393 bl 3000c6a0 <_API_Mutex_Unlock>
return return_status;
3000b850: ea000000 b 3000b858 <rtems_region_create+0xec>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000b854: e3a06009 mov r6, #9 <== NOT EXECUTED
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
3000b858: e1a00006 mov r0, r6
3000b85c: 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: eb00091a bl 30019ca8 <_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: eb00107d bl 3001ba44 <_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: eb000c5a bl 3001a9e0 <_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: eb000919 bl 30019d0c <_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: eb0008f4 bl 30019ca8 <_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: eb001057 bl 3001ba44 <_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: eb000d5d bl 3001ae84 <_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: eb0008fc bl 30019d0c <_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: eb0008d7 bl 30019ca8 <_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: eb00103a bl 3001ba44 <_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: 0b000d66 bleq 3001af0c <_Heap_Get_information> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017970: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017974: eb0008e4 bl 30019d0c <_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: eb000872 bl 30019ca8 <_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: eb000fd5 bl 3001ba44 <_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: eb000e63 bl 3001b4a4 <_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: eb000877 bl 30019d0c <_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: eb000842 bl 30019ca8 <_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: eb000fa5 bl 3001ba44 <_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: eb000de5 bl 3001b370 <_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: eb001ebc bl 3001f6e4 <_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: eb000842 bl 30019d0c <_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: eb00083c bl 30019d0c <_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: eb000818 bl 30019ca8 <_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: eb000f7b bl 3001ba44 <_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: eb000c07 bl 3001ac94 <_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: eb001e93 bl 3001f6e4 <_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: eb000819 bl 30019d0c <_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: eb000562 bl 3000b5ac <_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: eb000a10 bl 3000c870 <_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: eb0003d6 bl 3000afcc <_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: 13a03002 movne r3, #2 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: eb0002f4 bl 3000acb8 <_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: e3500006 cmp r0, #6
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: eb0005fb bl 3000b8e8 <_Objects_Free>
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
3000a0f8: eb0009dc bl 3000c870 <_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: eb0009d2 bl 3000c870 <_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: eb000639 bl 3000ba3c <_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: eb0009b8 bl 3000c870 <_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: e3a02004 mov r2, #4 3000a1a0: eb0002c3 bl 3000acb4 <_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: eb000384 bl 3000afc8 <_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: eb00051c bl 3000b634 <_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: eb0005c6 bl 3000b8e8 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
3000a1cc: eb0009a7 bl 3000c870 <_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}
30013664 <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
30013664: e92d4001 push {r0, lr}
30013668: e1a01000 mov r1, r0
3001366c: e1a0200d mov r2, sp
30013670: e59f0044 ldr r0, [pc, #68] ; 300136bc <rtems_semaphore_flush+0x58>
30013674: ebffe69e bl 3000d0f4 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30013678: e59d3000 ldr r3, [sp] 3001367c: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30013680: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30013684: 1a00000b bne 300136b8 <rtems_semaphore_flush+0x54>
30013688: e5901010 ldr r1, [r0, #16] 3001368c: e2800014 add r0, r0, #20
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
30013690: e2111030 ands r1, r1, #48 ; 0x30
30013694: 0a000003 beq 300136a8 <rtems_semaphore_flush+0x44>
_CORE_mutex_Flush(
30013698: e1a01003 mov r1, r3 3001369c: e3a02001 mov r2, #1 300136a0: ebffe331 bl 3000c36c <_CORE_mutex_Flush> 300136a4: ea000001 b 300136b0 <rtems_semaphore_flush+0x4c>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
300136a8: e3a02001 mov r2, #1 <== NOT EXECUTED 300136ac: ebffe3f3 bl 3000c680 <_CORE_semaphore_Flush> <== NOT EXECUTED
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
300136b0: ebffe9fa bl 3000dea0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300136b4: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300136b8: 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: eb0005f4 bl 3000b9d4 <_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: eb0002eb bl 3000adec <_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: eb000a93 bl 3000cd20 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
3000a2d0: eb000966 bl 3000c870 <_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}
3000a874 <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
3000a874: e59f3038 ldr r3, [pc, #56] ; 3000a8b4 <rtems_shutdown_executive+0x40>
*/
void rtems_shutdown_executive(
uint32_t result
)
{
3000a878: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( _System_state_Is_up( _System_state_Get() ) ) {
3000a87c: e5932000 ldr r2, [r3] 3000a880: e3520003 cmp r2, #3
3000a884: 1a000006 bne 3000a8a4 <rtems_shutdown_executive+0x30>
#if defined(RTEMS_SMP)
_SMP_Request_other_cores_to_shutdown();
#endif
_Per_CPU_Information[0].idle->Wait.return_code = result;
3000a888: e59f2028 ldr r2, [pc, #40] ; 3000a8b8 <rtems_shutdown_executive+0x44> 3000a88c: e5922010 ldr r2, [r2, #16] 3000a890: e5820034 str r0, [r2, #52] ; 0x34 3000a894: e3a02004 mov r2, #4 3000a898: 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 );
3000a89c: e59f0018 ldr r0, [pc, #24] ; 3000a8bc <rtems_shutdown_executive+0x48> 3000a8a0: eb000caa bl 3000db50 <_CPU_Context_restore>
****** RETURN TO RTEMS_INITIALIZE_START_MULTITASKING() ******
****** AND THEN TO BOOT_CARD() ******
*******************************************************************
*******************************************************************/
}
_Internal_error_Occurred(
3000a8a4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a8a8: e3a01001 mov r1, #1 <== NOT EXECUTED 3000a8ac: e3a02014 mov r2, #20 <== NOT EXECUTED 3000a8b0: eb00031f bl 3000b534 <_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: eb0011e0 bl 3001c8d0 <_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: e59030f0 ldr r3, [r0, #240] ; 0xf0
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: eb0011b8 bl 3001c8b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300181cc: e3a00000 mov r0, #0 300181d0: ea000001 b 300181dc <rtems_signal_send+0xa8>
}
_Thread_Enable_dispatch();
300181d4: eb0011b5 bl 3001c8b0 <_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: eb00018f bl 3000ab7c <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
3000a53c: e1a00004 mov r0, r4 3000a540: e1a0100d mov r1, sp 3000a544: eb0008d1 bl 3000c890 <_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: eb0004fe bl 3000b95c <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
3000a560: e1a01004 mov r1, r4 3000a564: eb0007f6 bl 3000c544 <_Thread_Close> 3000a568: e5940008 ldr r0, [r4, #8] 3000a56c: eb0004fa bl 3000b95c <_Objects_Get_information_id> 3000a570: e1a01004 mov r1, r4 3000a574: eb0004db bl 3000b8e8 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
3000a578: e5950000 ldr r0, [r5] 3000a57c: eb000197 bl 3000abe0 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
3000a580: eb0008ba bl 3000c870 <_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: eb000192 bl 3000abe0 <_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: e59330f0 ldr r3, [r3, #240] ; 0xf0 <== 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: eb000971 bl 3000e658 <_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: e59030f0 ldr r3, [r0, #240] ; 0xf0 3000c0a4: e2844008 add r4, r4, #8 3000c0a8: e7933104 ldr r3, [r3, r4, lsl #2] 3000c0ac: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000c0b0: eb000960 bl 3000e638 <_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: eb00056c bl 3000bb94 <_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: eb0010ce bl 3001c8d0 <_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: eb0010be bl 3001c8b0 <_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: eb0010bb bl 3001c8b0 <_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: eb000893 bl 3000d000 <_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: eb000a8f bl 3000d80c <_Thread_Restart> 3000adcc: e3500000 cmp r0, #0
3000add0: 0a000002 beq 3000ade0 <rtems_task_restart+0x40>
_Thread_Enable_dispatch();
3000add4: eb000881 bl 3000cfe0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000add8: e1a00004 mov r0, r4 3000addc: ea000001 b 3000ade8 <rtems_task_restart+0x48>
}
_Thread_Enable_dispatch();
3000ade0: eb00087e bl 3000cfe0 <_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: eb000888 bl 3000f9e0 <_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: eb00079b bl 3000f654 <_Thread_Clear_state>
_Thread_Enable_dispatch();
3000d7e4: eb000875 bl 3000f9c0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000d7e8: e1a00004 mov r0, r4 3000d7ec: ea000001 b 3000d7f8 <rtems_task_resume+0x48>
}
_Thread_Enable_dispatch();
3000d7f0: eb000872 bl 3000f9c0 <_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: e59330f0 ldr r3, [r3, #240] ; 0xf0 <== 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: eb000910 bl 3000e658 <_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: e59030f0 ldr r3, [r0, #240] ; 0xf0 3000c228: e2844008 add r4, r4, #8 3000c22c: e7835104 str r5, [r3, r4, lsl #2]
_Thread_Enable_dispatch();
3000c230: eb000900 bl 3000e638 <_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: eb0008e7 bl 30010860 <_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: eb0007b4 bl 300103dc <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
3000e508: eb0008cc bl 30010840 <_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: eb00087b bl 3000c890 <_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: eb000ac2 bl 3000d1d0 <_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: eb000867 bl 3000c870 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a6d0: e1a00004 mov r0, r4 3000a6d4: ea000001 b 3000a6e0 <rtems_task_start+0x5c>
}
_Thread_Enable_dispatch();
3000a6d8: eb000864 bl 3000c870 <_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: eb000858 bl 3000fbac <_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: eb000a58 bl 300103d4 <_Thread_Set_state>
_Thread_Enable_dispatch();
3000da70: eb000845 bl 3000fb8c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000da74: e1a00004 mov r0, r4 3000da78: ea000001 b 3000da84 <rtems_task_suspend+0x48>
}
_Thread_Enable_dispatch();
3000da7c: eb000842 bl 3000fb8c <_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: eb0007ac bl 3000ada4 <_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: 059060fc ldreq r6, [r0, #252] ; 0xfc
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: eb000799 bl 3000ad84 <_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: eb000b49 bl 3000bc60 <_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: eb00078f bl 3000ad84 <_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: e59730fc ldr r3, [r7, #252] ; 0xfc
_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: e58700fc str r0, [r7, #252] ; 0xfc
_Thread_Enable_dispatch();
30008f68: eb000785 bl 3000ad84 <_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: eb000784 bl 3000ada4 <_Thread_Get>
switch (location) {
30008f90: e59d3000 ldr r3, [sp] 30008f94: e3530000 cmp r3, #0
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
30008f98: 059010fc ldreq r1, [r0, #252] ; 0xfc
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: 058020fc streq r2, [r0, #252] ; 0xfc
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: eb00076e bl 3000ad84 <_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: eb000767 bl 3000ad84 <_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: eb000763 bl 3000ada4 <_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: 059030fc ldreq r3, [r0, #252] ; 0xfc <== 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: eb000750 bl 3000ad84 <_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: eb00074a bl 3000ad84 <_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: eb000a64 bl 3000d0b8 <_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: eb000b32 bl 3000d420 <_Watchdog_Insert> <== NOT EXECUTED
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
3000a754: eb000845 bl 3000c870 <_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: eb00455b bl 3001cb8c <__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: eb000a99 bl 3000e0ac <_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: eb004546 bl 3001cb8c <__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: eb000b8b bl 3000e4b4 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3000b684: eb000876 bl 3000d864 <_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: eb0003d3 bl 3000b690 <_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: eb00085f bl 3000c8cc <_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: eb00084f bl 3000c8cc <_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: eb0004d0 bl 3000bb20 <_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: eb000b76 bl 3000d5d8 <_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: eb000b0d bl 3000d47c <_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: eb000820 bl 3000c8cc <_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: eb00502d bl 3002ce24 <__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: eb000b3d bl 3001ba7c <_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: eb00126f bl 3001d764 <_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: eb005015 bl 3002ce24 <__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: eb001209 bl 3001d608 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
30018de0: eb000eb2 bl 3001c8b0 <_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: eb000b14 bl 3001ba7c <_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: eb000e94 bl 3001c8b0 <_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: eb000ce1 bl 3001c8b0 <_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: eb004e0b bl 3002ce24 <__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: eb000af3 bl 3001ba7c <_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: eb001222 bl 3001d764 <_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: eb0011c8 bl 3001d608 <_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: eb001217 bl 3001d764 <_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: eb000e64 bl 3001c8b0 <_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: eb000abe bl 3001ba7c <_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: eb0011f1 bl 3001d764 <_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: eb000e2f bl 3001c8b0 <_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: eb004f6b bl 3002ce24 <__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: eb000a7b bl 3001ba7c <_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: eb0011ae bl 3001d764 <_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: eb004f54 bl 3002ce24 <__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: eb000df0 bl 3001c8b0 <_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
3000aae0 <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;
3000aae0: e59f3020 ldr r3, [pc, #32] ; 3000ab08 <rtems_workspace_greedy_free+0x28><== NOT EXECUTED
void rtems_workspace_greedy_free( void *opaque )
{
3000aae4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000aae8: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000aaec: e1a01000 mov r1, r0 <== NOT EXECUTED
++level;
3000aaf0: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000aaf4: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Disable_dispatch(); _Heap_Greedy_free( &_Workspace_Area, opaque );
3000aaf8: e59f000c ldr r0, [pc, #12] ; 3000ab0c <rtems_workspace_greedy_free+0x2c><== NOT EXECUTED 3000aafc: eb0002d5 bl 3000b658 <_Heap_Greedy_free> <== NOT EXECUTED
_Thread_Enable_dispatch(); }
3000ab00: 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();
3000ab04: ea000881 b 3000cd10 <_Thread_Enable_dispatch> <== NOT EXECUTED
3000a968 <sched_get_priority_max>:
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
3000a968: e3500004 cmp r0, #4 <== NOT EXECUTED
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
3000a96c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
switch ( policy ) {
3000a970: 8a000003 bhi 3000a984 <sched_get_priority_max+0x1c> <== NOT EXECUTED 3000a974: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a978: e1a00013 lsl r0, r3, r0 <== NOT EXECUTED 3000a97c: e3100017 tst r0, #23 <== NOT EXECUTED 3000a980: 1a000004 bne 3000a998 <sched_get_priority_max+0x30> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000a984: eb001f49 bl 300126b0 <__errno> <== NOT EXECUTED
3000a988: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a98c: e5803000 str r3, [r0] <== NOT EXECUTED
3000a990: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a994: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
3000a998: e59f3008 ldr r3, [pc, #8] ; 3000a9a8 <sched_get_priority_max+0x40><== NOT EXECUTED 3000a99c: e5d30000 ldrb r0, [r3] <== NOT EXECUTED 3000a9a0: e2400001 sub r0, r0, #1 <== NOT EXECUTED
}
3000a9a4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a9ac <sched_get_priority_min>:
*/
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
3000a9ac: e3500004 cmp r0, #4 <== NOT EXECUTED
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
3000a9b0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
switch ( policy ) {
3000a9b4: 8a000003 bhi 3000a9c8 <sched_get_priority_min+0x1c> <== NOT EXECUTED 3000a9b8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a9bc: e1a00013 lsl r0, r3, r0 <== NOT EXECUTED 3000a9c0: e3100017 tst r0, #23 <== NOT EXECUTED 3000a9c4: 1a000004 bne 3000a9dc <sched_get_priority_min+0x30> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000a9c8: eb001f38 bl 300126b0 <__errno> <== NOT EXECUTED
3000a9cc: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a9d0: e5803000 str r3, [r0] <== NOT EXECUTED
3000a9d4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a9d8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
3000a9dc: e1a00003 mov r0, r3 <== NOT EXECUTED
}
3000a9e0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009ee4 <sched_getparam>:
*/
int sched_getparam(
pid_t pid __attribute__((unused)),
struct sched_param *param __attribute__((unused))
)
{
30009ee4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009ee8: eb002047 bl 3001200c <__errno> <== NOT EXECUTED 30009eec: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009ef0: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009ef4: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009ef8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009efc <sched_getscheduler>:
#include <rtems/posix/time.h>
int sched_getscheduler(
pid_t pid __attribute__((unused))
)
{
30009efc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009f00: eb002041 bl 3001200c <__errno> <== NOT EXECUTED 30009f04: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009f08: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009f0c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009f10: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a9e4 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
3000a9e4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
3000a9e8: e2505000 subs r5, r0, #0 <== NOT EXECUTED
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
3000a9ec: e1a04001 mov r4, r1 <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
3000a9f0: 0a000005 beq 3000aa0c <sched_rr_get_interval+0x28> <== NOT EXECUTED 3000a9f4: ebfff080 bl 30006bfc <getpid> <== NOT EXECUTED 3000a9f8: e1550000 cmp r5, r0 <== NOT EXECUTED 3000a9fc: 0a000002 beq 3000aa0c <sched_rr_get_interval+0x28> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
3000aa00: eb001f2a bl 300126b0 <__errno> <== NOT EXECUTED 3000aa04: e3a03003 mov r3, #3 <== NOT EXECUTED 3000aa08: ea000003 b 3000aa1c <sched_rr_get_interval+0x38> <== NOT EXECUTED
if ( !interval )
3000aa0c: e3540000 cmp r4, #0 <== NOT EXECUTED 3000aa10: 1a000004 bne 3000aa28 <sched_rr_get_interval+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000aa14: eb001f25 bl 300126b0 <__errno> <== NOT EXECUTED
3000aa18: e3a03016 mov r3, #22 <== NOT EXECUTED
3000aa1c: e5803000 str r3, [r0] <== NOT EXECUTED
3000aa20: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000aa24: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
3000aa28: e59f3010 ldr r3, [pc, #16] ; 3000aa40 <sched_rr_get_interval+0x5c><== NOT EXECUTED 3000aa2c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000aa30: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000aa34: eb000db0 bl 3000e0fc <_Timespec_From_ticks> <== NOT EXECUTED
return 0;
3000aa38: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000aa3c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30009f14 <sched_setparam>:
int sched_setparam(
pid_t pid __attribute__((unused)),
const struct sched_param *param __attribute__((unused))
)
{
30009f14: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009f18: eb00203b bl 3001200c <__errno> <== NOT EXECUTED 30009f1c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009f20: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009f24: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009f28: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009f2c <sched_setscheduler>:
int sched_setscheduler(
pid_t pid __attribute__((unused)),
int policy __attribute__((unused)),
const struct sched_param *param __attribute__((unused))
)
{
30009f2c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009f30: eb002035 bl 3001200c <__errno> <== NOT EXECUTED 30009f34: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009f38: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009f3c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009f40: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000cd50 <sem_close>:
#include <rtems/seterr.h>
int sem_close(
sem_t *sem
)
{
3000cd50: e92d4011 push {r0, r4, lr}
3000cd54: e1a03000 mov r3, r0
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
3000cd58: e5931000 ldr r1, [r3] 3000cd5c: e59f0040 ldr r0, [pc, #64] ; 3000cda4 <sem_close+0x54> 3000cd60: e1a0200d mov r2, sp 3000cd64: eb00084e bl 3000eea4 <_Objects_Get>
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000cd68: e59d4000 ldr r4, [sp] 3000cd6c: e3540000 cmp r4, #0
3000cd70: 1a000006 bne 3000cd90 <sem_close+0x40>
case OBJECTS_LOCAL:
the_semaphore->open_count -= 1;
3000cd74: e5902018 ldr r2, [r0, #24] 3000cd78: e2422001 sub r2, r2, #1 3000cd7c: e5802018 str r2, [r0, #24]
_POSIX_Semaphore_Delete( the_semaphore );
3000cd80: eb0017af bl 30012c44 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
3000cd84: eb000bb1 bl 3000fc50 <_Thread_Enable_dispatch>
return 0;
3000cd88: e1a00004 mov r0, r4 3000cd8c: ea000003 b 3000cda0 <sem_close+0x50>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000cd90: eb002241 bl 3001569c <__errno> <== NOT EXECUTED 3000cd94: e3a03016 mov r3, #22 <== NOT EXECUTED 3000cd98: e5803000 str r3, [r0] <== NOT EXECUTED 3000cd9c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000cda0: e8bd8018 pop {r3, r4, pc}
3000cda8 <sem_destroy>:
#include <rtems/seterr.h>
int sem_destroy(
sem_t *sem
)
{
3000cda8: e92d4011 push {r0, r4, lr}
3000cdac: e1a03000 mov r3, r0
3000cdb0: e1a0200d mov r2, sp
3000cdb4: e59f0048 ldr r0, [pc, #72] ; 3000ce04 <sem_destroy+0x5c>
3000cdb8: e5931000 ldr r1, [r3]
3000cdbc: eb000838 bl 3000eea4 <_Objects_Get>
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000cdc0: e59d2000 ldr r2, [sp] 3000cdc4: e3520000 cmp r2, #0
3000cdc8: 1a000008 bne 3000cdf0 <sem_destroy+0x48>
case OBJECTS_LOCAL:
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
3000cdcc: e5d04014 ldrb r4, [r0, #20] 3000cdd0: e3540000 cmp r4, #0
3000cdd4: 0a000001 beq 3000cde0 <sem_destroy+0x38>
_Thread_Enable_dispatch();
3000cdd8: eb000b9c bl 3000fc50 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000cddc: ea000003 b 3000cdf0 <sem_destroy+0x48> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
_POSIX_Semaphore_Delete( the_semaphore );
3000cde0: eb001797 bl 30012c44 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
3000cde4: eb000b99 bl 3000fc50 <_Thread_Enable_dispatch>
return 0;
3000cde8: e1a00004 mov r0, r4 3000cdec: ea000003 b 3000ce00 <sem_destroy+0x58>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000cdf0: eb002229 bl 3001569c <__errno> <== NOT EXECUTED 3000cdf4: e3a03016 mov r3, #22 <== NOT EXECUTED 3000cdf8: e5803000 str r3, [r0] <== NOT EXECUTED 3000cdfc: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000ce00: e8bd8018 pop {r3, r4, pc}
3000ce08 <sem_getvalue>:
int sem_getvalue(
sem_t *sem,
int *sval
)
{
3000ce08: e92d4031 push {r0, r4, r5, lr}
3000ce0c: e1a03000 mov r3, r0
3000ce10: e1a04001 mov r4, r1
3000ce14: e59f003c ldr r0, [pc, #60] ; 3000ce58 <sem_getvalue+0x50>
3000ce18: e5931000 ldr r1, [r3]
3000ce1c: e1a0200d mov r2, sp
3000ce20: eb00081f bl 3000eea4 <_Objects_Get>
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000ce24: e59d5000 ldr r5, [sp] 3000ce28: e3550000 cmp r5, #0
3000ce2c: 1a000004 bne 3000ce44 <sem_getvalue+0x3c>
case OBJECTS_LOCAL:
*sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore );
3000ce30: e5903064 ldr r3, [r0, #100] ; 0x64 3000ce34: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
3000ce38: eb000b84 bl 3000fc50 <_Thread_Enable_dispatch>
return 0;
3000ce3c: e1a00005 mov r0, r5 3000ce40: ea000003 b 3000ce54 <sem_getvalue+0x4c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000ce44: eb002214 bl 3001569c <__errno> <== NOT EXECUTED 3000ce48: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ce4c: e5803000 str r3, [r0] <== NOT EXECUTED 3000ce50: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000ce54: e8bd8038 pop {r3, r4, r5, pc}
3000a4bc <sem_init>:
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
3000a4bc: e92d4013 push {r0, r1, r4, lr}
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
3000a4c0: e2504000 subs r4, r0, #0
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
3000a4c4: e1a0c001 mov ip, r1 3000a4c8: e1a03002 mov r3, r2
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
3000a4cc: 1a000004 bne 3000a4e4 <sem_init+0x28>
rtems_set_errno_and_return_minus_one( EINVAL );
3000a4d0: eb00203f bl 300125d4 <__errno> <== NOT EXECUTED 3000a4d4: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a4d8: e5803000 str r3, [r0] <== NOT EXECUTED 3000a4dc: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000a4e0: ea000009 b 3000a50c <sem_init+0x50> <== NOT EXECUTED
status = _POSIX_Semaphore_Create_support(
3000a4e4: e28d2004 add r2, sp, #4 3000a4e8: e3a00000 mov r0, #0 3000a4ec: e58d2000 str r2, [sp] 3000a4f0: e1a01000 mov r1, r0 3000a4f4: e1a0200c mov r2, ip 3000a4f8: eb0016ce bl 30010038 <_POSIX_Semaphore_Create_support>
pshared,
value,
&the_semaphore
);
if ( status != -1 )
3000a4fc: e3700001 cmn r0, #1
*sem = the_semaphore->Object.id;
3000a500: 159d3004 ldrne r3, [sp, #4] 3000a504: 15933008 ldrne r3, [r3, #8] 3000a508: 15843000 strne r3, [r4]
return status;
}
3000a50c: e8bd801c pop {r2, r3, r4, pc}
3000af50 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
3000af50: e92d000e push {r1, r2, r3}
3000af54: e92d41f0 push {r4, r5, r6, r7, r8, lr}
*
* 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;
3000af58: e59f30fc ldr r3, [pc, #252] ; 3000b05c <sem_open+0x10c> 3000af5c: e24dd018 sub sp, sp, #24 3000af60: e5932000 ldr r2, [r3] 3000af64: e59d4030 ldr r4, [sp, #48] ; 0x30
++level;
3000af68: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000af6c: e5832000 str r2, [r3] 3000af70: e1a06000 mov r6, r0
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
3000af74: e2147c02 ands r7, r4, #512 ; 0x200
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
3000af78: 128d303c addne r3, sp, #60 ; 0x3c 3000af7c: 158d3004 strne r3, [sp, #4]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
3000af80: e59f00d8 ldr r0, [pc, #216] ; 3000b060 <sem_open+0x110> 3000af84: e1a01006 mov r1, r6 3000af88: e28d2008 add r2, sp, #8 3000af8c: e28d3014 add r3, sp, #20 3000af90: 159d5038 ldrne r5, [sp, #56] ; 0x38
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
3000af94: 01a05007 moveq r5, r7 3000af98: ebfffe79 bl 3000a984 <_POSIX_Name_to_id>
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
3000af9c: e2508000 subs r8, r0, #0
3000afa0: 0a000007 beq 3000afc4 <sem_open+0x74>
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
3000afa4: e3580002 cmp r8, #2
3000afa8: 1a000001 bne 3000afb4 <sem_open+0x64>
3000afac: e3570000 cmp r7, #0
3000afb0: 1a000017 bne 3000b014 <sem_open+0xc4>
_Thread_Enable_dispatch();
3000afb4: eb000d0b bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
3000afb8: eb0021db bl 3001372c <__errno> <== NOT EXECUTED 3000afbc: e5808000 str r8, [r0] <== NOT EXECUTED 3000afc0: ea000006 b 3000afe0 <sem_open+0x90> <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
3000afc4: e2044c0a and r4, r4, #2560 ; 0xa00 3000afc8: e3540c0a cmp r4, #2560 ; 0xa00
3000afcc: 1a000005 bne 3000afe8 <sem_open+0x98>
_Thread_Enable_dispatch();
3000afd0: eb000d04 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
3000afd4: eb0021d4 bl 3001372c <__errno> <== NOT EXECUTED 3000afd8: e3a03011 mov r3, #17 <== NOT EXECUTED 3000afdc: e5803000 str r3, [r0] <== NOT EXECUTED 3000afe0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000afe4: ea000018 b 3000b04c <sem_open+0xfc> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
3000afe8: e59d1008 ldr r1, [sp, #8] 3000afec: e28d2010 add r2, sp, #16 3000aff0: e59f0068 ldr r0, [pc, #104] ; 3000b060 <sem_open+0x110> 3000aff4: eb000959 bl 3000d560 <_Objects_Get>
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
the_semaphore->open_count += 1;
3000aff8: e5903018 ldr r3, [r0, #24]
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
3000affc: e58d000c str r0, [sp, #12]
the_semaphore->open_count += 1;
3000b000: e2833001 add r3, r3, #1 3000b004: e5803018 str r3, [r0, #24]
_Thread_Enable_dispatch();
3000b008: eb000cf6 bl 3000e3e8 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
3000b00c: eb000cf5 bl 3000e3e8 <_Thread_Enable_dispatch>
goto return_id;
3000b010: ea00000b b 3000b044 <sem_open+0xf4>
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
3000b014: e28d300c add r3, sp, #12 3000b018: e58d3000 str r3, [sp] 3000b01c: e59d1014 ldr r1, [sp, #20] 3000b020: e3a02000 mov r2, #0 3000b024: e1a03005 mov r3, r5 3000b028: e1a00006 mov r0, r6 3000b02c: eb001819 bl 30011098 <_POSIX_Semaphore_Create_support> 3000b030: e1a04000 mov r4, r0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
3000b034: eb000ceb bl 3000e3e8 <_Thread_Enable_dispatch>
if ( status == -1 )
3000b038: e3740001 cmn r4, #1
return SEM_FAILED;
3000b03c: 01a00004 moveq r0, r4
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
3000b040: 0a000001 beq 3000b04c <sem_open+0xfc>
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
return &the_semaphore->Semaphore_id;
#else
return (sem_t *)&the_semaphore->Object.id;
3000b044: e59d000c ldr r0, [sp, #12] 3000b048: e2800008 add r0, r0, #8
#endif }
3000b04c: e28dd018 add sp, sp, #24
3000b050: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
3000b054: e28dd00c add sp, sp, #12
3000b058: e12fff1e bx lr
3000a510 <sem_post>:
#include <rtems/seterr.h>
int sem_post(
sem_t *sem
)
{
3000a510: e92d4011 push {r0, r4, lr}
3000a514: e1a03000 mov r3, r0
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
3000a518: e5931000 ldr r1, [r3] 3000a51c: e59f0044 ldr r0, [pc, #68] ; 3000a568 <sem_post+0x58> 3000a520: e1a0200d mov r2, sp 3000a524: eb0007e7 bl 3000c4c8 <_Objects_Get>
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000a528: e59d4000 ldr r4, [sp] 3000a52c: e1a03000 mov r3, r0 3000a530: e3540000 cmp r4, #0
3000a534: 1a000006 bne 3000a554 <sem_post+0x44>
case OBJECTS_LOCAL:
_CORE_semaphore_Surrender(
3000a538: e5931008 ldr r1, [r3, #8] 3000a53c: e1a02004 mov r2, r4 3000a540: e280001c add r0, r0, #28 3000a544: eb000550 bl 3000ba8c <_CORE_semaphore_Surrender>
NULL /* XXX need to define a routine to handle this case */
#else
NULL
#endif
);
_Thread_Enable_dispatch();
3000a548: eb000b49 bl 3000d274 <_Thread_Enable_dispatch>
return 0;
3000a54c: e1a00004 mov r0, r4 3000a550: ea000003 b 3000a564 <sem_post+0x54>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000a554: eb00201e bl 300125d4 <__errno> <== NOT EXECUTED 3000a558: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a55c: e5803000 str r3, [r0] <== NOT EXECUTED 3000a560: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000a564: e8bd8018 pop {r3, r4, pc}
3000d020 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
3000d020: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000d024: e1a04000 mov r4, r0 <== NOT EXECUTED
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000d028: e1a00001 mov r0, r1 <== NOT EXECUTED 3000d02c: e1a0100d mov r1, sp <== NOT EXECUTED 3000d030: eb001463 bl 300121c4 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
3000d034: e2403003 sub r3, r0, #3 <== NOT EXECUTED 3000d038: e2731000 rsbs r1, r3, #0 <== NOT EXECUTED 3000d03c: e0a11003 adc r1, r1, r3 <== NOT EXECUTED 3000d040: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d044: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000d048: eb00171f bl 30012ccc <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
3000d04c: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000d05c <sem_unlink>:
*
* 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;
3000d05c: e59f3070 ldr r3, [pc, #112] ; 3000d0d4 <sem_unlink+0x78>
#include <rtems/seterr.h>
int sem_unlink(
const char *name
)
{
3000d060: e92d4073 push {r0, r1, r4, r5, r6, lr}
3000d064: e5932000 ldr r2, [r3]
3000d068: e1a01000 mov r1, r0
++level;
3000d06c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000d070: e5832000 str r2, [r3]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
3000d074: e59f405c ldr r4, [pc, #92] ; 3000d0d8 <sem_unlink+0x7c> 3000d078: e1a0200d mov r2, sp 3000d07c: e1a00004 mov r0, r4 3000d080: e28d3004 add r3, sp, #4 3000d084: eb00150b bl 300124b8 <_POSIX_Name_to_id>
size_t name_len;
_Thread_Disable_dispatch();
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id, &name_len );
if ( status != 0 ) {
3000d088: e2505000 subs r5, r0, #0
3000d08c: 0a000004 beq 3000d0a4 <sem_unlink+0x48>
_Thread_Enable_dispatch();
3000d090: eb000aee bl 3000fc50 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( status );
3000d094: eb002180 bl 3001569c <__errno> <== NOT EXECUTED 3000d098: e5805000 str r5, [r0] <== NOT EXECUTED 3000d09c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000d0a0: ea00000a b 3000d0d0 <sem_unlink+0x74> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3000d0a4: e594301c ldr r3, [r4, #28] 3000d0a8: e1dd20b0 ldrh r2, [sp]
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Namespace_remove (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Namespace_remove(
3000d0ac: e1a00004 mov r0, r4 3000d0b0: e7936102 ldr r6, [r3, r2, lsl #2] 3000d0b4: e1a01006 mov r1, r6
the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object(
&_POSIX_Semaphore_Information,
_Objects_Get_index( the_semaphore_id )
);
the_semaphore->linked = false;
3000d0b8: e5c65015 strb r5, [r6, #21] 3000d0bc: eb0007c5 bl 3000efd8 <_Objects_Namespace_remove>
_POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore );
3000d0c0: e1a00006 mov r0, r6 3000d0c4: eb0016de bl 30012c44 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
3000d0c8: eb000ae0 bl 3000fc50 <_Thread_Enable_dispatch>
return 0;
3000d0cc: e1a00005 mov r0, r5
}
3000d0d0: e8bd807c pop {r2, r3, r4, r5, r6, pc}
30009de8 <setitimer>:
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
if ( !value )
30009de8: e3510000 cmp r1, #0 <== NOT EXECUTED
int setitimer(
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
30009dec: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !value )
30009df0: 0a000001 beq 30009dfc <setitimer+0x14> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
30009df4: e3520000 cmp r2, #0 <== NOT EXECUTED 30009df8: 1a000002 bne 30009e08 <setitimer+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
30009dfc: eb00202f bl 30011ec0 <__errno> <== NOT EXECUTED 30009e00: e3a0300e mov r3, #14 <== NOT EXECUTED 30009e04: ea000006 b 30009e24 <setitimer+0x3c> <== NOT EXECUTED
switch ( which ) {
30009e08: e3500002 cmp r0, #2 <== NOT EXECUTED 30009e0c: 8a000002 bhi 30009e1c <setitimer+0x34> <== NOT EXECUTED
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
30009e10: eb00202a bl 30011ec0 <__errno> <== NOT EXECUTED 30009e14: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009e18: ea000001 b 30009e24 <setitimer+0x3c> <== NOT EXECUTED
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
30009e1c: eb002027 bl 30011ec0 <__errno> <== NOT EXECUTED 30009e20: e3a03016 mov r3, #22 <== NOT EXECUTED 30009e24: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009e28: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009e2c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a858 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
3000a858: e2523000 subs r3, r2, #0 <== NOT EXECUTED
*oact = _POSIX_signals_Vectors[ sig ];
3000a85c: 159f20b4 ldrne r2, [pc, #180] ; 3000a918 <sigaction+0xc0> <== NOT EXECUTED
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
3000a860: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000a864: e1a05001 mov r5, r1 <== NOT EXECUTED
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
3000a868: 13a0100c movne r1, #12 <== NOT EXECUTED 3000a86c: 10222091 mlane r2, r1, r0, r2 <== NOT EXECUTED
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
3000a870: e1a04000 mov r4, r0 <== NOT EXECUTED
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
3000a874: 18920007 ldmne r2, {r0, r1, r2} <== NOT EXECUTED
3000a878: 18830007 stmne r3, {r0, r1, r2} <== NOT EXECUTED
if ( !sig )
3000a87c: e3540000 cmp r4, #0 <== NOT EXECUTED 3000a880: 0a000004 beq 3000a898 <sigaction+0x40> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000a884: e2443001 sub r3, r4, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
3000a888: e353001f cmp r3, #31 <== NOT EXECUTED 3000a88c: 8a000001 bhi 3000a898 <sigaction+0x40> <== NOT EXECUTED
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
3000a890: e3540009 cmp r4, #9 <== NOT EXECUTED 3000a894: 1a000004 bne 3000a8ac <sigaction+0x54> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a898: eb002032 bl 30012968 <__errno> <== NOT EXECUTED
3000a89c: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a8a0: e5803000 str r3, [r0] <== NOT EXECUTED
3000a8a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a8a8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
3000a8ac: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a8b0: 0a000016 beq 3000a910 <sigaction+0xb8> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000a8b4: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000a8b8: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000a8bc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
3000a8c0: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000a8c4: e59f704c ldr r7, [pc, #76] ; 3000a918 <sigaction+0xc0> <== NOT EXECUTED 3000a8c8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a8cc: e3a0800c mov r8, #12 <== NOT EXECUTED 3000a8d0: 1a000006 bne 3000a8f0 <sigaction+0x98> <== NOT EXECUTED
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
3000a8d4: e0040498 mul r4, r8, r4 <== NOT EXECUTED
3000a8d8: e59f803c ldr r8, [pc, #60] ; 3000a91c <sigaction+0xc4> <== NOT EXECUTED
3000a8dc: e0873004 add r3, r7, r4 <== NOT EXECUTED
3000a8e0: e0884004 add r4, r8, r4 <== NOT EXECUTED
3000a8e4: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
3000a8e8: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
3000a8ec: ea000004 b 3000a904 <sigaction+0xac> <== NOT EXECUTED
} else {
_POSIX_signals_Clear_process_signals( sig );
3000a8f0: e1a00004 mov r0, r4 <== NOT EXECUTED
_POSIX_signals_Vectors[ sig ] = *act;
3000a8f4: e0247498 mla r4, r8, r4, r7 <== NOT EXECUTED
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
3000a8f8: eb00156f bl 3000febc <_POSIX_signals_Clear_process_signals><== NOT EXECUTED
_POSIX_signals_Vectors[ sig ] = *act;
3000a8fc: e8950007 ldm r5, {r0, r1, r2} <== NOT EXECUTED
3000a900: e8840007 stm r4, {r0, r1, r2} <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a904: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
3000a908: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a90c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000a910: e1a00005 mov r0, r5 <== NOT EXECUTED
}
3000a914: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000a920 <sigaddset>:
int sigaddset(
sigset_t *set,
int signo
)
{
if ( !set )
3000a920: e3500000 cmp r0, #0 <== NOT EXECUTED
int sigaddset(
sigset_t *set,
int signo
)
{
3000a924: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000a928: 0a000004 beq 3000a940 <sigaddset+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000a92c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a930: 0a000002 beq 3000a940 <sigaddset+0x20> <== NOT EXECUTED 3000a934: e2411001 sub r1, r1, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(signo) )
3000a938: e351001f cmp r1, #31 <== NOT EXECUTED 3000a93c: 9a000004 bls 3000a954 <sigaddset+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a940: eb002008 bl 30012968 <__errno> <== NOT EXECUTED
3000a944: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a948: e5803000 str r3, [r0] <== NOT EXECUTED
3000a94c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a950: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*set |= signo_to_mask(signo);
3000a954: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000a958: e3a02001 mov r2, #1 <== NOT EXECUTED 3000a95c: e1831112 orr r1, r3, r2, lsl r1 <== NOT EXECUTED 3000a960: e5801000 str r1, [r0] <== NOT EXECUTED
return 0;
3000a964: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000a968: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c880 <sigdelset>:
int sigdelset(
sigset_t *set,
int signo
)
{
if ( !set )
3000c880: e3500000 cmp r0, #0 <== NOT EXECUTED
int sigdelset(
sigset_t *set,
int signo
)
{
3000c884: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000c888: 0a000004 beq 3000c8a0 <sigdelset+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000c88c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c890: 0a00000d beq 3000c8cc <sigdelset+0x4c> <== NOT EXECUTED 3000c894: e2411001 sub r1, r1, #1 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
3000c898: e351001f cmp r1, #31 <== NOT EXECUTED 3000c89c: 9a000004 bls 3000c8b4 <sigdelset+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000c8a0: eb002074 bl 30014a78 <__errno> <== NOT EXECUTED
3000c8a4: e3a03016 mov r3, #22 <== NOT EXECUTED
3000c8a8: e5803000 str r3, [r0] <== NOT EXECUTED
3000c8ac: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000c8b0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*set &= ~signo_to_mask(signo);
3000c8b4: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000c8b8: e3a02001 mov r2, #1 <== NOT EXECUTED 3000c8bc: e1c31112 bic r1, r3, r2, lsl r1 <== NOT EXECUTED 3000c8c0: e5801000 str r1, [r0] <== NOT EXECUTED
return 0;
3000c8c4: e3a00000 mov r0, #0 <== NOT EXECUTED
3000c8c8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
return 0;
3000c8cc: e1a00001 mov r0, r1 <== NOT EXECUTED
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
*set &= ~signo_to_mask(signo);
return 0;
}
3000c8d0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000f354 <sigemptyset>:
int sigemptyset(
sigset_t *set
)
{
if ( !set )
3000f354: e2503000 subs r3, r0, #0
#include <rtems/seterr.h>
int sigemptyset(
sigset_t *set
)
{
3000f358: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( !set )
3000f35c: 1a000004 bne 3000f374 <sigemptyset+0x20>
rtems_set_errno_and_return_minus_one( EINVAL );
3000f360: eb000981 bl 3001196c <__errno> <== NOT EXECUTED
3000f364: e3a03016 mov r3, #22 <== NOT EXECUTED
3000f368: e5803000 str r3, [r0] <== NOT EXECUTED
3000f36c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000f370: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*set = 0;
3000f374: e3a00000 mov r0, #0 3000f378: e5830000 str r0, [r3]
return 0; }
3000f37c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
3000c900 <sigfillset>:
int sigfillset(
sigset_t *set
)
{
if ( !set )
3000c900: e3500000 cmp r0, #0 <== NOT EXECUTED
#include <rtems/seterr.h>
int sigfillset(
sigset_t *set
)
{
3000c904: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000c908: 1a000004 bne 3000c920 <sigfillset+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000c90c: eb002059 bl 30014a78 <__errno> <== NOT EXECUTED
3000c910: e3a03016 mov r3, #22 <== NOT EXECUTED
3000c914: e5803000 str r3, [r0] <== NOT EXECUTED
3000c918: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000c91c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*set = SIGNAL_ALL_MASK;
3000c920: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000c924: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
3000c928: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000c92c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c930 <sigismember>:
int sigismember(
const sigset_t *set,
int signo
)
{
if ( !set )
3000c930: e3500000 cmp r0, #0 <== NOT EXECUTED
int sigismember(
const sigset_t *set,
int signo
)
{
3000c934: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000c938: 0a000004 beq 3000c950 <sigismember+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000c93c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c940: 0a00000d beq 3000c97c <sigismember+0x4c> <== NOT EXECUTED 3000c944: e2411001 sub r1, r1, #1 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
3000c948: e351001f cmp r1, #31 <== NOT EXECUTED 3000c94c: 9a000004 bls 3000c964 <sigismember+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000c950: eb002048 bl 30014a78 <__errno> <== NOT EXECUTED
3000c954: e3a03016 mov r3, #22 <== NOT EXECUTED
3000c958: e5803000 str r3, [r0] <== NOT EXECUTED
3000c95c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000c960: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( *set & signo_to_mask(signo) )
3000c964: e5903000 ldr r3, [r0] <== NOT EXECUTED
const sigset_t *set,
int signo
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000c968: e3a02001 mov r2, #1 <== NOT EXECUTED
3000c96c: e0133112 ands r3, r3, r2, lsl r1 <== NOT EXECUTED
3000c970: 03a00000 moveq r0, #0 <== NOT EXECUTED
3000c974: 13a00001 movne r0, #1 <== NOT EXECUTED
3000c978: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
return 0;
3000c97c: e1a00001 mov r0, r1 <== NOT EXECUTED
if ( *set & signo_to_mask(signo) )
return 1;
return 0;
}
3000c980: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a6c8 <signal>:
sighandler_t signal(
int signum,
sighandler_t handler
)
{
3000a6c8: e92d4010 push {r4, lr} <== NOT EXECUTED
3000a6cc: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
3000a6d0: e1a04000 mov r4, r0 <== NOT EXECUTED
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
sigemptyset(&s.sa_mask);
3000a6d4: e28d0004 add r0, sp, #4 <== NOT EXECUTED
)
{
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
3000a6d8: e58d1008 str r1, [sp, #8] <== NOT EXECUTED
sigemptyset(&s.sa_mask);
3000a6dc: ebffffee bl 3000a69c <sigemptyset> <== NOT EXECUTED
s.sa_flags = SA_RESTART | SA_INTERRUPT | SA_NOMASK; s.sa_restorer= NULL ; #elif defined(signal_like_SVR4) s.sa_flags = SA_RESTART; #else s.sa_flags = 0;
3000a6e0: e3a03000 mov r3, #0 <== NOT EXECUTED
#endif
sigaction( signum, &s, &old );
3000a6e4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a6e8: e1a0100d mov r1, sp <== NOT EXECUTED 3000a6ec: e28d200c add r2, sp, #12 <== NOT EXECUTED
s.sa_flags = SA_RESTART | SA_INTERRUPT | SA_NOMASK; s.sa_restorer= NULL ; #elif defined(signal_like_SVR4) s.sa_flags = SA_RESTART; #else s.sa_flags = 0;
3000a6f0: e58d3000 str r3, [sp] <== NOT EXECUTED
#endif
sigaction( signum, &s, &old );
3000a6f4: ebffffa3 bl 3000a588 <sigaction> <== NOT EXECUTED
return (sighandler_t) old.sa_handler; }
3000a6f8: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
3000a6fc: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3000a700: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a998 <sigpending>:
sigset_t *set
)
{
POSIX_API_Control *api;
if ( !set )
3000a998: e3500000 cmp r0, #0 <== NOT EXECUTED
#include <rtems/seterr.h>
int sigpending(
sigset_t *set
)
{
3000a99c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set )
3000a9a0: 1a000004 bne 3000a9b8 <sigpending+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a9a4: eb001fef bl 30012968 <__errno> <== NOT EXECUTED
3000a9a8: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a9ac: e5803000 str r3, [r0] <== NOT EXECUTED
3000a9b0: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a9b4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000a9b8: e59f3020 ldr r3, [pc, #32] ; 3000a9e0 <sigpending+0x48> <== NOT EXECUTED
*set = api->signals_pending | _POSIX_signals_Pending;
3000a9bc: e59f2020 ldr r2, [pc, #32] ; 3000a9e4 <sigpending+0x4c> <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000a9c0: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
*set = api->signals_pending | _POSIX_signals_Pending;
3000a9c4: e5922000 ldr r2, [r2] <== NOT EXECUTED 3000a9c8: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED 3000a9cc: e59330d4 ldr r3, [r3, #212] ; 0xd4 <== NOT EXECUTED 3000a9d0: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000a9d4: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
3000a9d8: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000a9dc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a9e8 <sigprocmask>:
/*
* P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask.
*/
#if defined(RTEMS_POSIX_API)
return pthread_sigmask( how, set, oset );
3000a9e8: ea0016c7 b 3001050c <pthread_sigmask> <== NOT EXECUTED
3000c9d8 <sigqueue>:
int sigqueue(
pid_t pid,
int signo,
const union sigval value
)
{
3000c9d8: e92d4001 push {r0, lr} <== NOT EXECUTED
3000c9dc: e28d3004 add r3, sp, #4 <== NOT EXECUTED
3000c9e0: e5232004 str r2, [r3, #-4]! <== NOT EXECUTED
return killinfo( pid, signo, &value );
3000c9e4: e1a0200d mov r2, sp <== NOT EXECUTED 3000c9e8: eb001572 bl 30011fb8 <killinfo> <== NOT EXECUTED
}
3000c9ec: e8bd8008 pop {r3, pc} <== NOT EXECUTED
3000c9f0 <sigsuspend>:
#include <rtems/seterr.h>
int sigsuspend(
const sigset_t *sigmask
)
{
3000c9f0: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
3000c9f4: e1a04000 mov r4, r0 <== NOT EXECUTED
/* * We use SIG_BLOCK and not SIG_SETMASK because there may be * signals which might be pending, which might get caught here. * We want the signals to be caught inside sigtimedwait. */ status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked );
3000c9f8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000c9fc: e1a0200d mov r2, sp <== NOT EXECUTED 3000ca00: e3a00001 mov r0, #1 <== NOT EXECUTED 3000ca04: ebfffff2 bl 3000c9d4 <sigprocmask> <== NOT EXECUTED
current_unblocked_signals = ~(*sigmask);
3000ca08: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000ca0c: e28d0008 add r0, sp, #8 <== NOT EXECUTED 3000ca10: e1e03003 mvn r3, r3 <== NOT EXECUTED
status = sigtimedwait( ¤t_unblocked_signals, NULL, NULL );
3000ca14: e3a01000 mov r1, #0 <== NOT EXECUTED
* signals which might be pending, which might get caught here.
* We want the signals to be caught inside sigtimedwait.
*/
status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked );
current_unblocked_signals = ~(*sigmask);
3000ca18: e5203004 str r3, [r0, #-4]! <== NOT EXECUTED
status = sigtimedwait( ¤t_unblocked_signals, NULL, NULL );
3000ca1c: e1a02001 mov r2, r1 <== NOT EXECUTED 3000ca20: eb00001a bl 3000ca90 <sigtimedwait> <== NOT EXECUTED
(void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL );
3000ca24: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ca28: e1a0100d mov r1, sp <== NOT EXECUTED 3000ca2c: e1a02000 mov r2, r0 <== NOT EXECUTED 3000ca30: ebffffe7 bl 3000c9d4 <sigprocmask> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
assert( status != -1 );
#endif
rtems_set_errno_and_return_minus_one( EINTR );
3000ca34: eb00200f bl 30014a78 <__errno> <== NOT EXECUTED 3000ca38: e3a03004 mov r3, #4 <== NOT EXECUTED 3000ca3c: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000ca40: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000ca44: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
3000ad50 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
3000ad50: e92d45ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
3000ad54: e2506000 subs r6, r0, #0 <== NOT EXECUTED
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
3000ad58: e1a04001 mov r4, r1 <== NOT EXECUTED 3000ad5c: e1a05002 mov r5, r2 <== NOT EXECUTED
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
3000ad60: 0a000009 beq 3000ad8c <sigtimedwait+0x3c> <== NOT EXECUTED
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
3000ad64: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ad68: 0a00000a beq 3000ad98 <sigtimedwait+0x48> <== NOT EXECUTED
if ( !_Timespec_Is_valid( timeout ) )
3000ad6c: e1a00002 mov r0, r2 <== NOT EXECUTED 3000ad70: eb000def bl 3000e534 <_Timespec_Is_valid> <== NOT EXECUTED 3000ad74: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ad78: 0a000003 beq 3000ad8c <sigtimedwait+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
3000ad7c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ad80: eb000dfc bl 3000e578 <_Timespec_To_ticks> <== NOT EXECUTED
if ( !interval )
3000ad84: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000ad88: 1a000003 bne 3000ad9c <sigtimedwait+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000ad8c: eb00209a bl 30012ffc <__errno> <== NOT EXECUTED 3000ad90: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ad94: ea000055 b 3000aef0 <sigtimedwait+0x1a0> <== NOT EXECUTED
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
3000ad98: e1a01002 mov r1, r2 <== NOT EXECUTED
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
the_thread = _Thread_Executing;
3000ad9c: e59f3160 ldr r3, [pc, #352] ; 3000af04 <sigtimedwait+0x1b4><== NOT EXECUTED
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
3000ada0: e3540000 cmp r4, #0 <== NOT EXECUTED
the_thread = _Thread_Executing;
3000ada4: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
3000ada8: 028d4004 addeq r4, sp, #4 <== NOT EXECUTED
the_thread = _Thread_Executing;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000adac: e59380f4 ldr r8, [r3, #244] ; 0xf4 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000adb0: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000adb4: e3872080 orr r2, r7, #128 ; 0x80 <== NOT EXECUTED 3000adb8: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
*/
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
3000adbc: e5962000 ldr r2, [r6] <== NOT EXECUTED 3000adc0: e59800d4 ldr r0, [r8, #212] ; 0xd4 <== NOT EXECUTED 3000adc4: e012a000 ands sl, r2, r0 <== NOT EXECUTED 3000adc8: 0a00000d beq 3000ae04 <sigtimedwait+0xb4> <== NOT EXECUTED
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
3000adcc: ebffffcd bl 3000ad08 <_POSIX_signals_Get_lowest> <== NOT EXECUTED
_POSIX_signals_Clear_signals(
3000add0: e3a03000 mov r3, #0 <== NOT EXECUTED
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
3000add4: e5840000 str r0, [r4] <== NOT EXECUTED 3000add8: e1a01000 mov r1, r0 <== NOT EXECUTED
_POSIX_signals_Clear_signals(
3000addc: e1a02004 mov r2, r4 <== NOT EXECUTED 3000ade0: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ade4: e58d3000 str r3, [sp] <== NOT EXECUTED 3000ade8: eb001625 bl 30010684 <_POSIX_signals_Clear_signals> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000adec: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
3000adf0: e3a01001 mov r1, #1 <== NOT EXECUTED
3000adf4: e3a03000 mov r3, #0 <== NOT EXECUTED
3000adf8: e984000a stmib r4, {r1, r3} <== NOT EXECUTED
return the_info->si_signo;
3000adfc: e5945000 ldr r5, [r4] <== NOT EXECUTED 3000ae00: ea00003c b 3000aef8 <sigtimedwait+0x1a8> <== NOT EXECUTED
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
3000ae04: e59f00fc ldr r0, [pc, #252] ; 3000af08 <sigtimedwait+0x1b8><== NOT EXECUTED 3000ae08: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000ae0c: e1120000 tst r2, r0 <== NOT EXECUTED 3000ae10: 0a00000d beq 3000ae4c <sigtimedwait+0xfc> <== NOT EXECUTED
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
3000ae14: ebffffbb bl 3000ad08 <_POSIX_signals_Get_lowest> <== NOT EXECUTED 3000ae18: e1a05000 mov r5, r0 <== NOT EXECUTED
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
3000ae1c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ae20: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ae24: e1a02004 mov r2, r4 <== NOT EXECUTED 3000ae28: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ae2c: e58da000 str sl, [sp] <== NOT EXECUTED 3000ae30: eb001613 bl 30010684 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 3000ae34: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
3000ae38: e3a02001 mov r2, #1 <== NOT EXECUTED 3000ae3c: e3a03000 mov r3, #0 <== NOT EXECUTED
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
_ISR_Enable( level );
the_info->si_signo = signo;
3000ae40: e5845000 str r5, [r4] <== NOT EXECUTED
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
3000ae44: e984000c stmib r4, {r2, r3} <== NOT EXECUTED
return signo;
3000ae48: ea00002a b 3000aef8 <sigtimedwait+0x1a8> <== NOT EXECUTED
}
the_info->si_signo = -1;
3000ae4c: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000ae50: e5842000 str r2, [r4] <== 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;
3000ae54: e59f20b0 ldr r2, [pc, #176] ; 3000af0c <sigtimedwait+0x1bc><== NOT EXECUTED 3000ae58: e5920000 ldr r0, [r2] <== NOT EXECUTED
++level;
3000ae5c: e2800001 add r0, r0, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000ae60: e5820000 str r0, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
3000ae64: e3a00004 mov r0, #4 <== NOT EXECUTED 3000ae68: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
the_thread->Wait.option = *set;
3000ae6c: e5960000 ldr r0, [r6] <== NOT EXECUTED
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
3000ae70: e59f2098 ldr r2, [pc, #152] ; 3000af10 <sigtimedwait+0x1c0><== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
3000ae74: e5830030 str r0, [r3, #48] ; 0x30 <== NOT EXECUTED
the_thread->Wait.return_argument = the_info;
3000ae78: e5834028 str r4, [r3, #40] ; 0x28 <== NOT EXECUTED
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
3000ae7c: e5832044 str r2, [r3, #68] ; 0x44 <== 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;
3000ae80: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ae84: e5823030 str r3, [r2, #48] ; 0x30 <== NOT EXECUTED 3000ae88: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
the_thread->Wait.return_argument = the_info;
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
3000ae8c: e1a00002 mov r0, r2 <== NOT EXECUTED 3000ae90: e59f207c ldr r2, [pc, #124] ; 3000af14 <sigtimedwait+0x1c4><== NOT EXECUTED 3000ae94: eb000c65 bl 3000e030 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ae98: eb000b38 bl 3000db80 <_Thread_Enable_dispatch> <== NOT EXECUTED
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
3000ae9c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000aea0: e58d3000 str r3, [sp] <== NOT EXECUTED 3000aea4: e1a00008 mov r0, r8 <== NOT EXECUTED 3000aea8: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000aeac: e1a02004 mov r2, r4 <== NOT EXECUTED 3000aeb0: eb0015f3 bl 30010684 <_POSIX_signals_Clear_signals> <== NOT EXECUTED
/* Set errno only if return code is not EINTR or
* if EINTR was caused by a signal being caught, which
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
3000aeb4: e59f3048 ldr r3, [pc, #72] ; 3000af04 <sigtimedwait+0x1b4> <== NOT EXECUTED 3000aeb8: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000aebc: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000aec0: e3530004 cmp r3, #4 <== NOT EXECUTED 3000aec4: 1a000005 bne 3000aee0 <sigtimedwait+0x190> <== NOT EXECUTED
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
3000aec8: e5945000 ldr r5, [r4] <== NOT EXECUTED 3000aecc: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000aed0: e2452001 sub r2, r5, #1 <== NOT EXECUTED 3000aed4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000aed8: e0131211 ands r1, r3, r1, lsl r2 <== NOT EXECUTED 3000aedc: 1a000005 bne 3000aef8 <sigtimedwait+0x1a8> <== NOT EXECUTED
errno = _Thread_Executing->Wait.return_code;
3000aee0: eb002045 bl 30012ffc <__errno> <== NOT EXECUTED 3000aee4: e59f3018 ldr r3, [pc, #24] ; 3000af04 <sigtimedwait+0x1b4> <== NOT EXECUTED 3000aee8: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000aeec: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000aef0: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
3000aef4: e3e05000 mvn r5, #0 <== NOT EXECUTED
}
return the_info->si_signo;
}
3000aef8: e1a00005 mov r0, r5 <== NOT EXECUTED
3000aefc: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000af00: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000cc60 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
3000cc60: e92d4010 push {r4, lr} <== NOT EXECUTED
3000cc64: e1a04001 mov r4, r1 <== NOT EXECUTED
int status;
status = sigtimedwait( set, NULL, NULL );
3000cc68: e3a01000 mov r1, #0 <== NOT EXECUTED 3000cc6c: e1a02001 mov r2, r1 <== NOT EXECUTED 3000cc70: ebffff86 bl 3000ca90 <sigtimedwait> <== NOT EXECUTED
if ( status != -1 ) {
3000cc74: e3700001 cmn r0, #1 <== NOT EXECUTED 3000cc78: 0a000004 beq 3000cc90 <sigwait+0x30> <== NOT EXECUTED
if ( sig )
3000cc7c: e3540000 cmp r4, #0 <== NOT EXECUTED
*sig = status;
3000cc80: 15840000 strne r0, [r4] <== NOT EXECUTED
return 0;
3000cc84: 13a00000 movne r0, #0 <== NOT EXECUTED
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
3000cc88: 18bd8010 popne {r4, pc} <== NOT EXECUTED
3000cc8c: ea000002 b 3000cc9c <sigwait+0x3c> <== NOT EXECUTED
*sig = status;
return 0;
}
return errno;
3000cc90: eb001f78 bl 30014a78 <__errno> <== NOT EXECUTED
3000cc94: e5900000 ldr r0, [r0] <== NOT EXECUTED
3000cc98: e8bd8010 pop {r4, pc} <== NOT EXECUTED
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
3000cc9c: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
3000cca0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cc58 <sigwaitinfo>:
int sigwaitinfo(
const sigset_t *set,
siginfo_t *info
)
{
return sigtimedwait( set, info, NULL );
3000cc58: e3a02000 mov r2, #0 <== NOT EXECUTED 3000cc5c: eaffff8b b 3000ca90 <sigtimedwait> <== NOT EXECUTED
30009b84 <sysconf>:
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
30009b84: e3500002 cmp r0, #2 <== NOT EXECUTED
*/
long sysconf(
int name
)
{
30009b88: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( name == _SC_CLK_TCK )
30009b8c: 1a000004 bne 30009ba4 <sysconf+0x20> <== NOT EXECUTED
return (TOD_MICROSECONDS_PER_SECOND /
30009b90: e59f3058 ldr r3, [pc, #88] ; 30009bf0 <sysconf+0x6c> <== NOT EXECUTED
30009b94: e59f0058 ldr r0, [pc, #88] ; 30009bf4 <sysconf+0x70> <== NOT EXECUTED
30009b98: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
30009b9c: eb00442b bl 3001ac50 <__aeabi_uidiv> <== NOT EXECUTED
30009ba0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
30009ba4: e3500004 cmp r0, #4 <== NOT EXECUTED
return rtems_libio_number_iops;
30009ba8: 059f3048 ldreq r3, [pc, #72] ; 30009bf8 <sysconf+0x74> <== NOT EXECUTED 30009bac: 05930000 ldreq r0, [r3] <== NOT EXECUTED
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
30009bb0: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
30009bb4: e3500033 cmp r0, #51 ; 0x33 <== NOT EXECUTED
return 1024;
30009bb8: 03a00b01 moveq r0, #1024 ; 0x400 <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
30009bbc: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return 1024;
if ( name == _SC_PAGESIZE )
30009bc0: e3500008 cmp r0, #8 <== NOT EXECUTED
return PAGE_SIZE;
30009bc4: 03a00a01 moveq r0, #4096 ; 0x1000 <== NOT EXECUTED
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
return 1024;
if ( name == _SC_PAGESIZE )
30009bc8: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
30009bcc: e350004f cmp r0, #79 ; 0x4f <== NOT EXECUTED 30009bd0: 0a000004 beq 30009be8 <sysconf+0x64> <== NOT EXECUTED
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
30009bd4: eb00202c bl 30011c8c <__errno> <== NOT EXECUTED
30009bd8: e3a03016 mov r3, #22 <== NOT EXECUTED
30009bdc: e5803000 str r3, [r0] <== NOT EXECUTED
30009be0: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009be4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( name == _SC_PAGESIZE )
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
30009be8: e3a00020 mov r0, #32 <== NOT EXECUTED
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
30009bec: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b064 <timer_create>:
timer_t *timerid
)
{
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
3000b064: e3500001 cmp r0, #1 <== NOT EXECUTED
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
3000b068: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000b06c: e1a04001 mov r4, r1 <== NOT EXECUTED
3000b070: e1a05002 mov r5, r2 <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
3000b074: 1a00000d bne 3000b0b0 <timer_create+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
3000b078: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b07c: 0a00000b beq 3000b0b0 <timer_create+0x4c> <== NOT EXECUTED
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
3000b080: e3510000 cmp r1, #0 <== NOT EXECUTED 3000b084: 0a00000c beq 3000b0bc <timer_create+0x58> <== NOT EXECUTED
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
3000b088: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000b08c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000b090: e3530001 cmp r3, #1 <== NOT EXECUTED 3000b094: 8a000005 bhi 3000b0b0 <timer_create+0x4c> <== NOT EXECUTED
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
3000b098: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 3000b09c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b0a0: 0a000002 beq 3000b0b0 <timer_create+0x4c> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000b0a4: e2433001 sub r3, r3, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
3000b0a8: e353001f cmp r3, #31 <== NOT EXECUTED 3000b0ac: 9a000002 bls 3000b0bc <timer_create+0x58> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000b0b0: eb00219d bl 3001372c <__errno> <== NOT EXECUTED 3000b0b4: e3a03016 mov r3, #22 <== NOT EXECUTED 3000b0b8: ea00000a b 3000b0e8 <timer_create+0x84> <== 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;
3000b0bc: e59f30b8 ldr r3, [pc, #184] ; 3000b17c <timer_create+0x118><== NOT EXECUTED 3000b0c0: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3000b0c4: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000b0c8: e5832000 str r2, [r3] <== NOT EXECUTED
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
3000b0cc: e59f00ac ldr r0, [pc, #172] ; 3000b180 <timer_create+0x11c><== NOT EXECUTED 3000b0d0: eb0007fe bl 3000d0d0 <_Objects_Allocate> <== NOT EXECUTED
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
3000b0d4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b0d8: 1a000005 bne 3000b0f4 <timer_create+0x90> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b0dc: eb000cc1 bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
3000b0e0: eb002191 bl 3001372c <__errno> <== NOT EXECUTED
3000b0e4: e3a0300b mov r3, #11 <== NOT EXECUTED
3000b0e8: e5803000 str r3, [r0] <== NOT EXECUTED
3000b0ec: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b0f0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
3000b0f4: e3a03002 mov r3, #2 <== NOT EXECUTED 3000b0f8: e5c0303c strb r3, [r0, #60] ; 0x3c <== NOT EXECUTED
ptimer->thread_id = _Thread_Executing->Object.id;
3000b0fc: e59f3080 ldr r3, [pc, #128] ; 3000b184 <timer_create+0x120><== NOT EXECUTED
if ( evp != NULL ) {
3000b100: e3540000 cmp r4, #0 <== NOT EXECUTED
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
3000b104: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000b108: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000b10c: e5803038 str r3, [r0, #56] ; 0x38 <== NOT EXECUTED
if ( evp != NULL ) {
3000b110: 0a000005 beq 3000b12c <timer_create+0xc8> <== NOT EXECUTED
ptimer->inf.sigev_notify = evp->sigev_notify;
3000b114: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000b118: e5803040 str r3, [r0, #64] ; 0x40 <== NOT EXECUTED
ptimer->inf.sigev_signo = evp->sigev_signo;
3000b11c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000b120: e5803044 str r3, [r0, #68] ; 0x44 <== NOT EXECUTED
ptimer->inf.sigev_value = evp->sigev_value;
3000b124: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000b128: e5803048 str r3, [r0, #72] ; 0x48 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b12c: e59f204c ldr r2, [pc, #76] ; 3000b180 <timer_create+0x11c> <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000b130: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED 3000b134: e1d010b8 ldrh r1, [r0, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b138: e592201c ldr r2, [r2, #28] <== NOT EXECUTED
}
ptimer->overrun = 0;
3000b13c: e3a04000 mov r4, #0 <== NOT EXECUTED 3000b140: e5804068 str r4, [r0, #104] ; 0x68 <== NOT EXECUTED
ptimer->timer_data.it_value.tv_sec = 0;
3000b144: e580405c str r4, [r0, #92] ; 0x5c <== NOT EXECUTED
ptimer->timer_data.it_value.tv_nsec = 0;
3000b148: e5804060 str r4, [r0, #96] ; 0x60 <== NOT EXECUTED
ptimer->timer_data.it_interval.tv_sec = 0;
3000b14c: e5804054 str r4, [r0, #84] ; 0x54 <== NOT EXECUTED
ptimer->timer_data.it_interval.tv_nsec = 0;
3000b150: e5804058 str r4, [r0, #88] ; 0x58 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000b154: e5804018 str r4, [r0, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
3000b158: e580402c str r4, [r0, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
3000b15c: e5804030 str r4, [r0, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000b160: e5804034 str r4, [r0, #52] ; 0x34 <== NOT EXECUTED 3000b164: e7820101 str r0, [r2, r1, lsl #2] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000b168: e580400c str r4, [r0, #12] <== NOT EXECUTED
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
3000b16c: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b170: eb000c9c bl 3000e3e8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000b174: e1a00004 mov r0, r4 <== NOT EXECUTED
}
3000b178: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000a670 <timer_delete>:
int timer_delete(
timer_t timerid
)
{
3000a670: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3000a674: e1a01000 mov r1, r0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
3000a678: e1a0200d mov r2, sp <== NOT EXECUTED 3000a67c: e59f0058 ldr r0, [pc, #88] ; 3000a6dc <timer_delete+0x6c> <== NOT EXECUTED 3000a680: eb000879 bl 3000c86c <_Objects_Get> <== NOT EXECUTED
*/
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000a684: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000a688: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a68c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a690: 1a00000c bne 3000a6c8 <timer_delete+0x58> <== NOT EXECUTED
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Timer_Information, &ptimer->Object );
3000a694: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a698: e59f003c ldr r0, [pc, #60] ; 3000a6dc <timer_delete+0x6c> <== NOT EXECUTED 3000a69c: eb000770 bl 3000c464 <_Objects_Close> <== NOT EXECUTED
ptimer->state = POSIX_TIMER_STATE_FREE;
3000a6a0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a6a4: e5c4303c strb r3, [r4, #60] ; 0x3c <== NOT EXECUTED
(void) _Watchdog_Remove( &ptimer->Timer );
3000a6a8: e2840010 add r0, r4, #16 <== NOT EXECUTED 3000a6ac: eb000f77 bl 3000e490 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free (
POSIX_Timer_Control *the_timer
)
{
_Objects_Free( &_POSIX_Timer_Information, &the_timer->Object );
3000a6b0: e59f0024 ldr r0, [pc, #36] ; 3000a6dc <timer_delete+0x6c> <== NOT EXECUTED 3000a6b4: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a6b8: eb000816 bl 3000c718 <_Objects_Free> <== NOT EXECUTED
_POSIX_Timer_Free( ptimer );
_Thread_Enable_dispatch();
3000a6bc: eb000bd5 bl 3000d618 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a6c0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a6c4: ea000003 b 3000a6d8 <timer_delete+0x68> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000a6c8: eb0021f4 bl 30012ea0 <__errno> <== NOT EXECUTED 3000a6cc: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a6d0: e5803000 str r3, [r0] <== NOT EXECUTED 3000a6d4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000a6d8: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000b20c <timer_getoverrun>:
#include <rtems/posix/timer.h>
int timer_getoverrun(
timer_t timerid
)
{
3000b20c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000b210: e1a01000 mov r1, r0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
3000b214: e1a0200d mov r2, sp <== NOT EXECUTED 3000b218: e59f0034 ldr r0, [pc, #52] ; 3000b254 <timer_getoverrun+0x48><== NOT EXECUTED 3000b21c: eb00085d bl 3000d398 <_Objects_Get> <== NOT EXECUTED
int overrun;
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000b220: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000b224: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b228: 1a000003 bne 3000b23c <timer_getoverrun+0x30> <== NOT EXECUTED
case OBJECTS_LOCAL:
overrun = ptimer->overrun;
3000b22c: e5904068 ldr r4, [r0, #104] ; 0x68 <== NOT EXECUTED
ptimer->overrun = 0;
3000b230: e5803068 str r3, [r0, #104] ; 0x68 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b234: eb000bc2 bl 3000e144 <_Thread_Enable_dispatch> <== NOT EXECUTED
return overrun;
3000b238: ea000003 b 3000b24c <timer_getoverrun+0x40> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000b23c: eb00211e bl 300136bc <__errno> <== NOT EXECUTED 3000b240: e3a03016 mov r3, #22 <== NOT EXECUTED 3000b244: e5803000 str r3, [r0] <== NOT EXECUTED 3000b248: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
3000b24c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000b250: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000b258 <timer_gettime>:
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
3000b258: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
3000b25c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
3000b260: e1a05000 mov r5, r0 <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
3000b264: 0a000018 beq 3000b2cc <timer_gettime+0x74> <== NOT EXECUTED 3000b268: e59f1070 ldr r1, [pc, #112] ; 3000b2e0 <timer_gettime+0x88><== NOT EXECUTED 3000b26c: e1a0000d mov r0, sp <== NOT EXECUTED 3000b270: eb0005b6 bl 3000c950 <_TOD_Get_with_nanoseconds> <== NOT EXECUTED 3000b274: e1a01005 mov r1, r5 <== NOT EXECUTED 3000b278: e59f0064 ldr r0, [pc, #100] ; 3000b2e4 <timer_gettime+0x8c><== NOT EXECUTED 3000b27c: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000b280: eb000844 bl 3000d398 <_Objects_Get> <== NOT EXECUTED
/* Reads the current time */
_TOD_Get( ¤t_time );
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000b284: e59d6008 ldr r6, [sp, #8] <== NOT EXECUTED 3000b288: e1a05000 mov r5, r0 <== NOT EXECUTED 3000b28c: e3560000 cmp r6, #0 <== NOT EXECUTED 3000b290: 1a00000d bne 3000b2cc <timer_gettime+0x74> <== NOT EXECUTED
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
3000b294: e59f304c ldr r3, [pc, #76] ; 3000b2e8 <timer_gettime+0x90> <== NOT EXECUTED 3000b298: e5952024 ldr r2, [r5, #36] ; 0x24 <== NOT EXECUTED 3000b29c: e590001c ldr r0, [r0, #28] <== NOT EXECUTED 3000b2a0: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000b2a4: e0800002 add r0, r0, r2 <== NOT EXECUTED
_Watchdog_Ticks_since_boot; /* now */
_Timespec_From_ticks( left, &value->it_value );
3000b2a8: e0630000 rsb r0, r3, r0 <== NOT EXECUTED 3000b2ac: e2841008 add r1, r4, #8 <== NOT EXECUTED 3000b2b0: eb000e28 bl 3000eb58 <_Timespec_From_ticks> <== NOT EXECUTED
value->it_interval = ptimer->timer_data.it_interval;
3000b2b4: e2853054 add r3, r5, #84 ; 0x54 <== NOT EXECUTED
3000b2b8: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000b2bc: e884000c stm r4, {r2, r3} <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b2c0: eb000b9f bl 3000e144 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000b2c4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b2c8: ea000003 b 3000b2dc <timer_gettime+0x84> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000b2cc: eb0020fa bl 300136bc <__errno> <== NOT EXECUTED 3000b2d0: e3a03016 mov r3, #22 <== NOT EXECUTED 3000b2d4: e5803000 str r3, [r0] <== NOT EXECUTED 3000b2d8: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000b2dc: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
30009dd4 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
30009dd4: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
30009dd8: e2525000 subs r5, r2, #0 <== NOT EXECUTED
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
30009ddc: e24dd020 sub sp, sp, #32 <== NOT EXECUTED 30009de0: e1a08000 mov r8, r0 <== NOT EXECUTED 30009de4: e1a07001 mov r7, r1 <== NOT EXECUTED 30009de8: e1a04003 mov r4, r3 <== NOT EXECUTED
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
30009dec: 0a000053 beq 30009f40 <timer_settime+0x16c> <== NOT EXECUTED
/*
* First, it verifies if the structure "value" is correct
* if the number of nanoseconds is not correct return EINVAL
*/
if ( !_Timespec_Is_valid( &(value->it_value) ) ) {
30009df0: e2850008 add r0, r5, #8 <== NOT EXECUTED 30009df4: eb000e49 bl 3000d720 <_Timespec_Is_valid> <== NOT EXECUTED 30009df8: e3500000 cmp r0, #0 <== NOT EXECUTED 30009dfc: 0a00004f beq 30009f40 <timer_settime+0x16c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
30009e00: e1a00005 mov r0, r5 <== NOT EXECUTED 30009e04: eb000e45 bl 3000d720 <_Timespec_Is_valid> <== NOT EXECUTED 30009e08: e3500000 cmp r0, #0 <== NOT EXECUTED 30009e0c: 0a00004b beq 30009f40 <timer_settime+0x16c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
30009e10: e3570000 cmp r7, #0 <== NOT EXECUTED 30009e14: 13570004 cmpne r7, #4 <== NOT EXECUTED 30009e18: 1a000048 bne 30009f40 <timer_settime+0x16c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
30009e1c: e28d6004 add r6, sp, #4 <== NOT EXECUTED
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
30009e20: e3570004 cmp r7, #4 <== NOT EXECUTED
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
30009e24: e895000f ldm r5, {r0, r1, r2, r3} <== NOT EXECUTED
30009e28: e886000f stm r6, {r0, r1, r2, r3} <== NOT EXECUTED
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
30009e2c: 1a00000b bne 30009e60 <timer_settime+0x8c> <== NOT EXECUTED
struct timespec now;
_TOD_Get( &now );
30009e30: e28d0014 add r0, sp, #20 <== NOT EXECUTED
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
30009e34: e2866008 add r6, r6, #8 <== NOT EXECUTED
normalize = *value;
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
30009e38: ebffffd0 bl 30009d80 <_TOD_Get> <== NOT EXECUTED
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
30009e3c: e1a00006 mov r0, r6 <== NOT EXECUTED 30009e40: e28d1014 add r1, sp, #20 <== NOT EXECUTED 30009e44: eb000e46 bl 3000d764 <_Timespec_Less_than> <== NOT EXECUTED 30009e48: e3500000 cmp r0, #0 <== NOT EXECUTED 30009e4c: 1a00003b bne 30009f40 <timer_settime+0x16c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
30009e50: e28d0014 add r0, sp, #20 <== NOT EXECUTED 30009e54: e1a01006 mov r1, r6 <== NOT EXECUTED 30009e58: e1a02006 mov r2, r6 <== NOT EXECUTED 30009e5c: eb000e4e bl 3000d79c <_Timespec_Subtract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
30009e60: e59f00f0 ldr r0, [pc, #240] ; 30009f58 <timer_settime+0x184><== NOT EXECUTED 30009e64: e1a01008 mov r1, r8 <== NOT EXECUTED 30009e68: e28d201c add r2, sp, #28 <== NOT EXECUTED 30009e6c: eb000853 bl 3000bfc0 <_Objects_Get> <== NOT EXECUTED
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
30009e70: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 30009e74: e1a06000 mov r6, r0 <== NOT EXECUTED 30009e78: e3530000 cmp r3, #0 <== NOT EXECUTED 30009e7c: 1a00002f bne 30009f40 <timer_settime+0x16c> <== NOT EXECUTED
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
30009e80: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30009e84: e3530000 cmp r3, #0 <== NOT EXECUTED 30009e88: 1a00000e bne 30009ec8 <timer_settime+0xf4> <== NOT EXECUTED 30009e8c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30009e90: e3530000 cmp r3, #0 <== NOT EXECUTED 30009e94: 1a00000b bne 30009ec8 <timer_settime+0xf4> <== NOT EXECUTED
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
30009e98: e2800010 add r0, r0, #16 <== NOT EXECUTED 30009e9c: eb000f3e bl 3000db9c <_Watchdog_Remove> <== NOT EXECUTED
/* The old data of the timer are returned */
if ( ovalue )
30009ea0: e3540000 cmp r4, #0 <== NOT EXECUTED 30009ea4: e286c054 add ip, r6, #84 ; 0x54 <== NOT EXECUTED
*ovalue = ptimer->timer_data;
30009ea8: 189c000f ldmne ip, {r0, r1, r2, r3} <== NOT EXECUTED
30009eac: 1884000f stmne r4, {r0, r1, r2, r3} <== NOT EXECUTED
/* The new data are set */
ptimer->timer_data = normalize;
30009eb0: e28d3004 add r3, sp, #4 <== NOT EXECUTED
30009eb4: e893000f ldm r3, {r0, r1, r2, r3} <== NOT EXECUTED
30009eb8: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
30009ebc: e3a03004 mov r3, #4 <== NOT EXECUTED 30009ec0: e5c6303c strb r3, [r6, #60] ; 0x3c <== NOT EXECUTED 30009ec4: ea00001a b 30009f34 <timer_settime+0x160> <== NOT EXECUTED
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
30009ec8: e1a00005 mov r0, r5 <== NOT EXECUTED 30009ecc: eb000e43 bl 3000d7e0 <_Timespec_To_ticks> <== NOT EXECUTED
initial_period = _Timespec_To_ticks( &normalize.it_value );
30009ed0: e28d5004 add r5, sp, #4 <== NOT EXECUTED
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
30009ed4: e5860064 str r0, [r6, #100] ; 0x64 <== NOT EXECUTED
initial_period = _Timespec_To_ticks( &normalize.it_value );
30009ed8: e2850008 add r0, r5, #8 <== NOT EXECUTED 30009edc: eb000e3f bl 3000d7e0 <_Timespec_To_ticks> <== NOT EXECUTED
activated = _POSIX_Timer_Insert_helper(
30009ee0: e58d6000 str r6, [sp] <== NOT EXECUTED
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
initial_period = _Timespec_To_ticks( &normalize.it_value );
30009ee4: e1a01000 mov r1, r0 <== NOT EXECUTED
activated = _POSIX_Timer_Insert_helper(
30009ee8: e5962008 ldr r2, [r6, #8] <== NOT EXECUTED 30009eec: e2860010 add r0, r6, #16 <== NOT EXECUTED 30009ef0: e59f3064 ldr r3, [pc, #100] ; 30009f5c <timer_settime+0x188><== NOT EXECUTED 30009ef4: eb0016de bl 3000fa74 <_POSIX_Timer_Insert_helper> <== NOT EXECUTED
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
30009ef8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 30009efc: 1a000002 bne 30009f0c <timer_settime+0x138> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009f00: eb000b99 bl 3000cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009f04: e1a00007 mov r0, r7 <== NOT EXECUTED 30009f08: ea000010 b 30009f50 <timer_settime+0x17c> <== NOT EXECUTED
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
30009f0c: e3540000 cmp r4, #0 <== NOT EXECUTED 30009f10: e286c054 add ip, r6, #84 ; 0x54 <== NOT EXECUTED
*ovalue = ptimer->timer_data;
30009f14: 189c000f ldmne ip, {r0, r1, r2, r3} <== NOT EXECUTED
30009f18: 1884000f stmne r4, {r0, r1, r2, r3} <== NOT EXECUTED
ptimer->timer_data = normalize;
30009f1c: e895000f ldm r5, {r0, r1, r2, r3} <== NOT EXECUTED
30009f20: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
30009f24: e3a03003 mov r3, #3 <== NOT EXECUTED 30009f28: e5c6303c strb r3, [r6, #60] ; 0x3c <== NOT EXECUTED
_TOD_Get( &ptimer->time );
30009f2c: e286006c add r0, r6, #108 ; 0x6c <== NOT EXECUTED 30009f30: ebffff92 bl 30009d80 <_TOD_Get> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009f34: eb000b8c bl 3000cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009f38: e3a00000 mov r0, #0 <== NOT EXECUTED 30009f3c: ea000003 b 30009f50 <timer_settime+0x17c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
30009f40: eb00208e bl 30012180 <__errno> <== NOT EXECUTED 30009f44: e3a03016 mov r3, #22 <== NOT EXECUTED 30009f48: e5803000 str r3, [r0] <== NOT EXECUTED 30009f4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30009f50: e28dd020 add sp, sp, #32 <== NOT EXECUTED
30009f54: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30009ecc <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
30009ecc: e92d4073 push {r0, r1, r4, r5, r6, lr} <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
30009ed0: e59f60cc ldr r6, [pc, #204] ; 30009fa4 <ualarm+0xd8> <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
30009ed4: e1a05000 mov r5, r0 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
30009ed8: e596401c ldr r4, [r6, #28] <== NOT EXECUTED 30009edc: e3540000 cmp r4, #0 <== NOT EXECUTED 30009ee0: 1a000005 bne 30009efc <ualarm+0x30> <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30009ee4: e59f30bc ldr r3, [pc, #188] ; 30009fa8 <ualarm+0xdc> <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30009ee8: e5864008 str r4, [r6, #8] <== NOT EXECUTED
the_watchdog->routine = routine;
30009eec: e586301c str r3, [r6, #28] <== NOT EXECUTED
the_watchdog->id = id;
30009ef0: e5864020 str r4, [r6, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
30009ef4: e5864024 str r4, [r6, #36] ; 0x24 <== NOT EXECUTED 30009ef8: ea000013 b 30009f4c <ualarm+0x80> <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
30009efc: e1a00006 mov r0, r6 <== NOT EXECUTED 30009f00: eb000ec6 bl 3000da20 <_Watchdog_Remove> <== NOT EXECUTED
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
30009f04: e2400002 sub r0, r0, #2 <== NOT EXECUTED 30009f08: e3500001 cmp r0, #1 <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
30009f0c: 83a04000 movhi r4, #0 <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
30009f10: 8a00000d bhi 30009f4c <ualarm+0x80> <== NOT EXECUTED
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
30009f14: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 30009f18: e5960014 ldr r0, [r6, #20] <== NOT EXECUTED
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
30009f1c: e1a0100d mov r1, sp <== NOT EXECUTED
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
30009f20: e0800003 add r0, r0, r3 <== NOT EXECUTED 30009f24: e5963018 ldr r3, [r6, #24] <== NOT EXECUTED
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
30009f28: e59f407c ldr r4, [pc, #124] ; 30009fac <ualarm+0xe0> <== NOT EXECUTED
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
30009f2c: e0630000 rsb r0, r3, r0 <== NOT EXECUTED 30009f30: eb000d91 bl 3000d57c <_Timespec_From_ticks> <== NOT EXECUTED
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
30009f34: e59d3000 ldr r3, [sp] <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
30009f38: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 30009f3c: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
30009f40: e0040493 mul r4, r3, r4 <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
30009f44: eb004a30 bl 3001c80c <__aeabi_idiv> <== NOT EXECUTED 30009f48: e0804004 add r4, r0, r4 <== NOT EXECUTED
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
30009f4c: e3550000 cmp r5, #0 <== NOT EXECUTED 30009f50: 0a000011 beq 30009f9c <ualarm+0xd0> <== NOT EXECUTED
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
30009f54: e59f1050 ldr r1, [pc, #80] ; 30009fac <ualarm+0xe0> <== NOT EXECUTED 30009f58: e1a00005 mov r0, r5 <== NOT EXECUTED 30009f5c: eb0049e4 bl 3001c6f4 <__aeabi_uidiv> <== NOT EXECUTED
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
30009f60: e59f1044 ldr r1, [pc, #68] ; 30009fac <ualarm+0xe0> <== NOT EXECUTED
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
30009f64: e58d0000 str r0, [sp] <== NOT EXECUTED
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
30009f68: e1a00005 mov r0, r5 <== NOT EXECUTED 30009f6c: eb004a78 bl 3001c954 <__umodsi3> <== NOT EXECUTED 30009f70: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED 30009f74: e0030390 mul r3, r0, r3 <== NOT EXECUTED
ticks = _Timespec_To_ticks( &tp );
30009f78: e1a0000d mov r0, sp <== NOT EXECUTED
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
30009f7c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
ticks = _Timespec_To_ticks( &tp );
30009f80: eb000d8f bl 3000d5c4 <_Timespec_To_ticks> <== NOT EXECUTED
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
30009f84: e1a0000d mov r0, sp <== NOT EXECUTED 30009f88: eb000d8d bl 3000d5c4 <_Timespec_To_ticks> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30009f8c: e59f1010 ldr r1, [pc, #16] ; 30009fa4 <ualarm+0xd8> <== NOT EXECUTED 30009f90: e581000c str r0, [r1, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30009f94: e59f0014 ldr r0, [pc, #20] ; 30009fb0 <ualarm+0xe4> <== NOT EXECUTED 30009f98: eb000e49 bl 3000d8c4 <_Watchdog_Insert> <== NOT EXECUTED
}
return remaining;
}
30009f9c: e1a00004 mov r0, r4 <== NOT EXECUTED
30009fa0: e8bd807c pop {r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
30009f44 <vfork>:
#include <unistd.h>
pid_t vfork(void)
{
return -1;
}
30009f44: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009f48: e12fff1e bx lr <== NOT EXECUTED
30009f4c <wait>:
#include <rtems/seterr.h>
int wait(
int *stat_loc
)
{
30009f4c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009f50: eb00202d bl 3001200c <__errno> <== NOT EXECUTED 30009f54: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009f58: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009f5c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009f60: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009f64 <waitpid>:
int waitpid(
pid_t pid,
int *stat_loc,
int options
)
{
30009f64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009f68: eb002027 bl 3001200c <__errno> <== NOT EXECUTED 30009f6c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009f70: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009f74: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009f78: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED