3001075c <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();
3001075c: e59f3030 ldr r3, [pc, #48] ; 30010794 <TOD_MICROSECONDS_TO_TICKS+0x38><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
30010760: 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();
30010764: e593500c ldr r5, [r3, #12] <== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
30010768: 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;
3001076c: e1a01005 mov r1, r5 <== NOT EXECUTED 30010770: eb004f65 bl 3002450c <__aeabi_uidiv> <== NOT EXECUTED
if ( (microseconds % microseconds_per_tick) != 0 )
30010774: 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;
30010778: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( (microseconds % microseconds_per_tick) != 0 )
3001077c: e1a00006 mov r0, r6 <== NOT EXECUTED 30010780: eb004fa7 bl 30024624 <__umodsi3> <== NOT EXECUTED 30010784: e3500000 cmp r0, #0 <== NOT EXECUTED
ticks += 1;
30010788: 12844001 addne r4, r4, #1 <== NOT EXECUTED
return ticks;
}
3001078c: e1a00004 mov r0, r4 <== NOT EXECUTED
30010790: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000c010 <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();
3000c010: e59f203c ldr r2, [pc, #60] ; 3000c054 <TOD_MILLISECONDS_TO_TICKS+0x44><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000c014: 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();
3000c018: e59f3038 ldr r3, [pc, #56] ; 3000c058 <TOD_MILLISECONDS_TO_TICKS+0x48><== NOT EXECUTED 3000c01c: e592500c ldr r5, [r2, #12] <== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000c020: 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();
3000c024: e0852593 umull r2, r5, r3, r5 <== NOT EXECUTED 3000c028: e1a05325 lsr r5, r5, #6 <== NOT EXECUTED
ticks = milliseconds / milliseconds_per_tick;
3000c02c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000c030: eb00425b bl 3001c9a4 <__aeabi_uidiv> <== NOT EXECUTED
if ( (milliseconds % milliseconds_per_tick) != 0 )
3000c034: 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;
3000c038: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( (milliseconds % milliseconds_per_tick) != 0 )
3000c03c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000c040: eb00429d bl 3001cabc <__umodsi3> <== NOT EXECUTED 3000c044: e3500000 cmp r0, #0 <== NOT EXECUTED
ticks += 1;
3000c048: 12844001 addne r4, r4, #1 <== NOT EXECUTED
return ticks;
}
3000c04c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c050: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000db14 <_CORE_RWLock_Obtain_for_reading>:
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000db14: e59fc0bc ldr ip, [pc, #188] ; 3000dbd8 <_CORE_RWLock_Obtain_for_reading+0xc4>
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000db18: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000db1c: e59c5008 ldr r5, [ip, #8]
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000db20: e1a04000 mov r4, r0 3000db24: e1a07001 mov r7, r1 3000db28: e1a06003 mov r6, r3 3000db2c: e202a0ff and sl, r2, #255 ; 0xff
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000db30: e10f8000 mrs r8, CPSR 3000db34: e3883080 orr r3, r8, #128 ; 0x80 3000db38: 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 ) {
3000db3c: e5903044 ldr r3, [r0, #68] ; 0x44 3000db40: e3530000 cmp r3, #0
3000db44: 1a000008 bne 3000db6c <_CORE_RWLock_Obtain_for_reading+0x58>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
the_rwlock->number_of_readers += 1;
3000db48: e5903048 ldr r3, [r0, #72] ; 0x48
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000db4c: e3a02001 mov r2, #1
the_rwlock->number_of_readers += 1;
3000db50: e2833001 add r3, r3, #1
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000db54: e5802044 str r2, [r0, #68] ; 0x44
case CORE_RWLOCK_LOCKED_FOR_READING: {
Thread_Control *waiter;
waiter = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !waiter ) {
the_rwlock->number_of_readers += 1;
3000db58: 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 (
3000db5c: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000db60: e3a03000 mov r3, #0 3000db64: e5853034 str r3, [r5, #52] ; 0x34
return;
3000db68: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* 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 ) {
3000db6c: e3530001 cmp r3, #1
3000db70: 0a000012 beq 3000dbc0 <_CORE_RWLock_Obtain_for_reading+0xac>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
3000db74: e35a0000 cmp sl, #0
3000db78: 1a000003 bne 3000db8c <_CORE_RWLock_Obtain_for_reading+0x78>
3000db7c: e129f008 msr CPSR_fc, r8
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000db80: e3a03002 mov r3, #2 3000db84: e5853034 str r3, [r5, #52] ; 0x34
return;
3000db88: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
*/
_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;
3000db8c: e3a03000 mov r3, #0 3000db90: e3a02001 mov r2, #1 3000db94: e5842030 str r2, [r4, #48] ; 0x30
/*
* 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;
3000db98: e5854044 str r4, [r5, #68] ; 0x44
executing->Wait.id = id;
3000db9c: e5857020 str r7, [r5, #32]
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
3000dba0: e5853030 str r3, [r5, #48] ; 0x30
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000dba4: e5853034 str r3, [r5, #52] ; 0x34 3000dba8: e129f008 msr CPSR_fc, r8
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
3000dbac: e59f2028 ldr r2, [pc, #40] ; 3000dbdc <_CORE_RWLock_Obtain_for_reading+0xc8> 3000dbb0: e1a00004 mov r0, r4 3000dbb4: e1a01006 mov r1, r6
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
3000dbb8: 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(
3000dbbc: ea000826 b 3000fc5c <_Thread_queue_Enqueue_with_handler>
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 );
3000dbc0: eb000905 bl 3000ffdc <_Thread_queue_First> <== NOT EXECUTED
if ( !waiter ) {
3000dbc4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000dbc8: 1affffe9 bne 3000db74 <_CORE_RWLock_Obtain_for_reading+0x60><== NOT EXECUTED
the_rwlock->number_of_readers += 1;
3000dbcc: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000dbd0: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000dbd4: eaffffdf b 3000db58 <_CORE_RWLock_Obtain_for_reading+0x44> <== NOT EXECUTED
3000dc74 <_CORE_RWLock_Release>:
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000dc74: e59f30e0 ldr r3, [pc, #224] ; 3000dd5c <_CORE_RWLock_Release+0xe8>
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
3000dc78: e92d4010 push {r4, lr}
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000dc7c: e5931008 ldr r1, [r3, #8]
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
3000dc80: e1a04000 mov r4, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000dc84: e10f2000 mrs r2, CPSR 3000dc88: e3823080 orr r3, r2, #128 ; 0x80 3000dc8c: 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 );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
3000dc90: e5903044 ldr r3, [r0, #68] ; 0x44 3000dc94: e3530000 cmp r3, #0
3000dc98: 0a00002a beq 3000dd48 <_CORE_RWLock_Release+0xd4>
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
3000dc9c: e3530001 cmp r3, #1
3000dca0: 0a000020 beq 3000dd28 <_CORE_RWLock_Release+0xb4>
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000dca4: e3a03000 mov r3, #0 3000dca8: e5813034 str r3, [r1, #52] ; 0x34
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
3000dcac: e5843044 str r3, [r4, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000dcb0: e129f002 msr CPSR_fc, r2
_ISR_Enable( level );
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
3000dcb4: e1a00004 mov r0, r4 3000dcb8: eb00078c bl 3000faf0 <_Thread_queue_Dequeue>
if ( next ) {
3000dcbc: e3500000 cmp r0, #0
3000dcc0: 0a000016 beq 3000dd20 <_CORE_RWLock_Release+0xac>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
3000dcc4: e5903030 ldr r3, [r0, #48] ; 0x30 3000dcc8: e3530001 cmp r3, #1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
3000dccc: 03a03002 moveq r3, #2 3000dcd0: 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 ) {
3000dcd4: 0a000011 beq 3000dd20 <_CORE_RWLock_Release+0xac>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
3000dcd8: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000dcdc: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000dce0: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000dce4: e3a03001 mov r3, #1 <== NOT EXECUTED 3000dce8: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED 3000dcec: ea000007 b 3000dd10 <_CORE_RWLock_Release+0x9c> <== NOT EXECUTED
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
3000dcf0: e5913030 ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
3000dcf4: e1a00004 mov r0, r4 <== NOT EXECUTED
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
3000dcf8: e3530001 cmp r3, #1 <== NOT EXECUTED 3000dcfc: 0a000007 beq 3000dd20 <_CORE_RWLock_Release+0xac> <== NOT EXECUTED
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
3000dd00: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000dd04: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000dd08: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
3000dd0c: eb000867 bl 3000feb0 <_Thread_queue_Extract> <== NOT EXECUTED
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
3000dd10: e1a00004 mov r0, r4 <== NOT EXECUTED 3000dd14: eb0008b0 bl 3000ffdc <_Thread_queue_First> <== NOT EXECUTED
if ( !next ||
3000dd18: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000dd1c: 1afffff3 bne 3000dcf0 <_CORE_RWLock_Release+0x7c> <== NOT EXECUTED
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
3000dd20: e3a00000 mov r0, #0
3000dd24: e8bd8010 pop {r4, pc}
_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;
3000dd28: e5903048 ldr r3, [r0, #72] ; 0x48 3000dd2c: e2433001 sub r3, r3, #1
if ( the_rwlock->number_of_readers != 0 ) {
3000dd30: e3530000 cmp r3, #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;
3000dd34: e5803048 str r3, [r0, #72] ; 0x48
if ( the_rwlock->number_of_readers != 0 ) {
3000dd38: 0affffd9 beq 3000dca4 <_CORE_RWLock_Release+0x30>
3000dd3c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
3000dd40: e3a00000 mov r0, #0 <== NOT EXECUTED
3000dd44: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000dd48: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000dd4c: e3a03002 mov r3, #2 <== NOT EXECUTED 3000dd50: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
3000dd54: e3a00000 mov r0, #0 <== NOT EXECUTED
3000dd58: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000dd60 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
3000dd60: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000dd64: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000dd68: e1a0100d mov r1, sp <== NOT EXECUTED 3000dd6c: eb00068c bl 3000f7a4 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000dd70: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000dd74: e3530000 cmp r3, #0 <== NOT EXECUTED 3000dd78: 1a000004 bne 3000dd90 <_CORE_RWLock_Timeout+0x30> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
3000dd7c: eb0008d0 bl 300100c4 <_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;
3000dd80: e59f3010 ldr r3, [pc, #16] ; 3000dd98 <_CORE_RWLock_Timeout+0x38><== NOT EXECUTED 3000dd84: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000dd88: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000dd8c: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000dd90: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000dd94: e8bd8000 pop {pc} <== NOT EXECUTED
3001bc9c <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
3001bc9c: 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
)
{
3001bca0: 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 ) {
3001bca4: e1530002 cmp r3, r2
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
3001bca8: e1a07000 mov r7, r0 3001bcac: e1a05002 mov r5, r2 3001bcb0: e1a08001 mov r8, r1 3001bcb4: e59da020 ldr sl, [sp, #32]
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
3001bcb8: 3a000016 bcc 3001bd18 <_CORE_message_queue_Broadcast+0x7c>
* 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 ) {
3001bcbc: e5906048 ldr r6, [r0, #72] ; 0x48 3001bcc0: e3560000 cmp r6, #0
*count = 0;
3001bcc4: 13a00000 movne r0, #0 3001bcc8: 158a0000 strne r0, [sl]
* 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 ) {
3001bccc: 18bd85f0 popne {r4, r5, r6, r7, r8, sl, pc}
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
3001bcd0: e1a00007 mov r0, r7 3001bcd4: eb000bf6 bl 3001ecb4 <_Thread_queue_Dequeue> 3001bcd8: e2504000 subs r4, r0, #0
3001bcdc: 0a00000a beq 3001bd0c <_CORE_message_queue_Broadcast+0x70>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
3001bce0: e594002c ldr r0, [r4, #44] ; 0x2c 3001bce4: e1a01008 mov r1, r8 3001bce8: e1a02005 mov r2, r5 3001bcec: eb002244 bl 30024604 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
3001bcf0: e5943028 ldr r3, [r4, #40] ; 0x28
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
3001bcf4: e1a00007 mov r0, r7
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
3001bcf8: e5835000 str r5, [r3]
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
3001bcfc: eb000bec bl 3001ecb4 <_Thread_queue_Dequeue> 3001bd00: e2504000 subs r4, r0, #0
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
3001bd04: e2866001 add r6, r6, #1
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
3001bd08: 1afffff4 bne 3001bce0 <_CORE_message_queue_Broadcast+0x44>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
3001bd0c: e58a6000 str r6, [sl]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
3001bd10: e1a00004 mov r0, r4
3001bd14: 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;
3001bd18: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
3001bd1c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30013b6c <_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
)
{
30013b6c: 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)) {
30013b70: 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
)
{
30013b74: 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;
30013b78: 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
)
{
30013b7c: e1a05002 mov r5, r2 30013b80: e1a07001 mov r7, r1
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
30013b84: e5842044 str r2, [r4, #68] ; 0x44
the_message_queue->number_of_pending_messages = 0;
30013b88: e5840048 str r0, [r4, #72] ; 0x48
the_message_queue->maximum_message_size = maximum_message_size;
30013b8c: 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;
30013b90: e5840060 str r0, [r4, #96] ; 0x60
the_message_queue->notify_argument = the_argument;
30013b94: 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)) {
30013b98: 01a06003 moveq r6, r3
30013b9c: 0a000003 beq 30013bb0 <_CORE_message_queue_Initialize+0x44>
allocated_message_size += sizeof(uintptr_t);
30013ba0: e2836004 add r6, r3, #4 <== NOT EXECUTED
allocated_message_size &= ~(sizeof(uintptr_t) - 1);
30013ba4: 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)
30013ba8: e1530006 cmp r3, r6 <== NOT EXECUTED
30013bac: 88bd80f0 pophi {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(
30013bb0: e2866014 add r6, r6, #20
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
30013bb4: e0810695 umull r0, r1, r5, r6
if ( x > SIZE_MAX )
30013bb8: e3e02000 mvn r2, #0 30013bbc: e3a03000 mov r3, #0 30013bc0: e1520000 cmp r2, r0 30013bc4: 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;
30013bc8: b3a00000 movlt r0, #0
size_t *c
)
{
long long x = (long long)a*b;
if ( x > SIZE_MAX )
30013bcc: 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 );
30013bd0: eb000c19 bl 30016c3c <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
30013bd4: e3500000 cmp r0, #0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
30013bd8: e1a01000 mov r1, r0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
30013bdc: e584005c str r0, [r4, #92] ; 0x5c
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
30013be0: 0a000013 beq 30013c34 <_CORE_message_queue_Initialize+0xc8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
30013be4: e2840068 add r0, r4, #104 ; 0x68 30013be8: e1a02005 mov r2, r5 30013bec: e1a03006 mov r3, r6 30013bf0: ebffffc4 bl 30013b08 <_Chain_Initialize>
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
30013bf4: 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 );
30013bf8: e2843050 add r3, r4, #80 ; 0x50 30013bfc: e2842054 add r2, r4, #84 ; 0x54
head->next = tail;
head->previous = NULL;
tail->previous = head;
30013c00: e5843058 str r3, [r4, #88] ; 0x58 30013c04: e2413001 sub r3, r1, #1 30013c08: e2731000 rsbs r1, r3, #0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30013c0c: e5842050 str r2, [r4, #80] ; 0x50
head->previous = NULL;
30013c10: e3a02000 mov r2, #0 30013c14: e5842054 str r2, [r4, #84] ; 0x54 30013c18: e1a00004 mov r0, r4 30013c1c: e0a11003 adc r1, r1, r3 30013c20: e3a02080 mov r2, #128 ; 0x80 30013c24: e3a03006 mov r3, #6 30013c28: eb0009c8 bl 30016350 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
30013c2c: e3a00001 mov r0, #1
30013c30: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
30013c34: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
300190ac <_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 ) {
300190ac: 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
)
{
300190b0: e92d4030 push {r4, r5, lr}
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
300190b4: 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 ) {
300190b8: 0a000026 beq 30019158 <_CORE_message_queue_Insert_message+0xac>
_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 ) {
300190bc: e3520102 cmp r2, #-2147483648 ; 0x80000000
300190c0: 0a000036 beq 300191a0 <_CORE_message_queue_Insert_message+0xf4>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
300190c4: e5903050 ldr 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 ));
300190c8: e280c054 add ip, r0, #84 ; 0x54
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 ) ) {
300190cc: e15c0003 cmp ip, r3
300190d0: 0a000008 beq 300190f8 <_CORE_message_queue_Insert_message+0x4c>
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
300190d4: e5934008 ldr r4, [r3, #8] <== NOT EXECUTED 300190d8: e1540002 cmp r4, r2 <== NOT EXECUTED 300190dc: ca000005 bgt 300190f8 <_CORE_message_queue_Insert_message+0x4c><== NOT EXECUTED
the_node = the_node->next;
300190e0: 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 ) ) {
300190e4: e15c0003 cmp ip, r3 <== NOT EXECUTED 300190e8: 0a000002 beq 300190f8 <_CORE_message_queue_Insert_message+0x4c><== NOT EXECUTED
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
300190ec: e5934008 ldr r4, [r3, #8] <== NOT EXECUTED 300190f0: e1520004 cmp r2, r4 <== NOT EXECUTED 300190f4: aafffff9 bge 300190e0 <_CORE_message_queue_Insert_message+0x34><== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
300190f8: e10f4000 mrs r4, CPSR 300190fc: e3842080 orr r2, r4, #128 ; 0x80 30019100: e129f002 msr CPSR_fc, r2
break;
}
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
30019104: e5933004 ldr r3, [r3, #4]
continue;
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
30019108: e5902048 ldr r2, [r0, #72] ; 0x48
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3001910c: e593c000 ldr ip, [r3]
the_message_queue->number_of_pending_messages++;
30019110: e2825001 add r5, r2, #1
#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(
30019114: e2722001 rsbs r2, r2, #1
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
30019118: e5805048 str r5, [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(
3001911c: 33a02000 movcc r2, #0
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
30019120: e5813004 str r3, [r1, #4]
before_node = after_node->next; after_node->next = the_node;
30019124: e5831000 str r1, [r3]
the_node->next = before_node; before_node->previous = the_node;
30019128: e58c1004 str r1, [ip, #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;
3001912c: e581c000 str ip, [r1]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30019130: 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 )
30019134: e3520000 cmp r2, #0
30019138: 08bd8030 popeq {r4, r5, pc}
3001913c: e5903060 ldr r3, [r0, #96] ; 0x60
30019140: e3530000 cmp r3, #0
30019144: 08bd8030 popeq {r4, r5, pc}
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
30019148: e5900064 ldr r0, [r0, #100] ; 0x64 <== NOT EXECUTED
3001914c: e1a0e00f mov lr, pc <== NOT EXECUTED
30019150: e12fff13 bx r3 <== NOT EXECUTED
30019154: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30019158: e10fc000 mrs ip, CPSR 3001915c: e38c3080 orr r3, ip, #128 ; 0x80 30019160: e129f003 msr CPSR_fc, r3
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
_ISR_Disable( level );
SET_NOTIFY();
30019164: e5902048 ldr r2, [r0, #72] ; 0x48
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
30019168: e5903058 ldr r3, [r0, #88] ; 0x58
the_message_queue->number_of_pending_messages++;
3001916c: e2825001 add r5, r2, #1
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
30019170: 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(
30019174: e2722001 rsbs r2, r2, #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++;
30019178: e5805048 str r5, [r0, #72] ; 0x48
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3001917c: e5801058 str r1, [r0, #88] ; 0x58
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
30019180: e5814000 str r4, [r1]
#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(
30019184: 33a02000 movcc r2, #0
tail->previous = the_node; old_last->next = the_node;
30019188: e5831000 str r1, [r3]
the_node->previous = old_last;
3001918c: e5813004 str r3, [r1, #4]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30019190: e129f00c msr CPSR_fc, ip
/*
* 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 )
30019194: e3520000 cmp r2, #0
30019198: 1affffe7 bne 3001913c <_CORE_message_queue_Insert_message+0x90>
3001919c: e8bd8030 pop {r4, r5, pc}
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
300191a0: e10fc000 mrs ip, CPSR 300191a4: e38c3080 orr r3, ip, #128 ; 0x80 300191a8: e129f003 msr CPSR_fc, r3
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 ) {
_ISR_Disable( level );
SET_NOTIFY();
300191ac: e5902048 ldr r2, [r0, #72] ; 0x48
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
300191b0: e5903050 ldr r3, [r0, #80] ; 0x50
the_message_queue->number_of_pending_messages++;
300191b4: e2825001 add r5, r2, #1
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
300191b8: e2804050 add r4, 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(
300191bc: e2722001 rsbs r2, r2, #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++;
300191c0: e5805048 str r5, [r0, #72] ; 0x48
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
300191c4: e5801050 str r1, [r0, #80] ; 0x50
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
300191c8: e5814004 str r4, [r1, #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(
300191cc: 33a02000 movcc r2, #0
before_node = after_node->next; after_node->next = the_node; the_node->next = before_node;
300191d0: e5813000 str r3, [r1]
before_node->previous = the_node;
300191d4: e5831004 str r1, [r3, #4]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300191d8: e129f00c msr CPSR_fc, ip
/*
* 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 )
300191dc: e3520000 cmp r2, #0
300191e0: 1affffd5 bne 3001913c <_CORE_message_queue_Insert_message+0x90>
300191e4: e8bd8030 pop {r4, r5, pc}
30013c38 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
30013c38: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
30013c3c: e59fc110 ldr ip, [pc, #272] ; 30013d54 <_CORE_message_queue_Seize+0x11c>
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30013c40: e3a04000 mov r4, #0
{
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
30013c44: e59c5008 ldr r5, [ip, #8]
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
30013c48: e59d8024 ldr r8, [sp, #36] ; 0x24
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;
30013c4c: e5854034 str r4, [r5, #52] ; 0x34
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
30013c50: e5dd6020 ldrb r6, [sp, #32] 30013c54: e1a04000 mov r4, r0 30013c58: e1a00002 mov r0, r2
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30013c5c: e10fa000 mrs sl, CPSR 30013c60: e38a2080 orr r2, sl, #128 ; 0x80 30013c64: 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;
30013c68: e1a02004 mov r2, r4 30013c6c: e5b27050 ldr r7, [r2, #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 );
30013c70: e2849054 add r9, r4, #84 ; 0x54
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
30013c74: e1570009 cmp r7, r9
30013c78: 0a00001f beq 30013cfc <_CORE_message_queue_Seize+0xc4>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
30013c7c: e5971000 ldr r1, [r7]
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_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;
30013c80: e594e048 ldr lr, [r4, #72] ; 0x48
head->next = new_first;
30013c84: e5841050 str r1, [r4, #80] ; 0x50
new_first->previous = head;
30013c88: e5812004 str r2, [r1, #4] 30013c8c: e24e2001 sub r2, lr, #1 30013c90: e5842048 str r2, [r4, #72] ; 0x48
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30013c94: e129f00a msr CPSR_fc, sl
_ISR_Enable( level );
*size_p = the_message->Contents.size;
_Thread_Executing->Wait.count =
30013c98: e59c2008 ldr r2, [ip, #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;
30013c9c: e597e00c ldr lr, [r7, #12]
_Thread_Executing->Wait.count =
30013ca0: e5971008 ldr r1, [r7, #8]
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
30013ca4: e2875010 add r5, r7, #16
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;
30013ca8: e583e000 str lr, [r3]
_Thread_Executing->Wait.count =
30013cac: e5821024 str r1, [r2, #36] ; 0x24
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30013cb0: e5932000 ldr r2, [r3] 30013cb4: e1a01005 mov r1, r5 30013cb8: eb002044 bl 3001bdd0 <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 );
30013cbc: e1a00004 mov r0, r4 30013cc0: eb00089c bl 30015f38 <_Thread_queue_Dequeue>
if ( !the_thread ) {
30013cc4: e2503000 subs r3, r0, #0
30013cc8: 0a00001d beq 30013d44 <_CORE_message_queue_Seize+0x10c>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
30013ccc: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
*/
_CORE_message_queue_Set_message_priority(
the_message,
the_thread->Wait.count
);
the_message->Contents.size = (size_t) the_thread->Wait.option;
30013cd0: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED 30013cd4: e5871008 str r1, [r7, #8] <== NOT EXECUTED 30013cd8: e587200c str r2, [r7, #12] <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30013cdc: e593102c ldr r1, [r3, #44] ; 0x2c <== NOT EXECUTED 30013ce0: e1a00005 mov r0, r5 <== NOT EXECUTED 30013ce4: eb002039 bl 3001bdd0 <memcpy> <== NOT EXECUTED
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
30013ce8: e5972008 ldr r2, [r7, #8] <== NOT EXECUTED 30013cec: e1a00004 mov r0, r4 <== NOT EXECUTED 30013cf0: e1a01007 mov r1, r7 <== 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 );
}
30013cf4: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, 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(
30013cf8: ea0014eb b 300190ac <_CORE_message_queue_Insert_message> <== NOT EXECUTED
return;
}
#endif
}
if ( !wait ) {
30013cfc: e3560000 cmp r6, #0
30013d00: 1a000003 bne 30013d14 <_CORE_message_queue_Seize+0xdc>
30013d04: e129f00a msr CPSR_fc, sl
_ISR_Enable( level );
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
30013d08: e3a03004 mov r3, #4 30013d0c: e5853034 str r3, [r5, #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 );
}
30013d10: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, 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;
30013d14: e3a02001 mov r2, #1 30013d18: e5842030 str r2, [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;
30013d1c: e5854044 str r4, [r5, #68] ; 0x44
executing->Wait.id = id;
30013d20: e5851020 str r1, [r5, #32]
executing->Wait.return_argument_second.mutable_object = buffer;
30013d24: e585002c str r0, [r5, #44] ; 0x2c
executing->Wait.return_argument = size_p;
30013d28: e5853028 str r3, [r5, #40] ; 0x28 30013d2c: e129f00a msr CPSR_fc, sl
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
30013d30: e59f2020 ldr r2, [pc, #32] ; 30013d58 <_CORE_message_queue_Seize+0x120> 30013d34: e1a00004 mov r0, r4 30013d38: e1a01008 mov r1, r8
}
30013d3c: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, 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 );
30013d40: ea0008d7 b 300160a4 <_Thread_queue_Enqueue_with_handler>
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 );
30013d44: e2840068 add r0, r4, #104 ; 0x68 30013d48: e1a01007 mov r1, r7
}
30013d4c: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
30013d50: eaffff54 b 30013aa8 <_Chain_Append>
30013d5c <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30013d5c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30013d60: e590c04c ldr ip, [r0, #76] ; 0x4c
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30013d64: e1a04000 mov r4, r0
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30013d68: e15c0002 cmp ip, r2
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30013d6c: e1a05002 mov r5, r2 30013d70: e1a0a001 mov sl, r1 30013d74: e1a0b003 mov fp, r3 30013d78: e59d6028 ldr r6, [sp, #40] ; 0x28 30013d7c: e5dd902c ldrb r9, [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;
30013d80: 33a00001 movcc r0, #1
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30013d84: 38bd8ff0 popcc {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 ) {
30013d88: e5947048 ldr r7, [r4, #72] ; 0x48 30013d8c: e3570000 cmp r7, #0
30013d90: 0a00000f beq 30013dd4 <_CORE_message_queue_Submit+0x78>
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 *)
30013d94: e2840068 add r0, r4, #104 ; 0x68 30013d98: ebffff4d bl 30013ad4 <_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 ) {
30013d9c: e2507000 subs r7, r0, #0
30013da0: 0a000017 beq 30013e04 <_CORE_message_queue_Submit+0xa8>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30013da4: e1a0100a mov r1, sl 30013da8: e1a02005 mov r2, r5 30013dac: e2870010 add r0, r7, #16 30013db0: eb002006 bl 3001bdd0 <memcpy>
size
);
the_message->Contents.size = size;
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30013db4: e1a00004 mov r0, r4
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
30013db8: 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;
30013dbc: e5876008 str r6, [r7, #8]
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30013dc0: e1a01007 mov r1, r7 30013dc4: e1a02006 mov r2, r6 30013dc8: eb0014b7 bl 300190ac <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30013dcc: e3a00000 mov r0, #0
30013dd0: e8bd8ff0 pop {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 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
30013dd4: eb000857 bl 30015f38 <_Thread_queue_Dequeue>
if ( the_thread ) {
30013dd8: e2508000 subs r8, r0, #0
30013ddc: 0affffec beq 30013d94 <_CORE_message_queue_Submit+0x38>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30013de0: e598002c ldr r0, [r8, #44] ; 0x2c 30013de4: e1a0100a mov r1, sl 30013de8: e1a02005 mov r2, r5 30013dec: eb001ff7 bl 3001bdd0 <memcpy>
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30013df0: e5983028 ldr r3, [r8, #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;
30013df4: e1a00007 mov r0, r7
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30013df8: e5835000 str r5, [r3]
the_thread->Wait.count = (uint32_t) submit_type;
30013dfc: e5886024 str r6, [r8, #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;
30013e00: 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 ) {
30013e04: e3590000 cmp r9, #0 <== NOT EXECUTED
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
30013e08: 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 ) {
30013e0c: 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() ) {
30013e10: e59f3058 ldr r3, [pc, #88] ; 30013e70 <_CORE_message_queue_Submit+0x114><== NOT EXECUTED 30013e14: e5932000 ldr r2, [r3] <== NOT EXECUTED 30013e18: e3520000 cmp r2, #0 <== NOT EXECUTED 30013e1c: 0a000001 beq 30013e28 <_CORE_message_queue_Submit+0xcc> <== NOT EXECUTED
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
30013e20: e3a00003 mov r0, #3 <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
30013e24: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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;
30013e28: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30013e2c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 30013e30: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30013e34: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 30013e38: e3a01001 mov r1, #1 <== NOT EXECUTED 30013e3c: 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;
30013e40: e5834044 str r4, [r3, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
30013e44: e583b020 str fp, [r3, #32] <== NOT EXECUTED
executing->Wait.return_argument_second.immutable_object = buffer;
30013e48: e583a02c str sl, [r3, #44] ; 0x2c <== NOT EXECUTED
executing->Wait.option = (uint32_t) size;
30013e4c: e5835030 str r5, [r3, #48] ; 0x30 <== NOT EXECUTED
executing->Wait.count = submit_type;
30013e50: 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 (
30013e54: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
30013e58: e59f2014 ldr r2, [pc, #20] ; 30013e74 <_CORE_message_queue_Submit+0x118><== NOT EXECUTED 30013e5c: e1a00004 mov r0, r4 <== NOT EXECUTED 30013e60: e59d1030 ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED 30013e64: eb00088e bl 300160a4 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
30013e68: e3a00007 mov r0, #7 <== NOT EXECUTED
30013e6c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000b3e8 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
3000b3e8: e92d40f0 push {r4, r5, r6, r7, lr}
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
3000b3ec: e3a05000 mov r5, #0
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
3000b3f0: e1a0c000 mov ip, r0
the_mutex->Attributes = *the_mutex_attributes;
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
3000b3f4: e1520005 cmp r2, r5
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
3000b3f8: e1a06002 mov r6, r2
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
3000b3fc: e2804040 add r4, r0, #64 ; 0x40
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
3000b400: e1a07001 mov r7, r1
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
3000b404: e891000f ldm r1, {r0, r1, r2, r3}
the_mutex->lock = initial_lock;
3000b408: e58c6050 str r6, [ip, #80] ; 0x50
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
3000b40c: e884000f stm r4, {r0, r1, r2, r3}
the_mutex->lock = initial_lock; the_mutex->blocked_count = 0;
3000b410: e58c5058 str r5, [ip, #88] ; 0x58
#endif
_Thread_Executing->resource_count++;
}
} else {
the_mutex->nest_count = 0;
3000b414: 158c5054 strne r5, [ip, #84] ; 0x54
the_mutex->holder = NULL;
3000b418: 158c505c strne r5, [ip, #92] ; 0x5c
the_mutex->holder_id = 0;
3000b41c: 158c5060 strne r5, [ip, #96] ; 0x60
the_mutex->Attributes = *the_mutex_attributes;
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
3000b420: 1a00000b bne 3000b454 <_CORE_mutex_Initialize+0x6c>
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
3000b424: e59f3074 ldr r3, [pc, #116] ; 3000b4a0 <_CORE_mutex_Initialize+0xb8>
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
3000b428: e59c2048 ldr r2, [ip, #72] ; 0x48 3000b42c: e5933008 ldr r3, [r3, #8]
the_mutex->Attributes = *the_mutex_attributes;
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
3000b430: e3a00001 mov r0, #1
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
3000b434: e5931008 ldr r1, [r3, #8]
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000b438: e3520002 cmp r2, #2
the_mutex->Attributes = *the_mutex_attributes;
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
3000b43c: e58c0054 str r0, [ip, #84] ; 0x54
the_mutex->holder = _Thread_Executing;
3000b440: e58c305c str r3, [ip, #92] ; 0x5c
the_mutex->holder_id = _Thread_Executing->Object.id;
3000b444: e58c1060 str r1, [ip, #96] ; 0x60
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000b448: 0a00000a beq 3000b478 <_CORE_mutex_Initialize+0x90>
3000b44c: e3520003 cmp r2, #3
3000b450: 0a000008 beq 3000b478 <_CORE_mutex_Initialize+0x90>
the_mutex->nest_count = 0;
the_mutex->holder = NULL;
the_mutex->holder_id = 0;
}
_Thread_queue_Initialize(
3000b454: e5971008 ldr r1, [r7, #8] 3000b458: e1a0000c mov r0, ip 3000b45c: e2911000 adds r1, r1, #0 3000b460: 13a01001 movne r1, #1 3000b464: e3a02b01 mov r2, #1024 ; 0x400 3000b468: e3a03005 mov r3, #5 3000b46c: eb000912 bl 3000d8bc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000b470: e3a00000 mov r0, #0
3000b474: e8bd80f0 pop {r4, r5, r6, r7, pc}
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
3000b478: e5931014 ldr r1, [r3, #20] 3000b47c: e59c204c ldr r2, [ip, #76] ; 0x4c 3000b480: e1510002 cmp r1, r2
3000b484: 2a000001 bcs 3000b490 <_CORE_mutex_Initialize+0xa8>
the_mutex->Attributes.priority_ceiling )
return CORE_MUTEX_STATUS_CEILING_VIOLATED;
3000b488: e3a00006 mov r0, #6
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
3000b48c: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif
_Thread_Executing->resource_count++;
3000b490: e593201c ldr r2, [r3, #28] <== NOT EXECUTED 3000b494: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000b498: e583201c str r2, [r3, #28] <== NOT EXECUTED 3000b49c: eaffffec b 3000b454 <_CORE_mutex_Initialize+0x6c> <== NOT EXECUTED
3000b528 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000b528: e92d41f0 push {r4, r5, r6, r7, r8, lr}
* 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 )
3000b52c: e59f40b4 ldr r4, [pc, #180] ; 3000b5e8 <_CORE_mutex_Seize+0xc0> 3000b530: e1a05000 mov r5, r0 3000b534: e594c000 ldr ip, [r4] 3000b538: e1a06001 mov r6, r1 3000b53c: e35c0000 cmp ip, #0 3000b540: e1a08003 mov r8, r3 3000b544: e20270ff and r7, r2, #255 ; 0xff
3000b548: 0a000001 beq 3000b554 <_CORE_mutex_Seize+0x2c> _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
3000b54c: e3570000 cmp r7, #0
3000b550: 1a00000d bne 3000b58c <_CORE_mutex_Seize+0x64>
3000b554: e1a00005 mov r0, r5
3000b558: e28d1018 add r1, sp, #24
3000b55c: eb0013e5 bl 300104f8 <_CORE_mutex_Seize_interrupt_trylock>
3000b560: e3500000 cmp r0, #0
3000b564: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
3000b568: e3570000 cmp r7, #0
3000b56c: 1a00000e bne 3000b5ac <_CORE_mutex_Seize+0x84>
3000b570: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
3000b574: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3000b578: e59f306c ldr r3, [pc, #108] ; 3000b5ec <_CORE_mutex_Seize+0xc4><== NOT EXECUTED
3000b57c: e3a02001 mov r2, #1 <== NOT EXECUTED
3000b580: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
3000b584: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
3000b588: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000b58c: e59f305c ldr r3, [pc, #92] ; 3000b5f0 <_CORE_mutex_Seize+0xc8> 3000b590: e5933000 ldr r3, [r3] 3000b594: e3530001 cmp r3, #1
3000b598: 9affffed bls 3000b554 <_CORE_mutex_Seize+0x2c>
3000b59c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b5a0: e1a01000 mov r1, r0 <== NOT EXECUTED 3000b5a4: e3a02012 mov r2, #18 <== NOT EXECUTED 3000b5a8: eb0001c5 bl 3000bcc4 <_Internal_error_Occurred> <== NOT EXECUTED
3000b5ac: e59f3038 ldr r3, [pc, #56] ; 3000b5ec <_CORE_mutex_Seize+0xc4>
*
* 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;
3000b5b0: e5942000 ldr r2, [r4] 3000b5b4: e5933008 ldr r3, [r3, #8]
++level;
3000b5b8: e2822001 add r2, r2, #1
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;
3000b5bc: e3a01001 mov r1, #1 3000b5c0: e5851030 str r1, [r5, #48] ; 0x30
_Thread_Dispatch_disable_level = level;
3000b5c4: e5842000 str r2, [r4]
3000b5c8: e5835044 str r5, [r3, #68] ; 0x44
3000b5cc: e5836020 str r6, [r3, #32]
3000b5d0: e59d3018 ldr r3, [sp, #24]
3000b5d4: e129f003 msr CPSR_fc, r3
3000b5d8: e1a00005 mov r0, r5
3000b5dc: e1a01008 mov r1, r8
3000b5e0: ebffffaf bl 3000b4a4 <_CORE_mutex_Seize_interrupt_blocking>
3000b5e4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
300104f8 <_CORE_mutex_Seize_interrupt_trylock>:
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
300104f8: e59f2140 ldr r2, [pc, #320] ; 30010640 <_CORE_mutex_Seize_interrupt_trylock+0x148>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
300104fc: e590c050 ldr ip, [r0, #80] ; 0x50
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
30010500: e1a03000 mov r3, r0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
30010504: e5922008 ldr r2, [r2, #8]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
30010508: e3a00000 mov r0, #0
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3001050c: e15c0000 cmp ip, r0
30010510: e92d40f0 push {r4, r5, r6, r7, lr}
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
30010514: e5820034 str r0, [r2, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
30010518: 0a00000e beq 30010558 <_CORE_mutex_Seize_interrupt_trylock+0x60>
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
3001051c: e593c048 ldr ip, [r3, #72] ; 0x48
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;
the_mutex->holder_id = executing->Object.id;
30010520: e5925008 ldr r5, [r2, #8]
the_mutex->nest_count = 1;
30010524: e3a04001 mov r4, #1
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
30010528: e35c0002 cmp ip, #2
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
3001052c: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->holder = executing;
30010530: e583205c str r2, [r3, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
30010534: e5835060 str r5, [r3, #96] ; 0x60
the_mutex->nest_count = 1;
30010538: e5834054 str r4, [r3, #84] ; 0x54
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3001053c: 0a000013 beq 30010590 <_CORE_mutex_Seize_interrupt_trylock+0x98>
30010540: e35c0003 cmp ip, #3
30010544: 0a000018 beq 300105ac <_CORE_mutex_Seize_interrupt_trylock+0xb4>
30010548: e5913000 ldr r3, [r1] 3001054c: e129f003 msr CPSR_fc, r3
return 0;
#if defined(RTEMS_POSIX_API)
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
_ISR_Enable( *level_p );
return 0;
30010550: e3a00000 mov r0, #0
30010554: e8bd80f0 pop {r4, r5, r6, r7, 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 ) ) {
30010558: e593005c ldr r0, [r3, #92] ; 0x5c 3001055c: e1520000 cmp r2, r0
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
30010560: 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 ) ) {
30010564: 18bd80f0 popne {r4, r5, r6, r7, pc}
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
30010568: e5930040 ldr r0, [r3, #64] ; 0x40 3001056c: e3500000 cmp r0, #0
30010570: 1a00001e bne 300105f0 <_CORE_mutex_Seize_interrupt_trylock+0xf8>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
30010574: e5932054 ldr r2, [r3, #84] ; 0x54 30010578: e2822001 add r2, r2, #1 3001057c: e5832054 str r2, [r3, #84] ; 0x54 30010580: e5913000 ldr r3, [r1] 30010584: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
30010588: e3a00000 mov r0, #0
3001058c: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
30010590: e592301c ldr r3, [r2, #28] 30010594: e2833001 add r3, r3, #1 30010598: e582301c str r3, [r2, #28] 3001059c: e5913000 ldr r3, [r1] 300105a0: e129f003 msr CPSR_fc, r3
return 0;
#if defined(RTEMS_POSIX_API)
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
_ISR_Enable( *level_p );
return 0;
300105a4: e3a00000 mov r0, #0
300105a8: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
300105ac: e592c01c ldr ip, [r2, #28]
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
300105b0: e593704c ldr r7, [r3, #76] ; 0x4c
current = executing->current_priority;
300105b4: e5926014 ldr r6, [r2, #20]
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
300105b8: e08c5004 add r5, ip, r4
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
300105bc: e1570006 cmp r7, r6
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
300105c0: e582501c str r5, [r2, #28]
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
300105c4: 0affffdf beq 30010548 <_CORE_mutex_Seize_interrupt_trylock+0x50>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
300105c8: 3a00000f bcc 3001060c <_CORE_mutex_Seize_interrupt_trylock+0x114>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
300105cc: e3a05006 mov r5, #6 300105d0: e5825034 str r5, [r2, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
300105d4: e5834050 str r4, [r3, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
300105d8: e5830054 str r0, [r3, #84] ; 0x54
executing->resource_count--; /* undo locking above */
300105dc: e582c01c str ip, [r2, #28] 300105e0: e5913000 ldr r3, [r1] 300105e4: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
300105e8: e3a00000 mov r0, #0
300105ec: e8bd80f0 pop {r4, r5, r6, r7, 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 ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
300105f0: e3500001 cmp r0, #1
300105f4: 0a000001 beq 30010600 <_CORE_mutex_Seize_interrupt_trylock+0x108>
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
300105f8: e3a00001 mov r0, #1
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
300105fc: e8bd80f0 pop {r4, r5, r6, r7, pc}
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;
30010600: e3a03002 mov r3, #2 30010604: e5823034 str r3, [r2, #52] ; 0x34 30010608: eaffffce b 30010548 <_CORE_mutex_Seize_interrupt_trylock+0x50>
*
* 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;
3001060c: e59f2030 ldr r2, [pc, #48] ; 30010644 <_CORE_mutex_Seize_interrupt_trylock+0x14c><== NOT EXECUTED 30010610: e5920000 ldr r0, [r2] <== NOT EXECUTED
++level;
30010614: e2800001 add r0, r0, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30010618: e5820000 str r0, [r2] <== NOT EXECUTED 3001061c: e5912000 ldr r2, [r1] <== NOT EXECUTED 30010620: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
30010624: e3a02000 mov r2, #0 <== NOT EXECUTED 30010628: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED 3001062c: e593104c ldr r1, [r3, #76] ; 0x4c <== NOT EXECUTED 30010630: ebfff18d bl 3000cc6c <_Thread_Change_priority> <== NOT EXECUTED
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
30010634: ebfff2bf bl 3000d138 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30010638: e3a00000 mov r0, #0 <== NOT EXECUTED
3001063c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000b5f4 <_CORE_mutex_Surrender>:
* 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 ) {
3000b5f4: e5d03044 ldrb r3, [r0, #68] ; 0x44
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000b5f8: e92d4030 push {r4, r5, lr}
* 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 ) {
3000b5fc: e3530000 cmp r3, #0
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000b600: e1a04000 mov r4, r0
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
3000b604: e590205c ldr r2, [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 ) {
3000b608: 0a000004 beq 3000b620 <_CORE_mutex_Surrender+0x2c>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000b60c: e59f3110 ldr r3, [pc, #272] ; 3000b724 <_CORE_mutex_Surrender+0x130>
if ( !_Thread_Is_executing( holder ) )
3000b610: e5933008 ldr r3, [r3, #8] 3000b614: e1520003 cmp r2, r3
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
3000b618: 13a00003 movne r0, #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 ) )
3000b61c: 18bd8030 popne {r4, r5, pc}
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
3000b620: e5940054 ldr r0, [r4, #84] ; 0x54
3000b624: e3500000 cmp r0, #0
3000b628: 08bd8030 popeq {r4, r5, pc}
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000b62c: e2400001 sub r0, r0, #1
if ( the_mutex->nest_count != 0 ) {
3000b630: e3500000 cmp r0, #0
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000b634: e5840054 str r0, [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;
3000b638: 13a00000 movne r0, #0
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
3000b63c: 18bd8030 popne {r4, r5, pc}
3000b640: 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 ) ||
3000b644: e3530002 cmp r3, #2
3000b648: 0a00001f beq 3000b6cc <_CORE_mutex_Surrender+0xd8>
3000b64c: e3530003 cmp r3, #3
3000b650: 0a00001d beq 3000b6cc <_CORE_mutex_Surrender+0xd8>
if ( holder->resource_count == 0 &&
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
}
}
the_mutex->holder = NULL;
3000b654: e3a05000 mov r5, #0 3000b658: e584505c str r5, [r4, #92] ; 0x5c
the_mutex->holder_id = 0;
3000b65c: 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 ) ) ) {
3000b660: e1a00004 mov r0, r4 3000b664: eb00078e bl 3000d4a4 <_Thread_queue_Dequeue> 3000b668: e2503000 subs r3, r0, #0
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000b66c: 03a02001 moveq r2, #1 3000b670: 05842050 streq r2, [r4, #80] ; 0x50
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000b674: 01a00003 moveq r0, 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 ) ) ) {
3000b678: 08bd8030 popeq {r4, r5, pc}
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000b67c: e5931008 ldr r1, [r3, #8]
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000b680: e5942048 ldr r2, [r4, #72] ; 0x48
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000b684: e5841060 str r1, [r4, #96] ; 0x60
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000b688: e3520002 cmp r2, #2
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
3000b68c: e3a01001 mov r1, #1
} else
#endif
{
the_mutex->holder = the_thread;
3000b690: e584305c str r3, [r4, #92] ; 0x5c
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
3000b694: e5841054 str r1, [r4, #84] ; 0x54
switch ( the_mutex->Attributes.discipline ) {
3000b698: 0a000018 beq 3000b700 <_CORE_mutex_Surrender+0x10c>
3000b69c: e3520003 cmp r2, #3
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000b6a0: 11a00005 movne r0, r5
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000b6a4: 18bd8030 popne {r4, r5, pc}
_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++;
3000b6a8: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000b6ac: e594104c ldr r1, [r4, #76] ; 0x4c <== NOT EXECUTED 3000b6b0: e593c014 ldr ip, [r3, #20] <== 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++;
3000b6b4: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000b6b8: e151000c cmp r1, ip <== 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++;
3000b6bc: e583201c str r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000b6c0: 3a000013 bcc 3000b714 <_CORE_mutex_Surrender+0x120> <== NOT EXECUTED
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000b6c4: e1a00005 mov r0, r5 <== NOT EXECUTED
}
3000b6c8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000b6cc: e592301c ldr r3, [r2, #28] 3000b6d0: 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 &&
3000b6d4: e3530000 cmp r3, #0
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000b6d8: e582301c str r3, [r2, #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 &&
3000b6dc: 1affffdc bne 3000b654 <_CORE_mutex_Surrender+0x60>
holder->real_priority != holder->current_priority ) {
3000b6e0: e5921018 ldr r1, [r2, #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 &&
3000b6e4: e5923014 ldr r3, [r2, #20] 3000b6e8: e1510003 cmp r1, r3
3000b6ec: 0affffd8 beq 3000b654 <_CORE_mutex_Surrender+0x60>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
3000b6f0: e1a00002 mov r0, r2 3000b6f4: e3a02001 mov r2, #1 3000b6f8: eb00055b bl 3000cc6c <_Thread_Change_priority> 3000b6fc: eaffffd4 b 3000b654 <_CORE_mutex_Surrender+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++;
3000b700: e593201c ldr r2, [r3, #28]
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000b704: e1a00005 mov r0, r5
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++;
3000b708: e2822001 add r2, r2, #1 3000b70c: e583201c str r2, [r3, #28]
break;
3000b710: e8bd8030 pop {r4, r5, pc}
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
if (the_mutex->Attributes.priority_ceiling <
the_thread->current_priority){
_Thread_Change_priority(
3000b714: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b718: eb000553 bl 3000cc6c <_Thread_Change_priority> <== NOT EXECUTED
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000b71c: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b720: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000d408 <_CORE_spinlock_Initialize>:
CORE_spinlock_Control *the_spinlock,
CORE_spinlock_Attributes *the_spinlock_attributes
)
{
the_spinlock->Attributes = *the_spinlock_attributes;
3000d408: e5913000 ldr r3, [r1] <== NOT EXECUTED
the_spinlock->lock = 0;
3000d40c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000d410: e5802004 str r2, [r0, #4] <== NOT EXECUTED
CORE_spinlock_Control *the_spinlock,
CORE_spinlock_Attributes *the_spinlock_attributes
)
{
the_spinlock->Attributes = *the_spinlock_attributes;
3000d414: e5803000 str r3, [r0] <== NOT EXECUTED
the_spinlock->lock = 0;
the_spinlock->users = 0;
3000d418: e5802008 str r2, [r0, #8] <== NOT EXECUTED
the_spinlock->holder = 0;
3000d41c: e580200c str r2, [r0, #12] <== NOT EXECUTED
}
3000d420: e12fff1e bx lr <== NOT EXECUTED
3000c0b8 <_CORE_spinlock_Release>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c0b8: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000c0bc: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000c0c0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Disable( level );
/*
* It must locked before it can be unlocked.
*/
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000c0c4: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 3000c0c8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c0cc: 1a000002 bne 3000c0dc <_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 (
3000c0d0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_NOT_LOCKED;
3000c0d4: e3a00006 mov r0, #6 <== NOT EXECUTED 3000c0d8: 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 ) {
3000c0dc: e59f3040 ldr r3, [pc, #64] ; 3000c124 <_CORE_spinlock_Release+0x6c><== NOT EXECUTED 3000c0e0: e590100c ldr r1, [r0, #12] <== NOT EXECUTED 3000c0e4: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c0e8: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c0ec: e1510003 cmp r1, r3 <== NOT EXECUTED 3000c0f0: 0a000002 beq 3000c100 <_CORE_spinlock_Release+0x48> <== NOT EXECUTED 3000c0f4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_NOT_HOLDER;
3000c0f8: e3a00002 mov r0, #2 <== NOT EXECUTED 3000c0fc: e12fff1e bx lr <== NOT EXECUTED
}
/*
* Let it be unlocked.
*/
the_spinlock->users -= 1;
3000c100: e5901008 ldr r1, [r0, #8] <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_UNLOCKED;
3000c104: e3a03000 mov r3, #0 <== NOT EXECUTED
}
/*
* Let it be unlocked.
*/
the_spinlock->users -= 1;
3000c108: e2411001 sub r1, r1, #1 <== NOT EXECUTED 3000c10c: e5801008 str r1, [r0, #8] <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_UNLOCKED;
3000c110: e5803004 str r3, [r0, #4] <== NOT EXECUTED
the_spinlock->holder = 0;
3000c114: e580300c str r3, [r0, #12] <== NOT EXECUTED 3000c118: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_SUCCESSFUL;
3000c11c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000c120: e12fff1e bx lr <== NOT EXECUTED
3000c128 <_CORE_spinlock_Wait>:
CORE_spinlock_Status _CORE_spinlock_Wait(
CORE_spinlock_Control *the_spinlock,
bool wait,
Watchdog_Interval timeout
)
{
3000c128: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000c12c: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED
3000c130: e1a05000 mov r5, r0 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c134: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000c138: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000c13c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3000c140: 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) &&
3000c144: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED 3000c148: e3500001 cmp r0, #1 <== NOT EXECUTED 3000c14c: 0a000022 beq 3000c1dc <_CORE_spinlock_Wait+0xb4> <== NOT EXECUTED
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
_ISR_Enable( level );
return CORE_SPINLOCK_HOLDER_RELOCKING;
}
the_spinlock->users += 1;
3000c150: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED 3000c154: e2800001 add r0, r0, #1 <== NOT EXECUTED 3000c158: e5850008 str r0, [r5, #8] <== NOT EXECUTED
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000c15c: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 3000c160: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c164: 0a00000d beq 3000c1a0 <_CORE_spinlock_Wait+0x78> <== NOT EXECUTED
}
/*
* Spinlock is unavailable. If not willing to wait, return.
*/
if ( !wait ) {
3000c168: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c16c: 159f408c ldrne r4, [pc, #140] ; 3000c200 <_CORE_spinlock_Wait+0xd8><== NOT EXECUTED 3000c170: 0a000013 beq 3000c1c4 <_CORE_spinlock_Wait+0x9c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c174: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
_ISR_Enable( level );
/* An ISR could occur here */
_Thread_Enable_dispatch();
3000c178: eb000665 bl 3000db14 <_Thread_Enable_dispatch> <== 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;
3000c17c: e5943000 ldr r3, [r4] <== NOT EXECUTED
++level;
3000c180: e2833001 add r3, r3, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000c184: e5843000 str r3, [r4] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c188: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000c18c: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000c190: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_HOLDER_RELOCKING;
}
the_spinlock->users += 1;
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000c194: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED 3000c198: e3520000 cmp r2, #0 <== NOT EXECUTED 3000c19c: 1afffff4 bne 3000c174 <_CORE_spinlock_Wait+0x4c> <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_LOCKED;
the_spinlock->holder = _Thread_Executing->Object.id;
3000c1a0: e59f205c ldr r2, [pc, #92] ; 3000c204 <_CORE_spinlock_Wait+0xdc><== NOT EXECUTED
return CORE_SPINLOCK_HOLDER_RELOCKING;
}
the_spinlock->users += 1;
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
the_spinlock->lock = CORE_SPINLOCK_LOCKED;
3000c1a4: e3a01001 mov r1, #1 <== NOT EXECUTED
the_spinlock->holder = _Thread_Executing->Object.id;
3000c1a8: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED
return CORE_SPINLOCK_HOLDER_RELOCKING;
}
the_spinlock->users += 1;
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
the_spinlock->lock = CORE_SPINLOCK_LOCKED;
3000c1ac: e5851004 str r1, [r5, #4] <== NOT EXECUTED
the_spinlock->holder = _Thread_Executing->Object.id;
3000c1b0: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000c1b4: e585200c str r2, [r5, #12] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c1b8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_SUCCESSFUL;
3000c1bc: e3a00000 mov r0, #0 <== NOT EXECUTED
3000c1c0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Spinlock is unavailable. If not willing to wait, return.
*/
if ( !wait ) {
the_spinlock->users -= 1;
3000c1c4: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c1c8: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000c1cc: e5853008 str r3, [r5, #8] <== NOT EXECUTED 3000c1d0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_UNAVAILABLE;
3000c1d4: e3a00005 mov r0, #5 <== NOT EXECUTED
3000c1d8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout;
#endif
_ISR_Disable( level );
if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) &&
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
3000c1dc: e59f0020 ldr r0, [pc, #32] ; 3000c204 <_CORE_spinlock_Wait+0xdc><== NOT EXECUTED 3000c1e0: e595c00c ldr ip, [r5, #12] <== NOT EXECUTED 3000c1e4: e5900008 ldr r0, [r0, #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) &&
3000c1e8: e5900008 ldr r0, [r0, #8] <== NOT EXECUTED 3000c1ec: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000c1f0: 1affffd6 bne 3000c150 <_CORE_spinlock_Wait+0x28> <== NOT EXECUTED 3000c1f4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
_ISR_Enable( level );
return CORE_SPINLOCK_HOLDER_RELOCKING;
3000c1f8: e3a00001 mov r0, #1 <== NOT EXECUTED
3000c1fc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000bb2c <_Chain_Append_with_empty_check>:
bool _Chain_Append_with_empty_check(
Chain_Control *chain,
Chain_Node *node
)
{
3000bb2c: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
3000bb30: e10fc000 mrs ip, CPSR <== NOT EXECUTED
3000bb34: e38c3080 orr r3, ip, #128 ; 0x80 <== NOT EXECUTED
3000bb38: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000bb3c: e5904000 ldr r4, [r0] <== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
3000bb40: e2802004 add r2, r0, #4 <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3000bb44: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
the_node->next = tail;
3000bb48: e5812000 str r2, [r1] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000bb4c: e0622004 rsb r2, r2, r4 <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3000bb50: e5801008 str r1, [r0, #8] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000bb54: e2720000 rsbs r0, r2, #0 <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
old_last->next = the_node;
3000bb58: e5831000 str r1, [r3] <== NOT EXECUTED
the_node->previous = old_last;
3000bb5c: e5813004 str r3, [r1, #4] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000bb60: e0a00002 adc r0, r0, r2 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bb64: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
_ISR_Disable( level );
was_empty = _Chain_Append_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return was_empty;
}
3000bb68: e8bd0010 pop {r4} <== NOT EXECUTED
3000bb6c: e12fff1e bx lr <== NOT EXECUTED
3000bb9c <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
3000bb9c: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000bba0: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000bba4: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000bba8: 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;
3000bbac: e5903000 ldr r3, [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 );
3000bbb0: e280c004 add ip, r0, #4 <== NOT EXECUTED
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000bbb4: e15c0003 cmp ip, r3 <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
} else
*the_node = NULL;
3000bbb8: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000bbbc: 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;
3000bbc0: 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 ) {
3000bbc4: 0a000006 beq 3000bbe4 <_Chain_Get_with_empty_check+0x48> <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
3000bbc8: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
3000bbcc: e5802000 str r2, [r0] <== NOT EXECUTED
new_first->previous = head;
3000bbd0: e5820004 str r0, [r2, #4] <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
3000bbd4: e062200c rsb r2, r2, ip <== NOT EXECUTED 3000bbd8: e2720000 rsbs r0, r2, #0 <== NOT EXECUTED 3000bbdc: e0a00002 adc r0, r0, r2 <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
*the_node = old_first;
3000bbe0: 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 (
3000bbe4: 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;
}
3000bbe8: e8bd0010 pop {r4} <== NOT EXECUTED
3000bbec: e12fff1e bx lr <== NOT EXECUTED
3000d720 <_Chain_Insert>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d720: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000d724: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000d728: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000d72c: e5903000 ldr r3, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000d730: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000d734: e5801000 str r1, [r0] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000d738: 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;
3000d73c: 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 (
3000d740: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
_Chain_Insert_unprotected( after_node, node );
_ISR_Enable( level );
}
3000d744: e12fff1e bx lr <== NOT EXECUTED
3000bcb0 <_Chain_Prepend_with_empty_check>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000bcb0: e10fc000 mrs ip, CPSR <== NOT EXECUTED 3000bcb4: e38c3080 orr r3, ip, #128 ; 0x80 <== NOT EXECUTED 3000bcb8: 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;
3000bcbc: e5902000 ldr r2, [r0] <== NOT EXECUTED
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
3000bcc0: e1a03000 mov r3, r0 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000bcc4: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000bcc8: e4831004 str r1, [r3], #4 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000bccc: e5821004 str r1, [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;
3000bcd0: e5812000 str r2, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bcd4: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
_ISR_Disable( level );
was_empty = _Chain_Prepend_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return was_empty;
}
3000bcd8: e0633002 rsb r3, r3, r2 <== NOT EXECUTED 3000bcdc: e2730000 rsbs r0, r3, #0 <== NOT EXECUTED 3000bce0: e0a00003 adc r0, r0, r3 <== NOT EXECUTED 3000bce4: e12fff1e bx lr <== NOT EXECUTED
3000a304 <_Event_Seize>:
Thread_Control *executing,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
3000a304: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000a308: 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;
3000a30c: e3a06000 mov r6, #0
Thread_Control *executing,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
3000a310: e59dc020 ldr ip, [sp, #32] 3000a314: e59d5024 ldr r5, [sp, #36] ; 0x24 3000a318: e59d7028 ldr r7, [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;
3000a31c: e5846034 str r6, [r4, #52] ; 0x34
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000a320: e10fa000 mrs sl, CPSR 3000a324: e38a6080 orr r6, sl, #128 ; 0x80 3000a328: e129f006 msr CPSR_fc, r6
_ISR_Disable( level );
pending_events = event->pending_events;
3000a32c: e59c6000 ldr r6, [ip]
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
3000a330: e0108006 ands r8, r0, r6
3000a334: 0a000003 beq 3000a348 <_Event_Seize+0x44>
3000a338: e1500008 cmp r0, r8
3000a33c: 0a00001e beq 3000a3bc <_Event_Seize+0xb8>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
3000a340: e3110002 tst r1, #2 <== NOT EXECUTED 3000a344: 1a00001c bne 3000a3bc <_Event_Seize+0xb8> <== NOT EXECUTED
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
3000a348: e3110001 tst r1, #1
3000a34c: 1a000015 bne 3000a3a8 <_Event_Seize+0xa4> * 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;
3000a350: e5843028 str r3, [r4, #40] ; 0x28
*sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000a354: 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;
3000a358: e5841030 str r1, [r4, #48] ; 0x30
executing->Wait.count = event_in;
3000a35c: e5840024 str r0, [r4, #36] ; 0x24
executing->Wait.return_argument = event_out;
*sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000a360: e5853000 str r3, [r5]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a364: e129f00a msr CPSR_fc, sl
_ISR_Enable( level );
if ( ticks ) {
3000a368: e3520000 cmp r2, #0
3000a36c: 1a000019 bne 3000a3d8 <_Event_Seize+0xd4>
sync_state
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, wait_state );
3000a370: e1a00004 mov r0, r4 3000a374: e1a01007 mov r1, r7 3000a378: eb000d9a bl 3000d9e8 <_Thread_Set_state>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000a37c: e10f2000 mrs r2, CPSR 3000a380: e3823080 orr r3, r2, #128 ; 0x80 3000a384: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
current_sync_state = *sync_state;
3000a388: e5950000 ldr r0, [r5]
*sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000a38c: e3a03000 mov r3, #0
if ( current_sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
3000a390: e3500001 cmp r0, #1
_Thread_Set_state( executing, wait_state );
_ISR_Disable( level );
current_sync_state = *sync_state;
*sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000a394: e5853000 str r3, [r5]
if ( current_sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
3000a398: 0a00000c beq 3000a3d0 <_Event_Seize+0xcc>
* 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 );
3000a39c: e1a01004 mov r1, r4 <== NOT EXECUTED
}
3000a3a0: 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 );
3000a3a4: ea000a1a b 3000cc14 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a3a8: e129f00a msr CPSR_fc, sl
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
executing->Wait.return_code = RTEMS_UNSATISFIED;
3000a3ac: e3a0200d mov r2, #13 3000a3b0: e5842034 str r2, [r4, #52] ; 0x34
*event_out = seized_events;
3000a3b4: e5838000 str r8, [r3]
return;
3000a3b8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
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) );
3000a3bc: e1c66008 bic r6, r6, r8
pending_events = event->pending_events;
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
(seized_events == event_in || _Options_Is_any( option_set )) ) {
event->pending_events =
3000a3c0: e58c6000 str r6, [ip] 3000a3c4: e129f00a msr CPSR_fc, sl
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
*event_out = seized_events;
3000a3c8: e5838000 str r8, [r3]
return;
3000a3cc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3000a3d0: e129f002 msr CPSR_fc, r2
3000a3d4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a3d8: e3a01000 mov r1, #0
*sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
3000a3dc: e5943008 ldr r3, [r4, #8] 3000a3e0: e5841050 str r1, [r4, #80] ; 0x50
the_watchdog->routine = routine;
3000a3e4: e59f101c ldr r1, [pc, #28] ; 3000a408 <_Event_Seize+0x104>
the_watchdog->id = id;
3000a3e8: e5843068 str r3, [r4, #104] ; 0x68
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000a3ec: e5841064 str r1, [r4, #100] ; 0x64
the_watchdog->id = id; the_watchdog->user_data = user_data;
3000a3f0: e584506c str r5, [r4, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a3f4: e5842054 str r2, [r4, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a3f8: e59f000c ldr r0, [pc, #12] ; 3000a40c <_Event_Seize+0x108> 3000a3fc: e2841048 add r1, r4, #72 ; 0x48 3000a400: eb000e5d bl 3000dd7c <_Watchdog_Insert> 3000a404: eaffffd9 b 3000a370 <_Event_Seize+0x6c>
3000a464 <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
3000a464: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
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;
3000a468: e590c030 ldr ip, [r0, #48] ; 0x30
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
3000a46c: e1a04000 mov r4, r0 3000a470: e59d001c ldr r0, [sp, #28]
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000a474: e10f6000 mrs r6, CPSR 3000a478: e3865080 orr r5, r6, #128 ; 0x80 3000a47c: e129f005 msr CPSR_fc, r5
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;
3000a480: e5925000 ldr r5, [r2] 3000a484: e1811005 orr r1, r1, r5 3000a488: 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;
3000a48c: 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 ) ) {
3000a490: e0117005 ands r7, r1, r5
3000a494: 0a00002e beq 3000a554 <_Event_Surrender+0xf0>
/*
* 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() &&
3000a498: e59f80e0 ldr r8, [pc, #224] ; 3000a580 <_Event_Surrender+0x11c> 3000a49c: e598a000 ldr sl, [r8] 3000a4a0: e35a0000 cmp sl, #0
3000a4a4: 0a000002 beq 3000a4b4 <_Event_Surrender+0x50>
3000a4a8: e5988008 ldr r8, [r8, #8] <== NOT EXECUTED 3000a4ac: e1540008 cmp r4, r8 <== NOT EXECUTED 3000a4b0: 0a000017 beq 3000a514 <_Event_Surrender+0xb0> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
3000a4b4: e5943010 ldr r3, [r4, #16]
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
3000a4b8: e1100003 tst r0, r3
3000a4bc: 0a000024 beq 3000a554 <_Event_Surrender+0xf0>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
3000a4c0: e1550007 cmp r5, r7
3000a4c4: 0a000001 beq 3000a4d0 <_Event_Surrender+0x6c>
3000a4c8: e31c0002 tst ip, #2 <== NOT EXECUTED 3000a4cc: 0a000020 beq 3000a554 <_Event_Surrender+0xf0> <== NOT EXECUTED
event->pending_events = _Event_sets_Clear(
pending_events,
seized_events
);
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
3000a4d0: e5943028 ldr r3, [r4, #40] ; 0x28
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) );
3000a4d4: e1c11007 bic r1, r1, r7
/*
* 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(
3000a4d8: e5821000 str r1, [r2]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
3000a4dc: e3a02000 mov r2, #0 3000a4e0: e5842024 str r2, [r4, #36] ; 0x24
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
3000a4e4: e5837000 str r7, [r3]
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000a4e8: e10f3000 mrs r3, CPSR 3000a4ec: e129f006 msr CPSR_fc, r6 3000a4f0: e129f003 msr CPSR_fc, r3
_ISR_Flash( level );
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000a4f4: e5943050 ldr r3, [r4, #80] ; 0x50 3000a4f8: e3530002 cmp r3, #2
3000a4fc: 0a000016 beq 3000a55c <_Event_Surrender+0xf8>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a500: e129f006 msr CPSR_fc, r6
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000a504: e59f1078 ldr r1, [pc, #120] ; 3000a584 <_Event_Surrender+0x120> 3000a508: e1a00004 mov r0, r4
}
return;
}
}
_ISR_Enable( level );
}
3000a50c: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
3000a510: ea000a13 b 3000cd64 <_Thread_Clear_state>
* 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 ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
3000a514: e5938000 ldr r8, [r3] <== NOT EXECUTED 3000a518: e2488001 sub r8, r8, #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 ) &&
3000a51c: e3580001 cmp r8, #1 <== NOT EXECUTED 3000a520: 8affffe3 bhi 3000a4b4 <_Event_Surrender+0x50> <== 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) ) {
3000a524: e1550007 cmp r5, r7 <== NOT EXECUTED 3000a528: 0a000001 beq 3000a534 <_Event_Surrender+0xd0> <== NOT EXECUTED 3000a52c: e31c0002 tst ip, #2 <== NOT EXECUTED 3000a530: 0a000007 beq 3000a554 <_Event_Surrender+0xf0> <== NOT EXECUTED 3000a534: e1c11007 bic r1, r1, r7 <== NOT EXECUTED
event->pending_events = _Event_sets_Clear(
pending_events,
seized_events
);
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
3000a538: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
event->pending_events = _Event_sets_Clear(
3000a53c: e5821000 str r1, [r2] <== NOT EXECUTED
pending_events,
seized_events
);
the_thread->Wait.count = 0;
3000a540: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a544: e5842024 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
3000a548: e3a02003 mov r2, #3 <== NOT EXECUTED
event->pending_events = _Event_sets_Clear(
pending_events,
seized_events
);
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
3000a54c: e5807000 str r7, [r0] <== NOT EXECUTED
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
3000a550: e5832000 str r2, [r3] <== NOT EXECUTED
3000a554: e129f006 msr CPSR_fc, r6
3000a558: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000a55c: e3a03003 mov r3, #3 3000a560: e5843050 str r3, [r4, #80] ; 0x50 3000a564: e129f006 msr CPSR_fc, r6
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000a568: e2840048 add r0, r4, #72 ; 0x48 3000a56c: eb000e6f bl 3000df30 <_Watchdog_Remove> 3000a570: e59f100c ldr r1, [pc, #12] ; 3000a584 <_Event_Surrender+0x120> 3000a574: e1a00004 mov r0, r4
}
return;
}
}
_ISR_Enable( level );
}
3000a578: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
3000a57c: ea0009f8 b 3000cd64 <_Thread_Clear_state>
3000a588 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *arg
)
{
3000a588: e92d4010 push {r4, lr} <== NOT EXECUTED
3000a58c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000a590: e1a04001 mov r4, r1 <== NOT EXECUTED
ISR_Level level;
Thread_blocking_operation_States *sync_state;
sync_state = arg;
the_thread = _Thread_Get( id, &location );
3000a594: e1a0100d mov r1, sp <== NOT EXECUTED 3000a598: eb000aee bl 3000d158 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000a59c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a5a0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a5a4: 1a000010 bne 3000a5ec <_Event_Timeout+0x64> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000a5a8: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000a5ac: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 3000a5b0: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
3000a5b4: e5803024 str r3, [r0, #36] ; 0x24 <== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) ) {
3000a5b8: e59f3048 ldr r3, [pc, #72] ; 3000a608 <_Event_Timeout+0x80><== NOT EXECUTED 3000a5bc: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000a5c0: e1500003 cmp r0, r3 <== NOT EXECUTED 3000a5c4: 0a00000a beq 3000a5f4 <_Event_Timeout+0x6c> <== NOT EXECUTED
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
3000a5c8: e3a03006 mov r3, #6 <== NOT EXECUTED 3000a5cc: 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 (
3000a5d0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000a5d4: e59f1030 ldr r1, [pc, #48] ; 3000a60c <_Event_Timeout+0x84><== NOT EXECUTED 3000a5d8: eb0009e1 bl 3000cd64 <_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;
3000a5dc: e59f302c ldr r3, [pc, #44] ; 3000a610 <_Event_Timeout+0x88><== NOT EXECUTED 3000a5e0: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000a5e4: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000a5e8: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
3000a5ec: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a5f0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
3000a5f4: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000a5f8: e3530001 cmp r3, #1 <== NOT EXECUTED
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
3000a5fc: 03a03002 moveq r3, #2 <== NOT EXECUTED 3000a600: 05843000 streq r3, [r4] <== NOT EXECUTED 3000a604: eaffffef b 3000a5c8 <_Event_Timeout+0x40> <== NOT EXECUTED
30010648 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
30010648: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3001064c: 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;
30010650: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
30010654: e24dd01c sub sp, sp, #28 30010658: e1a06001 mov r6, r1
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3001065c: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
30010660: e1a07000 mov r7, r0
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
30010664: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
30010668: e1a0b003 mov fp, r3
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;
3001066c: e58d200c str r2, [sp, #12]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
30010670: 2a000086 bcs 30010890 <_Heap_Allocate_aligned_with_boundary+0x248>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
30010674: e3530000 cmp r3, #0
30010678: 1a000078 bne 30010860 <_Heap_Allocate_aligned_with_boundary+0x218>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
3001067c: e597a008 ldr sl, [r7, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
30010680: e3a05000 mov r5, #0 30010684: e157000a cmp r7, sl
30010688: 0a00007b beq 3001087c <_Heap_Allocate_aligned_with_boundary+0x234>
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
3001068c: e59d300c ldr r3, [sp, #12]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
30010690: e2662004 rsb r2, 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
30010694: e2833007 add r3, r3, #7 30010698: e58d3010 str r3, [sp, #16]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3001069c: e58d2014 str r2, [sp, #20] 300106a0: ea000005 b 300106bc <_Heap_Allocate_aligned_with_boundary+0x74>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
300106a4: e3540000 cmp r4, #0
);
}
}
/* Statistics */
++search_count;
300106a8: e2855001 add r5, r5, #1
if ( alloc_begin != 0 ) {
300106ac: 1a00005a bne 3001081c <_Heap_Allocate_aligned_with_boundary+0x1d4>
break;
}
block = block->next;
300106b0: 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 ) {
300106b4: e157000a cmp r7, sl
300106b8: 0a00006f beq 3001087c <_Heap_Allocate_aligned_with_boundary+0x234>
/*
* 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 ) {
300106bc: e59a9004 ldr r9, [sl, #4] 300106c0: e59d3000 ldr r3, [sp] 300106c4: e1530009 cmp r3, r9
);
}
}
/* Statistics */
++search_count;
300106c8: 22855001 addcs r5, r5, #1
/*
* 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 ) {
300106cc: 2afffff7 bcs 300106b0 <_Heap_Allocate_aligned_with_boundary+0x68>
if ( alignment == 0 ) {
300106d0: 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;
300106d4: 028a4008 addeq r4, sl, #8
300106d8: 0afffff1 beq 300106a4 <_Heap_Allocate_aligned_with_boundary+0x5c>
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;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
300106dc: e59d3014 ldr r3, [sp, #20]
- 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;
300106e0: e3c99001 bic r9, r9, #1
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
300106e4: e5972014 ldr r2, [r7, #20]
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;
300106e8: e08a9009 add r9, sl, r9
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;
300106ec: e59d1010 ldr r1, [sp, #16]
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
300106f0: e0834009 add r4, r3, r9
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
300106f4: e1a00004 mov r0, r4
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;
300106f8: e0623001 rsb r3, r2, r1 300106fc: e1a01008 mov r1, r8
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
30010700: e58d2004 str r2, [sp, #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
30010704: e0839009 add r9, r3, r9 30010708: eb002c8d bl 3001b944 <__umodsi3> 3001070c: e0604004 rsb r4, r0, r4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
30010710: e28a2008 add r2, sl, #8
uintptr_t alloc_begin = alloc_end - alloc_size;
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 ) {
30010714: e1590004 cmp r9, r4 30010718: e58d2008 str r2, [sp, #8]
3001071c: 2a000003 bcs 30010730 <_Heap_Allocate_aligned_with_boundary+0xe8>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30010720: e1a00009 mov r0, r9 <== NOT EXECUTED 30010724: e1a01008 mov r1, r8 <== NOT EXECUTED 30010728: eb002c85 bl 3001b944 <__umodsi3> <== NOT EXECUTED 3001072c: e0604009 rsb r4, r0, r9 <== NOT EXECUTED
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
30010730: e35b0000 cmp fp, #0
30010734: 0a000025 beq 300107d0 <_Heap_Allocate_aligned_with_boundary+0x188>
/* 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;
30010738: e0849006 add r9, r4, r6 <== NOT EXECUTED 3001073c: e1a00009 mov r0, r9 <== NOT EXECUTED 30010740: e1a0100b mov r1, fp <== NOT EXECUTED 30010744: eb002c7e bl 3001b944 <__umodsi3> <== NOT EXECUTED 30010748: 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 ) {
3001074c: e1540000 cmp r4, r0 <== NOT EXECUTED 30010750: 23a03000 movcs r3, #0 <== NOT EXECUTED 30010754: 33a03001 movcc r3, #1 <== NOT EXECUTED 30010758: e1590000 cmp r9, r0 <== NOT EXECUTED 3001075c: 93a03000 movls r3, #0 <== NOT EXECUTED 30010760: e3530000 cmp r3, #0 <== NOT EXECUTED 30010764: 0a000019 beq 300107d0 <_Heap_Allocate_aligned_with_boundary+0x188><== NOT EXECUTED
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
30010768: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3001076c: e0839006 add r9, r3, r6 <== 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 ) {
30010770: e1590000 cmp r9, r0 <== NOT EXECUTED 30010774: 958da018 strls sl, [sp, #24] <== NOT EXECUTED 30010778: 9a000002 bls 30010788 <_Heap_Allocate_aligned_with_boundary+0x140><== NOT EXECUTED 3001077c: ea00003c b 30010874 <_Heap_Allocate_aligned_with_boundary+0x22c><== NOT EXECUTED 30010780: e1590000 cmp r9, r0 <== NOT EXECUTED 30010784: 8a00003e bhi 30010884 <_Heap_Allocate_aligned_with_boundary+0x23c><== NOT EXECUTED
return 0;
}
alloc_begin = boundary_line - alloc_size;
30010788: e0664000 rsb r4, r6, r0 <== NOT EXECUTED 3001078c: e1a01008 mov r1, r8 <== NOT EXECUTED 30010790: e1a00004 mov r0, r4 <== NOT EXECUTED 30010794: eb002c6a bl 3001b944 <__umodsi3> <== NOT EXECUTED 30010798: e0604004 rsb r4, r0, r4 <== NOT EXECUTED
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
3001079c: e084a006 add sl, r4, r6 <== NOT EXECUTED 300107a0: e1a0000a mov r0, sl <== NOT EXECUTED 300107a4: e1a0100b mov r1, fp <== NOT EXECUTED 300107a8: eb002c65 bl 3001b944 <__umodsi3> <== NOT EXECUTED 300107ac: e060000a rsb r0, r0, sl <== 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 ) {
300107b0: e15a0000 cmp sl, r0 <== NOT EXECUTED 300107b4: 93a0a000 movls sl, #0 <== NOT EXECUTED 300107b8: 83a0a001 movhi sl, #1 <== NOT EXECUTED 300107bc: e1540000 cmp r4, r0 <== NOT EXECUTED 300107c0: 23a0a000 movcs sl, #0 <== NOT EXECUTED 300107c4: e35a0000 cmp sl, #0 <== NOT EXECUTED 300107c8: 1affffec bne 30010780 <_Heap_Allocate_aligned_with_boundary+0x138><== NOT EXECUTED 300107cc: e59da018 ldr sl, [sp, #24] <== 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 ) {
300107d0: e59d2008 ldr r2, [sp, #8] 300107d4: e1520004 cmp r2, r4
300107d8: 8a000025 bhi 30010874 <_Heap_Allocate_aligned_with_boundary+0x22c>
300107dc: e1a00004 mov r0, r4 300107e0: e59d100c ldr r1, [sp, #12] 300107e4: eb002c56 bl 3001b944 <__umodsi3> 300107e8: e3e09007 mvn r9, #7 300107ec: 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);
300107f0: e0899004 add r9, r9, r4
if ( free_size >= min_block_size || free_size == 0 ) {
return alloc_begin;
}
}
return 0;
300107f4: 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 ) {
300107f8: e0603009 rsb r3, r0, r9
return alloc_begin;
}
}
return 0;
300107fc: e1590000 cmp r9, r0 30010800: 11520003 cmpne r2, r3 30010804: 83a03000 movhi r3, #0 30010808: 93a03001 movls r3, #1 3001080c: 81a04003 movhi r4, r3
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
30010810: e3540000 cmp r4, #0
);
}
}
/* Statistics */
++search_count;
30010814: e2855001 add r5, r5, #1
if ( alloc_begin != 0 ) {
30010818: 0affffa4 beq 300106b0 <_Heap_Allocate_aligned_with_boundary+0x68>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3001081c: e5972048 ldr r2, [r7, #72] ; 0x48
stats->searches += search_count;
30010820: e597304c ldr r3, [r7, #76] ; 0x4c
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
30010824: e2822001 add r2, r2, #1
stats->searches += search_count;
30010828: e0833005 add r3, r3, r5
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3001082c: e5872048 str r2, [r7, #72] ; 0x48
stats->searches += search_count;
30010830: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
30010834: e1a00007 mov r0, r7 30010838: e1a0100a mov r1, sl 3001083c: e1a02004 mov r2, r4 30010840: e1a03006 mov r3, r6 30010844: ebffecce bl 3000bb84 <_Heap_Block_allocate>
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
30010848: e5973044 ldr r3, [r7, #68] ; 0x44
stats->max_search = search_count;
}
return (void *) alloc_begin;
3001084c: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
30010850: e1530005 cmp r3, r5
stats->max_search = search_count;
30010854: 35875044 strcc r5, [r7, #68] ; 0x44
}
return (void *) alloc_begin;
}
30010858: e28dd01c add sp, sp, #28
3001085c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
30010860: e1560003 cmp r6, r3 <== NOT EXECUTED 30010864: 8a000009 bhi 30010890 <_Heap_Allocate_aligned_with_boundary+0x248><== NOT EXECUTED
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
30010868: e3580000 cmp r8, #0 <== NOT EXECUTED 3001086c: 01a08002 moveq r8, r2 <== NOT EXECUTED 30010870: eaffff81 b 3001067c <_Heap_Allocate_aligned_with_boundary+0x34><== NOT EXECUTED
if ( free_size >= min_block_size || free_size == 0 ) {
return alloc_begin;
}
}
return 0;
30010874: e3a04000 mov r4, #0 30010878: eaffff89 b 300106a4 <_Heap_Allocate_aligned_with_boundary+0x5c>
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3001087c: e3a04000 mov r4, #0 30010880: eafffff0 b 30010848 <_Heap_Allocate_aligned_with_boundary+0x200>
30010884: e59da018 ldr sl, [sp, #24] <== NOT EXECUTED
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 ) {
if ( boundary_line < boundary_floor ) {
return 0;
30010888: e3a04000 mov r4, #0 <== NOT EXECUTED 3001088c: eaffff84 b 300106a4 <_Heap_Allocate_aligned_with_boundary+0x5c><== NOT EXECUTED
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
30010890: e3a00000 mov r0, #0 30010894: eaffffef b 30010858 <_Heap_Allocate_aligned_with_boundary+0x210>
3000bb84 <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000bb84: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, 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;
3000bb88: e5917004 ldr r7, [r1, #4] 3000bb8c: e1a05001 mov r5, r1 3000bb90: e3c71001 bic r1, r7, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000bb94: e0858001 add r8, r5, r1
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000bb98: e598c004 ldr ip, [r8, #4]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000bb9c: e2426008 sub r6, r2, #8
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000bba0: e31c0001 tst ip, #1
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000bba4: e1a0a003 mov sl, r3 3000bba8: e1a04000 mov r4, r0
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;
3000bbac: e0653006 rsb r3, r5, r6
/* Statistics */
--stats->free_blocks;
++stats->used_blocks;
stats->free_size -= _Heap_Block_size( block );
} else {
free_list_anchor = _Heap_Free_list_head( heap );
3000bbb0: 11a09000 movne r9, r0
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000bbb4: 1a00000c bne 3000bbec <_Heap_Block_allocate+0x68>
free_list_anchor = block->prev;
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000bbb8: e590e038 ldr lr, [r0, #56] ; 0x38
++stats->used_blocks;
3000bbbc: e590c040 ldr ip, [r0, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000bbc0: e590b030 ldr fp, [r0, #48] ; 0x30
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
free_list_anchor = block->prev;
3000bbc4: e595900c ldr r9, [r5, #12]
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
3000bbc8: e5950008 ldr r0, [r5, #8]
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000bbcc: e24ee001 sub lr, lr, #1
++stats->used_blocks;
3000bbd0: e28cc001 add ip, ip, #1
stats->free_size -= _Heap_Block_size( block );
3000bbd4: e061100b rsb r1, r1, fp
Heap_Block *prev = block->prev;
prev->next = next;
3000bbd8: e5890008 str r0, [r9, #8]
next->prev = prev;
3000bbdc: e580900c str r9, [r0, #12]
free_list_anchor = block->prev;
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000bbe0: e584e038 str lr, [r4, #56] ; 0x38
++stats->used_blocks;
3000bbe4: e584c040 str ip, [r4, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000bbe8: e5841030 str r1, [r4, #48] ; 0x30
} else {
free_list_anchor = _Heap_Free_list_head( heap );
}
if ( alloc_area_offset < heap->page_size ) {
3000bbec: e5941010 ldr r1, [r4, #16] 3000bbf0: e1530001 cmp r3, r1
3000bbf4: 2a00000a bcs 3000bc24 <_Heap_Block_allocate+0xa0>
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
_Heap_Block_split( heap, block, free_list_anchor, alloc_size );
3000bbf8: e1a00004 mov r0, r4 3000bbfc: e1a02009 mov r2, r9 3000bc00: e083300a add r3, r3, sl 3000bc04: e1a01005 mov r1, r5 3000bc08: ebffff2d bl 3000b8c4 <_Heap_Block_split>
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000bc0c: e5943030 ldr r3, [r4, #48] ; 0x30 3000bc10: e5942034 ldr r2, [r4, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000bc14: e1a00005 mov r0, r5
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000bc18: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000bc1c: 85843034 strhi r3, [r4, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000bc20: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000bc24: e1a00002 mov r0, r2 3000bc28: eb003f45 bl 3001b944 <__umodsi3>
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000bc2c: e5943030 ldr r3, [r4, #48] ; 0x30
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000bc30: 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;
3000bc34: e0651006 rsb r1, r5, r6
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000bc38: e0833001 add r3, r3, r1
if ( _Heap_Is_prev_used( block ) ) {
3000bc3c: e3170001 tst r7, #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;
3000bc40: e0668008 rsb r8, r6, r8
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000bc44: e5843030 str r3, [r4, #48] ; 0x30
if ( _Heap_Is_prev_used( block ) ) {
3000bc48: 1a000013 bne 3000bc9c <_Heap_Block_allocate+0x118>
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Prev_block(
const Heap_Block *block
)
{
return (Heap_Block *) ((uintptr_t) block - block->prev_size);
3000bc4c: e5953000 ldr r3, [r5] <== 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;
3000bc50: e1a02009 mov r2, r9 <== NOT EXECUTED 3000bc54: e0635005 rsb r5, r3, r5 <== 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;
3000bc58: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 3000bc5c: e3c33001 bic r3, r3, #1 <== NOT EXECUTED 3000bc60: e0811003 add r1, r1, r3 <== NOT EXECUTED
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
3000bc64: e3813001 orr r3, r1, #1 3000bc68: e5853004 str r3, [r5, #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 );
3000bc6c: e1a00004 mov r0, r4
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
new_block->prev_size = block_size;
new_block->size_and_flag = new_block_size;
3000bc70: e8860102 stm r6, {r1, r8}
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000bc74: e1a0300a mov r3, sl 3000bc78: e1a01006 mov r1, r6 3000bc7c: ebffff10 bl 3000b8c4 <_Heap_Block_split>
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000bc80: e5943030 ldr r3, [r4, #48] ; 0x30 3000bc84: e5942034 ldr r2, [r4, #52] ; 0x34
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
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 );
3000bc88: e1a05006 mov r5, r6
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000bc8c: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000bc90: 85843034 strhi r3, [r4, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000bc94: e1a00005 mov r0, r5
3000bc98: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
_Heap_Free_list_insert_after( free_list_anchor, block );
free_list_anchor = block;
/* Statistics */
++stats->free_blocks;
3000bc9c: e5940038 ldr r0, [r4, #56] ; 0x38
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000bca0: e5993008 ldr r3, [r9, #8] 3000bca4: e2800001 add r0, r0, #1
new_block->next = next;
3000bca8: e5853008 str r3, [r5, #8]
new_block->prev = block_before;
3000bcac: e585900c str r9, [r5, #12]
block_before->next = new_block;
3000bcb0: e5895008 str r5, [r9, #8]
next->prev = new_block;
3000bcb4: e583500c str r5, [r3, #12] 3000bcb8: e1a02005 mov r2, r5 3000bcbc: e5840038 str r0, [r4, #56] ; 0x38 3000bcc0: eaffffe7 b 3000bc64 <_Heap_Block_allocate+0xe0>
3000b8c4 <_Heap_Block_split>:
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000b8c4: e92d45f0 push {r4, r5, r6, r7, r8, sl, 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;
3000b8c8: e5905014 ldr r5, [r0, #20]
uintptr_t alloc_size
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
3000b8cc: e5906010 ldr r6, [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;
3000b8d0: e2458008 sub r8, r5, #8
return heap->stats.size;
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Max( uintptr_t a, uintptr_t b )
{
return a > b ? a : b;
3000b8d4: e1530008 cmp r3, r8 3000b8d8: 21a08003 movcs r8, r3
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const used_size =
3000b8dc: e2888008 add r8, r8, #8
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000b8e0: e1a07001 mov r7, r1 3000b8e4: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000b8e8: e1a01006 mov r1, r6 3000b8ec: e1a00008 mov r0, r8 3000b8f0: e1a0a002 mov sl, r2 3000b8f4: eb004012 bl 3001b944 <__umodsi3>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000b8f8: e5973004 ldr r3, [r7, #4]
if ( remainder != 0 ) {
3000b8fc: e3500000 cmp r0, #0 3000b900: e3c31001 bic r1, r3, #1
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;
3000b904: e2812004 add r2, r1, #4
return value - remainder + alignment;
3000b908: 10886006 addne r6, r8, r6
} else {
return value;
3000b90c: 01a06008 moveq r6, r8
uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS;
3000b910: e2855004 add r5, r5, #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;
3000b914: e0688002 rsb r8, r8, r2
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
3000b918: 10606006 rsbne r6, r0, r6
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 ) {
3000b91c: e1580005 cmp r8, r5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000b920: e0872001 add r2, r7, r1
3000b924: 3a00001c bcc 3000b99c <_Heap_Block_split+0xd8>
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;
3000b928: e2033001 and r3, r3, #1
block->size_and_flag = size | flag;
3000b92c: e1863003 orr r3, r6, r3 3000b930: e5873004 str r3, [r7, #4]
- 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;
3000b934: e5923004 ldr r3, [r2, #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;
3000b938: e5940030 ldr r0, [r4, #48] ; 0x30 3000b93c: e3c33001 bic r3, r3, #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;
3000b940: e082c003 add ip, r2, r3 3000b944: e59cc004 ldr ip, [ip, #4]
_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;
3000b948: e0661001 rsb r1, r6, r1
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000b94c: e0800001 add r0, r0, r1
if ( _Heap_Is_used( next_block ) ) {
3000b950: e31c0001 tst ip, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000b954: e0867007 add r7, r6, r7
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000b958: e5840030 str r0, [r4, #48] ; 0x30
if ( _Heap_Is_used( next_block ) ) {
3000b95c: 1a000012 bne 3000b9ac <_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;
3000b960: e5920008 ldr r0, [r2, #8] <== NOT EXECUTED
Heap_Block *prev = old_block->prev;
3000b964: e592200c ldr r2, [r2, #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;
3000b968: e0811003 add r1, r1, r3 <== NOT EXECUTED
new_block->next = next;
new_block->prev = prev;
3000b96c: e587200c str r2, [r7, #12] <== NOT EXECUTED
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3000b970: e5870008 str r0, [r7, #8] <== NOT EXECUTED
new_block->prev = prev;
next->prev = new_block;
3000b974: e580700c str r7, [r0, #12] <== NOT EXECUTED
prev->next = new_block;
3000b978: e5827008 str r7, [r2, #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);
3000b97c: e0812007 add r2, r1, r7 <== NOT EXECUTED
next_block = _Heap_Block_at( free_block, free_block_size );
}
free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
3000b980: e3813001 orr r3, r1, #1 3000b984: e5873004 str r3, [r7, #4]
next_block->prev_size = free_block_size;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000b988: e5923004 ldr r3, [r2, #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;
3000b98c: e5821000 str r1, [r2]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000b990: e3c33001 bic r3, r3, #1
3000b994: e5823004 str r3, [r2, #4]
3000b998: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
_Heap_Protection_block_initialize( heap, free_block );
} else {
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000b99c: e5923004 ldr r3, [r2, #4]
3000b9a0: e3833001 orr r3, r3, #1
3000b9a4: e5823004 str r3, [r2, #4]
3000b9a8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
if ( _Heap_Is_used( next_block ) ) {
_Heap_Free_list_insert_after( free_list_anchor, free_block );
/* Statistics */
++stats->free_blocks;
3000b9ac: e5940038 ldr r0, [r4, #56] ; 0x38
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000b9b0: e59a3008 ldr r3, [sl, #8] 3000b9b4: e2800001 add r0, r0, #1
new_block->next = next;
3000b9b8: e5873008 str r3, [r7, #8]
new_block->prev = block_before;
3000b9bc: e587a00c str sl, [r7, #12]
block_before->next = new_block;
3000b9c0: e58a7008 str r7, [sl, #8]
next->prev = new_block;
3000b9c4: e583700c str r7, [r3, #12] 3000b9c8: e5840038 str r0, [r4, #56] ; 0x38 3000b9cc: eaffffeb b 3000b980 <_Heap_Block_split+0xbc>
30010904 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
30010904: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
30010908: e1a05000 mov r5, r0 <== 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 ) {
3001090c: e0916002 adds r6, r1, r2 <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
30010910: e1a04001 mov r4, r1 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
30010914: e5908020 ldr r8, [r0, #32] <== 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;
30010918: e5951030 ldr r1, [r5, #48] ; 0x30 <== 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;
3001091c: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
30010920: e24dd020 sub sp, sp, #32 <== 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;
30010924: e3a07000 mov r7, #0 <== NOT EXECUTED
Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
30010928: e58d0008 str r0, [sp, #8] <== 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;
3001092c: e58d7018 str r7, [sp, #24] <== NOT EXECUTED
Heap_Block *extend_last_block = NULL;
30010930: e58d701c str r7, [sp, #28] <== NOT EXECUTED
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
30010934: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
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;
30010938: e58d1014 str r1, [sp, #20] <== 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;
3001093c: 21a00007 movcs r0, r7 <== 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 ) {
30010940: 3a000001 bcc 3001094c <_Heap_Extend+0x48> <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
return extended_size;
}
30010944: e28dd020 add sp, sp, #32 <== NOT EXECUTED
30010948: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( extend_area_end < extend_area_begin ) {
return 0;
}
extend_area_ok = _Heap_Get_first_and_last_block(
3001094c: e28dc018 add ip, sp, #24 <== NOT EXECUTED 30010950: e1a01002 mov r1, r2 <== NOT EXECUTED 30010954: e58dc000 str ip, [sp] <== NOT EXECUTED 30010958: e1a00004 mov r0, r4 <== NOT EXECUTED 3001095c: e28dc01c add ip, sp, #28 <== NOT EXECUTED 30010960: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 30010964: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 30010968: ebffec2c bl 3000ba20 <_Heap_Get_first_and_last_block> <== NOT EXECUTED
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
3001096c: e3500000 cmp r0, #0 <== NOT EXECUTED 30010970: 0afffff3 beq 30010944 <_Heap_Extend+0x40> <== NOT EXECUTED 30010974: e1a09008 mov r9, r8 <== NOT EXECUTED 30010978: e1a0b007 mov fp, r7 <== NOT EXECUTED 3001097c: e58d700c str r7, [sp, #12] <== NOT EXECUTED 30010980: e58d7010 str r7, [sp, #16] <== NOT EXECUTED
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
30010984: e1590008 cmp r9, r8 <== NOT EXECUTED 30010988: 05953018 ldreq r3, [r5, #24] <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
3001098c: e599a000 ldr sl, [r9] <== NOT EXECUTED
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
30010990: 11a03009 movne r3, r9 <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
30010994: e1530006 cmp r3, r6 <== NOT EXECUTED 30010998: 3154000a cmpcc r4, sl <== NOT EXECUTED 3001099c: 3a000067 bcc 30010b40 <_Heap_Extend+0x23c> <== NOT EXECUTED
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return 0;
}
if ( extend_area_end == sub_area_begin ) {
300109a0: e1530006 cmp r3, r6 <== NOT EXECUTED 300109a4: 058d9010 streq r9, [sp, #16] <== NOT EXECUTED 300109a8: 0a000001 beq 300109b4 <_Heap_Extend+0xb0> <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
300109ac: e156000a cmp r6, sl <== NOT EXECUTED 300109b0: 31a0b009 movcc fp, r9 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
300109b4: e1a0000a mov r0, sl <== NOT EXECUTED 300109b8: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 300109bc: eb002ca2 bl 3001bc4c <__umodsi3> <== NOT EXECUTED 300109c0: e24a3008 sub r3, sl, #8 <== NOT EXECUTED
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
300109c4: e15a0004 cmp sl, r4 <== NOT EXECUTED
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
300109c8: e0603003 rsb r3, r0, r3 <== NOT EXECUTED
start_block->prev_size = extend_area_end;
300109cc: 05896000 streq r6, [r9] <== 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 )
300109d0: 058d300c streq r3, [sp, #12] <== 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 ) {
300109d4: 0a000001 beq 300109e0 <_Heap_Extend+0xdc> <== NOT EXECUTED 300109d8: e154000a cmp r4, sl <== NOT EXECUTED 300109dc: 81a07003 movhi r7, r3 <== 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;
300109e0: e5939004 ldr r9, [r3, #4] <== NOT EXECUTED 300109e4: e3c99001 bic r9, r9, #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);
300109e8: e0839009 add r9, r3, r9 <== 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 );
300109ec: e1580009 cmp r8, r9 <== NOT EXECUTED 300109f0: 1affffe3 bne 30010984 <_Heap_Extend+0x80> <== NOT EXECUTED
if ( extend_area_begin < heap->area_begin ) {
300109f4: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED 300109f8: e1540003 cmp r4, r3 <== NOT EXECUTED
heap->area_begin = extend_area_begin;
300109fc: 35854018 strcc r4, [r5, #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 ) {
30010a00: 3a000002 bcc 30010a10 <_Heap_Extend+0x10c> <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
30010a04: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 30010a08: e1560003 cmp r6, r3 <== NOT EXECUTED
heap->area_end = extend_area_end;
30010a0c: 8585601c strhi r6, [r5, #28] <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
30010a10: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 30010a14: e59d201c ldr r2, [sp, #28] <== 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 ) {
30010a18: e595c020 ldr ip, [r5, #32] <== 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 =
30010a1c: e0631002 rsb r1, r3, r2 <== 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;
30010a20: e3810001 orr r0, r1, #1 <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
30010a24: e5836000 str r6, [r3] <== 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 ) {
30010a28: e15c0003 cmp ip, r3 <== NOT EXECUTED
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
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;
30010a2c: e5821000 str r1, [r2] <== NOT EXECUTED
extend_last_block->size_and_flag = 0;
30010a30: e3a01000 mov r1, #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 =
30010a34: e5830004 str r0, [r3, #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;
30010a38: e5821004 str r1, [r2, #4] <== NOT EXECUTED
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
heap->first_block = extend_first_block;
30010a3c: 85853020 strhi r3, [r5, #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 ) {
30010a40: 8a000002 bhi 30010a50 <_Heap_Extend+0x14c> <== NOT EXECUTED
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
30010a44: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED 30010a48: e1530002 cmp r3, r2 <== NOT EXECUTED
heap->last_block = extend_last_block;
30010a4c: 35852024 strcc r2, [r5, #36] ; 0x24 <== NOT EXECUTED
}
if ( merge_below_block != NULL ) {
30010a50: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30010a54: e3530000 cmp r3, #0 <== NOT EXECUTED 30010a58: 0a00004b beq 30010b8c <_Heap_Extend+0x288> <== NOT EXECUTED
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
30010a5c: e5958010 ldr r8, [r5, #16] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
30010a60: e2844008 add r4, r4, #8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
30010a64: e1a00004 mov r0, r4 <== NOT EXECUTED 30010a68: e1a01008 mov r1, r8 <== NOT EXECUTED 30010a6c: eb002c76 bl 3001bc4c <__umodsi3> <== NOT EXECUTED
if ( remainder != 0 ) {
30010a70: e3500000 cmp r0, #0 <== NOT EXECUTED
return value - remainder + alignment;
30010a74: 10844008 addne r4, r4, r8 <== NOT EXECUTED 30010a78: 10604004 rsbne r4, r0, r4 <== 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;
30010a7c: e59d3010 ldr r3, [sp, #16] <== 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 =
30010a80: e2441008 sub r1, r4, #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;
30010a84: e5932000 ldr r2, [r3] <== 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 =
30010a88: e0613003 rsb r3, r1, r3 <== 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;
30010a8c: e3833001 orr r3, r3, #1 <== 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;
30010a90: e5042008 str r2, [r4, #-8] <== NOT EXECUTED
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
30010a94: e5813004 str r3, [r1, #4] <== NOT EXECUTED
_Heap_Free_block( heap, new_first_block );
30010a98: e1a00005 mov r0, r5 <== NOT EXECUTED 30010a9c: ebffff83 bl 300108b0 <_Heap_Free_block> <== NOT EXECUTED
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
30010aa0: e59d400c ldr r4, [sp, #12] <== NOT EXECUTED 30010aa4: e3540000 cmp r4, #0 <== NOT EXECUTED 30010aa8: 0a000026 beq 30010b48 <_Heap_Extend+0x244> <== 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,
30010aac: 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(
30010ab0: e0646006 rsb r6, r4, r6 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30010ab4: e5951010 ldr r1, [r5, #16] <== NOT EXECUTED 30010ab8: e1a00006 mov r0, r6 <== NOT EXECUTED 30010abc: eb002c62 bl 3001bc4c <__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)
30010ac0: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30010ac4: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 30010ac8: e0663003 rsb r3, r6, r3 <== 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 =
30010acc: e0862004 add r2, r6, r4 <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
30010ad0: e3833001 orr r3, r3, #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 =
30010ad4: e5823004 str r3, [r2, #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;
30010ad8: e5943004 ldr r3, [r4, #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 );
30010adc: e1a00005 mov r0, r5 <== NOT EXECUTED 30010ae0: e2033001 and r3, r3, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
30010ae4: e1866003 orr r6, r6, r3 <== NOT EXECUTED 30010ae8: e5846004 str r6, [r4, #4] <== NOT EXECUTED 30010aec: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 30010af0: ebffff6e bl 300108b0 <_Heap_Free_block> <== NOT EXECUTED
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
30010af4: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 30010af8: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30010afc: e3520000 cmp r2, #0 <== NOT EXECUTED 30010b00: 03530000 cmpeq r3, #0 <== NOT EXECUTED 30010b04: 0a00001c beq 30010b7c <_Heap_Extend+0x278> <== 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
30010b08: e5953024 ldr r3, [r5, #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(
30010b0c: e595c020 ldr ip, [r5, #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;
30010b10: e5931004 ldr r1, [r3, #4] <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
30010b14: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010b18: e59d4014 ldr r4, [sp, #20] <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
30010b1c: e595202c ldr r2, [r5, #44] ; 0x2c <== 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(
30010b20: e063c00c rsb ip, r3, ip <== 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;
30010b24: e2011001 and r1, r1, #1 <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
30010b28: e0640000 rsb r0, r4, r0 <== NOT EXECUTED
block->size_and_flag = size | flag;
30010b2c: e18c1001 orr r1, ip, r1 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
30010b30: e0822000 add r2, r2, r0 <== NOT EXECUTED 30010b34: e5831004 str r1, [r3, #4] <== NOT EXECUTED 30010b38: e585202c str r2, [r5, #44] ; 0x2c <== NOT EXECUTED
return extended_size;
30010b3c: eaffff80 b 30010944 <_Heap_Extend+0x40> <== 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;
30010b40: e3a00000 mov r0, #0 <== NOT EXECUTED 30010b44: eaffff7e b 30010944 <_Heap_Extend+0x40> <== NOT EXECUTED
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
30010b48: e3570000 cmp r7, #0 <== NOT EXECUTED 30010b4c: 0affffe8 beq 30010af4 <_Heap_Extend+0x1f0> <== 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;
30010b50: e5971004 ldr r1, [r7, #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 );
30010b54: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 30010b58: e2011001 and r1, r1, #1 <== NOT EXECUTED 30010b5c: e0672002 rsb r2, r7, r2 <== 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(
30010b60: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
block->size_and_flag = size | flag;
30010b64: e1822001 orr r2, r2, r1 <== NOT EXECUTED 30010b68: e5872004 str r2, [r7, #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;
30010b6c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30010b70: e3822001 orr r2, r2, #1 <== NOT EXECUTED 30010b74: e5832004 str r2, [r3, #4] <== NOT EXECUTED 30010b78: eaffffdd b 30010af4 <_Heap_Extend+0x1f0> <== NOT EXECUTED
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
_Heap_Free_block( heap, extend_first_block );
30010b7c: e1a00005 mov r0, r5 <== NOT EXECUTED 30010b80: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 30010b84: ebffff49 bl 300108b0 <_Heap_Free_block> <== NOT EXECUTED 30010b88: eaffffde b 30010b08 <_Heap_Extend+0x204> <== 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 ) {
30010b8c: e35b0000 cmp fp, #0 <== 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;
30010b90: 1062b00b rsbne fp, r2, fp <== NOT EXECUTED 30010b94: 138bb001 orrne fp, fp, #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 =
30010b98: 1582b004 strne fp, [r2, #4] <== NOT EXECUTED 30010b9c: eaffffbf b 30010aa0 <_Heap_Extend+0x19c> <== NOT EXECUTED
30010898 <_Heap_Free>:
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
30010898: e2513000 subs r3, r1, #0
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
3001089c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
300108a0: e1a04000 mov r4, r0
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
300108a4: 03a00001 moveq r0, #1
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
300108a8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
300108ac: e1a00003 mov r0, r3 300108b0: e5941010 ldr r1, [r4, #16] 300108b4: e2435008 sub r5, r3, #8 300108b8: eb002c21 bl 3001b944 <__umodsi3>
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
300108bc: e5942020 ldr r2, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
300108c0: e0605005 rsb r5, r0, r5
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;
300108c4: e1550002 cmp r5, r2
300108c8: 3a00002f bcc 3001098c <_Heap_Free+0xf4>
300108cc: e5941024 ldr r1, [r4, #36] ; 0x24 300108d0: e1550001 cmp r5, r1
300108d4: 8a00002c bhi 3001098c <_Heap_Free+0xf4>
- 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;
300108d8: e595c004 ldr ip, [r5, #4] 300108dc: e3cc6001 bic r6, ip, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
300108e0: e0853006 add r3, r5, 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;
300108e4: e1520003 cmp r2, r3
300108e8: 8a000027 bhi 3001098c <_Heap_Free+0xf4>
300108ec: e1510003 cmp r1, r3
300108f0: 3a000027 bcc 30010994 <_Heap_Free+0xfc>
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;
300108f4: e5937004 ldr r7, [r3, #4]
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
300108f8: e2170001 ands r0, r7, #1
300108fc: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
30010900: e1510003 cmp r1, r3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
30010904: e3c77001 bic r7, r7, #1 30010908: 03a08000 moveq r8, #0
3001090c: 0a000004 beq 30010924 <_Heap_Free+0x8c>
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;
30010910: e0830007 add r0, r3, r7 30010914: e5900004 ldr r0, [r0, #4]
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
30010918: e3100001 tst r0, #1 3001091c: 13a08000 movne r8, #0 30010920: 03a08001 moveq r8, #1
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
30010924: e21c0001 ands r0, ip, #1
30010928: 1a00001b bne 3001099c <_Heap_Free+0x104>
uintptr_t const prev_size = block->prev_size;
3001092c: e595c000 ldr ip, [r5]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30010930: e06ca005 rsb sl, ip, r5
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;
30010934: e152000a cmp r2, sl
30010938: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
3001093c: e151000a cmp r1, sl
30010940: 38bd85f0 popcc {r4, r5, r6, r7, r8, sl, pc}
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;
30010944: e59a0004 ldr r0, [sl, #4]
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
30010948: e2100001 ands r0, r0, #1
3001094c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
30010950: e3580000 cmp r8, #0
30010954: 0a000039 beq 30010a40 <_Heap_Free+0x1a8>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
30010958: e5940038 ldr r0, [r4, #56] ; 0x38
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
3001095c: e0867007 add r7, r6, r7
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
30010960: e5932008 ldr r2, [r3, #8] 30010964: e087c00c add ip, r7, ip
Heap_Block *prev = block->prev;
30010968: e593300c ldr r3, [r3, #12]
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
3001096c: e2400001 sub r0, r0, #1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
30010970: e38c1001 orr r1, ip, #1
prev->next = next;
30010974: e5832008 str r2, [r3, #8]
next->prev = prev;
30010978: e582300c str r3, [r2, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
3001097c: e5840038 str r0, [r4, #56] ; 0x38
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
30010980: e58a1004 str r1, [sl, #4]
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
30010984: e78ac00c str ip, [sl, ip] 30010988: ea00000f b 300109cc <_Heap_Free+0x134>
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
return false;
3001098c: e3a00000 mov r0, #0
30010990: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30010994: e3a00000 mov r0, #0 <== NOT EXECUTED
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
30010998: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
3001099c: e3580000 cmp r8, #0
300109a0: 0a000014 beq 300109f8 <_Heap_Free+0x160>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
300109a4: e5932008 ldr r2, [r3, #8]
uintptr_t const size = block_size + next_block_size;
300109a8: e0877006 add r7, r7, r6
Heap_Block *prev = old_block->prev;
300109ac: e593300c ldr r3, [r3, #12]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
300109b0: e3871001 orr r1, r7, #1
new_block->next = next;
300109b4: e5852008 str r2, [r5, #8]
new_block->prev = prev;
300109b8: e585300c str r3, [r5, #12]
next->prev = new_block;
prev->next = new_block;
300109bc: e5835008 str r5, [r3, #8]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
300109c0: e582500c str r5, [r2, #12] 300109c4: e5851004 str r1, [r5, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
300109c8: e7857007 str r7, [r5, r7]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
300109cc: e5942040 ldr r2, [r4, #64] ; 0x40
++stats->frees;
300109d0: e5943050 ldr r3, [r4, #80] ; 0x50
stats->free_size += block_size;
300109d4: e5941030 ldr r1, [r4, #48] ; 0x30
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
300109d8: e2422001 sub r2, r2, #1
++stats->frees;
300109dc: e2833001 add r3, r3, #1
stats->free_size += block_size;
300109e0: e0816006 add r6, r1, r6
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
300109e4: e5842040 str r2, [r4, #64] ; 0x40
++stats->frees;
300109e8: e5843050 str r3, [r4, #80] ; 0x50
stats->free_size += block_size;
300109ec: e5846030 str r6, [r4, #48] ; 0x30
return( true );
300109f0: e3a00001 mov r0, #1
300109f4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
300109f8: e3862001 orr r2, r6, #1 300109fc: e5852004 str r2, [r5, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
30010a00: e5942038 ldr r2, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
30010a04: e594c03c ldr ip, [r4, #60] ; 0x3c
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
30010a08: e5930004 ldr r0, [r3, #4]
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
30010a0c: e5941008 ldr r1, [r4, #8]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
30010a10: e2822001 add r2, r2, #1
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
30010a14: e3c00001 bic r0, r0, #1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
30010a18: e152000c cmp r2, ip
new_block->next = next;
30010a1c: e5851008 str r1, [r5, #8]
new_block->prev = block_before;
30010a20: e585400c str r4, [r5, #12]
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
30010a24: e5830004 str r0, [r3, #4]
block_before->next = new_block; next->prev = new_block;
30010a28: e581500c str r5, [r1, #12]
next_block->prev_size = block_size;
30010a2c: e7856006 str r6, [r5, r6]
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
30010a30: e5845008 str r5, [r4, #8]
/* Statistics */
++stats->free_blocks;
30010a34: e5842038 str r2, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
stats->max_free_blocks = stats->free_blocks;
30010a38: 8584203c strhi r2, [r4, #60] ; 0x3c 30010a3c: eaffffe2 b 300109cc <_Heap_Free+0x134>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
30010a40: e086c00c add ip, r6, ip
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
30010a44: e38c2001 orr r2, ip, #1 30010a48: e58a2004 str r2, [sl, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
30010a4c: e5932004 ldr r2, [r3, #4]
next_block->prev_size = size;
30010a50: e785c006 str ip, [r5, r6]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
30010a54: e3c22001 bic r2, r2, #1 30010a58: e5832004 str r2, [r3, #4] 30010a5c: eaffffda b 300109cc <_Heap_Free+0x134>
300108b0 <_Heap_Free_block>:
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *first_free;
/* Statistics */
++stats->used_blocks;
300108b0: e5902040 ldr r2, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
300108b4: e5903050 ldr r3, [r0, #80] ; 0x50 <== NOT EXECUTED
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *first_free;
/* Statistics */
++stats->used_blocks;
300108b8: e2822001 add r2, r2, #1 <== NOT EXECUTED
--stats->frees;
300108bc: e2433001 sub r3, r3, #1 <== 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 )
{
300108c0: e92d4010 push {r4, lr} <== 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 ) );
300108c4: e2811008 add r1, r1, #8 <== 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 )
{
300108c8: e1a04000 mov r4, r0 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats;
Heap_Block *first_free;
/* Statistics */
++stats->used_blocks;
300108cc: e5802040 str r2, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
300108d0: 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 ) );
300108d4: eb0000b1 bl 30010ba0 <_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;
300108d8: 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;
300108dc: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
Heap_Block *prev = block->prev;
300108e0: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
prev->next = next;
next->prev = prev;
300108e4: e580100c str r1, [r0, #12] <== 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;
300108e8: e594200c ldr r2, [r4, #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;
300108ec: e5810008 str r0, [r1, #8] <== NOT EXECUTED
)
{
Heap_Block *prev = block_next->prev;
new_block->next = block_next;
new_block->prev = prev;
300108f0: e583200c str r2, [r3, #12] <== NOT EXECUTED
Heap_Block *new_block
)
{
Heap_Block *prev = block_next->prev;
new_block->next = block_next;
300108f4: e5834008 str r4, [r3, #8] <== NOT EXECUTED
new_block->prev = prev; prev->next = new_block; block_next->prev = new_block;
300108f8: e584300c str r3, [r4, #12] <== NOT EXECUTED
{
Heap_Block *prev = block_next->prev;
new_block->next = block_next;
new_block->prev = prev;
prev->next = new_block;
300108fc: e5823008 str r3, [r2, #8] <== 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 ); }
30010900: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000dbfc <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
3000dbfc: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
3000dc00: e2528000 subs r8, r2, #0
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
3000dc04: e1a04000 mov r4, r0
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); Heap_Block *allocated_blocks = NULL;
3000dc08: 01a05008 moveq r5, r8
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
3000dc0c: 0a000012 beq 3000dc5c <_Heap_Greedy_allocate+0x60>
3000dc10: e3a06000 mov r6, #0 3000dc14: e1a07001 mov r7, r1
const uintptr_t *block_sizes,
size_t block_count
)
{
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *allocated_blocks = NULL;
3000dc18: e1a05006 mov r5, r6
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
3000dc1c: e3a02000 mov r2, #0 3000dc20: e4971004 ldr r1, [r7], #4 3000dc24: e1a03002 mov r3, r2 3000dc28: e1a00004 mov r0, r4 3000dc2c: eb001ea7 bl 300156d0 <_Heap_Allocate_aligned_with_boundary>
size_t i;
for (i = 0; i < block_count; ++i) {
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
3000dc30: e250a000 subs sl, r0, #0
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
3000dc34: e2866001 add r6, r6, #1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000dc38: e24aa008 sub sl, sl, #8
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
3000dc3c: 0a000004 beq 3000dc54 <_Heap_Greedy_allocate+0x58>
3000dc40: e5941010 ldr r1, [r4, #16] 3000dc44: eb004b28 bl 300208ec <__umodsi3>
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000dc48: e060000a rsb r0, r0, sl
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
3000dc4c: e5805008 str r5, [r0, #8] 3000dc50: e1a05000 mov r5, r0
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
3000dc54: e1560008 cmp r6, r8
3000dc58: 1affffef bne 3000dc1c <_Heap_Greedy_allocate+0x20>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
3000dc5c: e5946008 ldr r6, [r4, #8]
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
3000dc60: e1540006 cmp r4, r6 3000dc64: 13a07000 movne r7, #0
3000dc68: 1a000001 bne 3000dc74 <_Heap_Greedy_allocate+0x78>
3000dc6c: ea000018 b 3000dcd4 <_Heap_Greedy_allocate+0xd8> <== NOT EXECUTED
3000dc70: e1a06003 mov r6, r3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000dc74: e5963004 ldr r3, [r6, #4]
_Heap_Block_allocate(
3000dc78: e1a01006 mov r1, r6 3000dc7c: e3c33001 bic r3, r3, #1 3000dc80: e2433008 sub r3, r3, #8 3000dc84: e2862008 add r2, r6, #8 3000dc88: e1a00004 mov r0, r4 3000dc8c: eb0000cd bl 3000dfc8 <_Heap_Block_allocate>
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
3000dc90: e5867008 str r7, [r6, #8]
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
3000dc94: e5943008 ldr r3, [r4, #8]
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
3000dc98: e1a07006 mov r7, r6 3000dc9c: e1540003 cmp r4, r3
3000dca0: 1afffff2 bne 3000dc70 <_Heap_Greedy_allocate+0x74>
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
3000dca4: e3550000 cmp r5, #0
3000dca8: 1a000001 bne 3000dcb4 <_Heap_Greedy_allocate+0xb8>
3000dcac: ea000006 b 3000dccc <_Heap_Greedy_allocate+0xd0>
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
3000dcb0: e1a05007 mov r5, r7 <== NOT EXECUTED
3000dcb4: e1a01005 mov r1, r5 3000dcb8: e5b17008 ldr r7, [r1, #8]!
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
3000dcbc: e1a00004 mov r0, r4 3000dcc0: eb001f16 bl 30015920 <_Heap_Free>
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
3000dcc4: e3570000 cmp r7, #0
3000dcc8: 1afffff8 bne 3000dcb0 <_Heap_Greedy_allocate+0xb4>
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
return blocks;
}
3000dccc: e1a00006 mov r0, r6
3000dcd0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
3000dcd4: e3a06000 mov r6, #0 <== NOT EXECUTED 3000dcd8: eafffff1 b 3000dca4 <_Heap_Greedy_allocate+0xa8> <== NOT EXECUTED
30010404 <_Heap_No_extend>:
uintptr_t unused_2 __attribute__((unused)),
uintptr_t unused_3 __attribute__((unused))
)
{
return 0;
}
30010404: e3a00000 mov r0, #0 <== NOT EXECUTED 30010408: e12fff1e bx lr <== NOT EXECUTED
30010a60 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
30010a60: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30010a64: e1a04000 mov r4, r0
30010a68: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30010a6c: e1a00001 mov r0, r1 30010a70: e5941010 ldr r1, [r4, #16] 30010a74: e1a07003 mov r7, r3 30010a78: e1a08002 mov r8, r2 30010a7c: eb002bb0 bl 3001b944 <__umodsi3>
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;
30010a80: e5943020 ldr r3, [r4, #32]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30010a84: e2451008 sub r1, r5, #8
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
30010a88: e0601001 rsb r1, r0, r1 30010a8c: 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;
30010a90: e3a02000 mov r2, #0
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;
30010a94: e1530001 cmp r3, r1 30010a98: e5872000 str r2, [r7]
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30010a9c: 83a00002 movhi r0, #2
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;
*new_size = 0;
30010aa0: e5862000 str r2, [r6]
30010aa4: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
30010aa8: e5943024 ldr r3, [r4, #36] ; 0x24
30010aac: e1530001 cmp r3, r1
30010ab0: 3a000036 bcc 30010b90 <_Heap_Resize_block+0x130>
- 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;
30010ab4: e5910004 ldr r0, [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;
30010ab8: e2652004 rsb r2, r5, #4 30010abc: e3c00001 bic r0, r0, #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;
30010ac0: e0813000 add r3, r1, r0 30010ac4: e593c004 ldr ip, [r3, #4]
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
30010ac8: e0822003 add r2, r2, r3 30010acc: e3ccc001 bic ip, ip, #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;
30010ad0: e083a00c add sl, r3, ip 30010ad4: 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;
30010ad8: e5872000 str r2, [r7]
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
30010adc: e31a0001 tst sl, #1 30010ae0: 13a07000 movne r7, #0 30010ae4: 03a07001 moveq r7, #1
if ( next_block_is_free ) {
30010ae8: e3570000 cmp r7, #0
block_size += next_block_size;
alloc_size += next_block_size;
30010aec: 1082200c addne r2, r2, ip
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
if ( next_block_is_free ) {
block_size += next_block_size;
30010af0: 1080000c addne r0, r0, ip
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
30010af4: e1580002 cmp r8, r2
return HEAP_RESIZE_UNSATISFIED;
30010af8: 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 ) {
30010afc: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
30010b00: e3570000 cmp r7, #0
30010b04: 0a000011 beq 30010b50 <_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;
30010b08: e591e004 ldr lr, [r1, #4] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30010b0c: e0802001 add r2, r0, 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;
30010b10: e20ee001 and lr, lr, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
30010b14: e180000e orr r0, r0, lr <== NOT EXECUTED 30010b18: e5810004 str r0, [r1, #4] <== NOT EXECUTED
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
/* Statistics */
--stats->free_blocks;
30010b1c: e594e038 ldr lr, [r4, #56] ; 0x38 <== NOT EXECUTED
stats->free_size -= next_block_size;
30010b20: e594a030 ldr sl, [r4, #48] ; 0x30 <== 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;
30010b24: e5927004 ldr r7, [r2, #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;
30010b28: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
Heap_Block *prev = block->prev;
30010b2c: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 30010b30: e3877001 orr r7, r7, #1 <== NOT EXECUTED
/* Statistics */
--stats->free_blocks;
30010b34: e24ee001 sub lr, lr, #1 <== NOT EXECUTED
stats->free_size -= next_block_size;
30010b38: e06cc00a rsb ip, ip, sl <== NOT EXECUTED
prev->next = next;
30010b3c: e5830008 str r0, [r3, #8] <== NOT EXECUTED
next->prev = prev;
30010b40: e580300c str r3, [r0, #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;
30010b44: e5827004 str r7, [r2, #4] <== NOT EXECUTED
/* Statistics */
--stats->free_blocks;
30010b48: e584e038 str lr, [r4, #56] ; 0x38 <== NOT EXECUTED
stats->free_size -= next_block_size;
30010b4c: e584c030 str ip, [r4, #48] ; 0x30 <== NOT EXECUTED
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
30010b50: e1a02005 mov r2, r5 30010b54: e1a03008 mov r3, r8 30010b58: e1a00004 mov r0, r4 30010b5c: ebffec08 bl 3000bb84 <_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;
30010b60: e5902004 ldr r2, [r0, #4] 30010b64: e1a03000 mov r3, r0 30010b68: e3c22001 bic r2, r2, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30010b6c: e2822004 add r2, r2, #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;
30010b70: e0655002 rsb r5, r5, r2 30010b74: e0833005 add r3, r3, r5 30010b78: e5863000 str r3, [r6]
/* Statistics */
++stats->resizes;
30010b7c: e5943054 ldr r3, [r4, #84] ; 0x54
return HEAP_RESIZE_SUCCESSFUL;
30010b80: 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;
30010b84: e2833001 add r3, r3, #1
30010b88: e5843054 str r3, [r4, #84] ; 0x54
30010b8c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30010b90: e3a00002 mov r0, #2 <== NOT EXECUTED
}
30010b94: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30010b98 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
30010b98: e92d4070 push {r4, r5, r6, lr}
30010b9c: e1a04000 mov r4, r0
30010ba0: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30010ba4: e1a00001 mov r0, r1 30010ba8: e5941010 ldr r1, [r4, #16] 30010bac: e1a06002 mov r6, r2 30010bb0: eb002b63 bl 3001b944 <__umodsi3> 30010bb4: e2452008 sub r2, r5, #8
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
30010bb8: 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);
30010bbc: e0602002 rsb r2, r0, r2
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;
30010bc0: e1520003 cmp r2, r3
30010bc4: 3a000010 bcc 30010c0c <_Heap_Size_of_alloc_area+0x74>
30010bc8: e5941024 ldr r1, [r4, #36] ; 0x24 30010bcc: e1520001 cmp r2, r1
30010bd0: 8a00000d bhi 30010c0c <_Heap_Size_of_alloc_area+0x74>
- 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;
30010bd4: e5920004 ldr r0, [r2, #4] 30010bd8: e3c00001 bic r0, r0, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30010bdc: e0822000 add r2, r2, r0
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;
30010be0: e1530002 cmp r3, r2
30010be4: 8a000008 bhi 30010c0c <_Heap_Size_of_alloc_area+0x74>
30010be8: e1510002 cmp r1, r2
30010bec: 3a000008 bcc 30010c14 <_Heap_Size_of_alloc_area+0x7c>
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;
30010bf0: e5920004 ldr r0, [r2, #4]
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
30010bf4: e2100001 ands r0, r0, #1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
30010bf8: 12655004 rsbne r5, r5, #4 30010bfc: 10852002 addne r2, r5, r2 30010c00: 15862000 strne r2, [r6]
return true;
30010c04: 13a00001 movne r0, #1
30010c08: e8bd8070 pop {r4, r5, r6, pc}
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
30010c0c: e3a00000 mov r0, #0 <== NOT EXECUTED
30010c10: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30010c14: e3a00000 mov r0, #0 <== NOT EXECUTED
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
30010c18: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000c6b4 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000c6b4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
uintptr_t const page_size = heap->page_size;
3000c6b8: e590c010 ldr ip, [r0, #16] <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000c6bc: e24dd038 sub sp, sp, #56 ; 0x38 <== 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() ) ) {
3000c6c0: e59f35b0 ldr r3, [pc, #1456] ; 3000cc78 <_Heap_Walk+0x5c4> <== NOT EXECUTED
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
3000c6c4: e58dc024 str ip, [sp, #36] ; 0x24 <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
3000c6c8: 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;
3000c6cc: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000c6d0: e5933000 ldr r3, [r3] <== 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;
3000c6d4: e59f25a0 ldr r2, [pc, #1440] ; 3000cc7c <_Heap_Walk+0x5c8> <== NOT EXECUTED 3000c6d8: e59f95a0 ldr r9, [pc, #1440] ; 3000cc80 <_Heap_Walk+0x5cc> <== NOT EXECUTED
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000c6dc: e58dc028 str ip, [sp, #40] ; 0x28 <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
3000c6e0: 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;
3000c6e4: 11a09002 movne r9, r2 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000c6e8: e3530003 cmp r3, #3 <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000c6ec: e1a04000 mov r4, r0 <== NOT EXECUTED 3000c6f0: e1a0a001 mov sl, 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;
3000c6f4: e5908020 ldr r8, [r0, #32] <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
3000c6f8: 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() ) ) {
3000c6fc: 0a000002 beq 3000c70c <_Heap_Walk+0x58> <== NOT EXECUTED
}
block = next_block;
} while ( block != first_block );
return true;
3000c700: e3a00001 mov r0, #1 <== NOT EXECUTED
}
3000c704: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
3000c708: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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)(
3000c70c: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED
3000c710: e5900018 ldr r0, [r0, #24] <== NOT EXECUTED
3000c714: e594101c ldr r1, [r4, #28] <== NOT EXECUTED
3000c718: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
3000c71c: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
3000c720: e58dc000 str ip, [sp] <== NOT EXECUTED
3000c724: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED
3000c728: e98d0103 stmib sp, {r0, r1, r8} <== NOT EXECUTED
3000c72c: e58dc010 str ip, [sp, #16] <== NOT EXECUTED
3000c730: e58d2014 str r2, [sp, #20] <== NOT EXECUTED
3000c734: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
3000c738: e1a0000a mov r0, sl <== NOT EXECUTED
3000c73c: e3a01000 mov r1, #0 <== NOT EXECUTED
3000c740: e59f253c ldr r2, [pc, #1340] ; 3000cc84 <_Heap_Walk+0x5d0> <== NOT EXECUTED
3000c744: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
3000c748: e1a0e00f mov lr, pc <== NOT EXECUTED
3000c74c: e12fff19 bx r9 <== NOT EXECUTED
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
3000c750: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c754: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000c758: 0a000026 beq 3000c7f8 <_Heap_Walk+0x144> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
3000c75c: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c760: e21c5007 ands r5, ip, #7 <== NOT EXECUTED 3000c764: 1a00002a bne 3000c814 <_Heap_Walk+0x160> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000c768: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 3000c76c: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c770: ebffe243 bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
3000c774: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000c778: 1a00002d bne 3000c834 <_Heap_Walk+0x180> <== NOT EXECUTED 3000c77c: e2880008 add r0, r8, #8 <== NOT EXECUTED 3000c780: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c784: ebffe23e bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000c788: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000c78c: 1a000030 bne 3000c854 <_Heap_Walk+0x1a0> <== 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;
3000c790: e598b004 ldr fp, [r8, #4] <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
3000c794: e21b5001 ands r5, fp, #1 <== NOT EXECUTED 3000c798: 0a000035 beq 3000c874 <_Heap_Walk+0x1c0> <== 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;
3000c79c: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000c7a0: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 3000c7a4: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000c7a8: e08c3003 add r3, ip, r3 <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000c7ac: e5935004 ldr r5, [r3, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
3000c7b0: e2155001 ands r5, r5, #1 <== NOT EXECUTED 3000c7b4: 0a000008 beq 3000c7dc <_Heap_Walk+0x128> <== NOT EXECUTED
);
return false;
}
if (
3000c7b8: e1580003 cmp r8, r3 <== NOT EXECUTED 3000c7bc: 0a000033 beq 3000c890 <_Heap_Walk+0x1dc> <== NOT EXECUTED
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
3000c7c0: e1a0000a mov r0, sl <== NOT EXECUTED 3000c7c4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c7c8: e59f24b8 ldr r2, [pc, #1208] ; 3000cc88 <_Heap_Walk+0x5d4> <== NOT EXECUTED 3000c7cc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c7d0: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c7d4: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c7d8: eaffffc9 b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
3000c7dc: e1a0000a mov r0, sl <== NOT EXECUTED 3000c7e0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c7e4: e59f24a0 ldr r2, [pc, #1184] ; 3000cc8c <_Heap_Walk+0x5d8> <== NOT EXECUTED 3000c7e8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c7ec: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c7f0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c7f4: eaffffc2 b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
3000c7f8: e1a0000a mov r0, sl <== NOT EXECUTED 3000c7fc: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c800: e59f2488 ldr r2, [pc, #1160] ; 3000cc90 <_Heap_Walk+0x5dc> <== NOT EXECUTED 3000c804: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c808: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c80c: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c810: eaffffbb b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
3000c814: e1a0000a mov r0, sl <== NOT EXECUTED 3000c818: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c81c: e59f2470 ldr r2, [pc, #1136] ; 3000cc94 <_Heap_Walk+0x5e0> <== NOT EXECUTED 3000c820: e1a0300c mov r3, ip <== NOT EXECUTED 3000c824: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c828: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c82c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c830: eaffffb3 b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
3000c834: e1a0000a mov r0, sl <== NOT EXECUTED 3000c838: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c83c: e59f2454 ldr r2, [pc, #1108] ; 3000cc98 <_Heap_Walk+0x5e4> <== NOT EXECUTED 3000c840: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000c844: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c848: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c84c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c850: eaffffab b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
3000c854: e1a0000a mov r0, sl <== NOT EXECUTED 3000c858: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c85c: e59f2438 ldr r2, [pc, #1080] ; 3000cc9c <_Heap_Walk+0x5e8> <== NOT EXECUTED 3000c860: e1a03008 mov r3, r8 <== NOT EXECUTED 3000c864: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c868: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c86c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000c870: eaffffa3 b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
3000c874: e1a0000a mov r0, sl <== NOT EXECUTED 3000c878: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c87c: e59f241c ldr r2, [pc, #1052] ; 3000cca0 <_Heap_Walk+0x5ec> <== NOT EXECUTED 3000c880: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c884: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c888: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c88c: eaffff9c b 3000c704 <_Heap_Walk+0x50> <== 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;
3000c890: e5945008 ldr r5, [r4, #8] <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
3000c894: e5947010 ldr r7, [r4, #16] <== 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 ) {
3000c898: e1540005 cmp r4, r5 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
3000c89c: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000c8a0: 0a00000c beq 3000c8d8 <_Heap_Walk+0x224> <== NOT EXECUTED
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000c8a4: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c8a8: 9a0000a9 bls 3000cb54 <_Heap_Walk+0x4a0> <== NOT EXECUTED
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
3000c8ac: e1a0000a mov r0, sl <== NOT EXECUTED 3000c8b0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c8b4: e59f23e8 ldr r2, [pc, #1000] ; 3000cca4 <_Heap_Walk+0x5f0> <== NOT EXECUTED 3000c8b8: e1a03005 mov r3, r5 <== NOT EXECUTED 3000c8bc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c8c0: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c8c4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c8c8: eaffff8d b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED 3000c8cc: e1a03008 mov r3, r8 <== NOT EXECUTED 3000c8d0: e59db034 ldr fp, [sp, #52] ; 0x34 <== NOT EXECUTED 3000c8d4: e59d8030 ldr r8, [sp, #48] ; 0x30 <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000c8d8: e1a06008 mov r6, r8 <== 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;
3000c8dc: e3cb7001 bic r7, fp, #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);
3000c8e0: e0875006 add r5, r7, r6 <== 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;
3000c8e4: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c8e8: 9a000008 bls 3000c910 <_Heap_Walk+0x25c> <== NOT EXECUTED
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 ) ) {
(*printer)(
3000c8ec: e1a0000a mov r0, sl <== NOT EXECUTED 3000c8f0: e58d5000 str r5, [sp] <== NOT EXECUTED 3000c8f4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c8f8: e59f23a8 ldr r2, [pc, #936] ; 3000cca8 <_Heap_Walk+0x5f4> <== NOT EXECUTED 3000c8fc: e1a03006 mov r3, r6 <== NOT EXECUTED 3000c900: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c904: e12fff19 bx r9 <== NOT EXECUTED
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
3000c908: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c90c: eaffff7c b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED 3000c910: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3000c914: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c918: 3afffff3 bcc 3000c8ec <_Heap_Walk+0x238> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000c91c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c920: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c924: ebffe1d6 bl 30005084 <__umodsi3> <== 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;
3000c928: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000c92c: e056300c subs r3, r6, ip <== NOT EXECUTED 3000c930: 13a03001 movne r3, #1 <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
3000c934: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c938: 0a000001 beq 3000c944 <_Heap_Walk+0x290> <== NOT EXECUTED 3000c93c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c940: 1a000068 bne 3000cae8 <_Heap_Walk+0x434> <== NOT EXECUTED
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
3000c944: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3000c948: e15c0007 cmp ip, r7 <== NOT EXECUTED 3000c94c: 9a000001 bls 3000c958 <_Heap_Walk+0x2a4> <== NOT EXECUTED 3000c950: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c954: 1a00006c bne 3000cb0c <_Heap_Walk+0x458> <== NOT EXECUTED
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
3000c958: e1560005 cmp r6, r5 <== NOT EXECUTED 3000c95c: 3a000001 bcc 3000c968 <_Heap_Walk+0x2b4> <== NOT EXECUTED 3000c960: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c964: 1a000071 bne 3000cb30 <_Heap_Walk+0x47c> <== 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;
3000c968: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 3000c96c: e20bb001 and fp, fp, #1 <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
3000c970: e3130001 tst r3, #1 <== NOT EXECUTED 3000c974: 0a000017 beq 3000c9d8 <_Heap_Walk+0x324> <== NOT EXECUTED
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
3000c978: e35b0000 cmp fp, #0 <== NOT EXECUTED
(*printer)(
3000c97c: e58d7000 str r7, [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) {
3000c980: 0a00000b beq 3000c9b4 <_Heap_Walk+0x300> <== NOT EXECUTED
(*printer)(
3000c984: e1a0000a mov r0, sl <== NOT EXECUTED 3000c988: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c98c: e59f2318 ldr r2, [pc, #792] ; 3000ccac <_Heap_Walk+0x5f8> <== NOT EXECUTED 3000c990: e1a03006 mov r3, r6 <== NOT EXECUTED 3000c994: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c998: e12fff19 bx r9 <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000c99c: e1580005 cmp r8, r5 <== NOT EXECUTED 3000c9a0: 0affff56 beq 3000c700 <_Heap_Walk+0x4c> <== NOT EXECUTED 3000c9a4: e595b004 ldr fp, [r5, #4] <== NOT EXECUTED 3000c9a8: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000c9ac: e1a06005 mov r6, r5 <== NOT EXECUTED 3000c9b0: eaffffc9 b 3000c8dc <_Heap_Walk+0x228> <== NOT EXECUTED
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
3000c9b4: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000c9b8: e1a0000a mov r0, sl <== NOT EXECUTED 3000c9bc: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000c9c0: e1a0100b mov r1, fp <== NOT EXECUTED 3000c9c4: e59f22e4 ldr r2, [pc, #740] ; 3000ccb0 <_Heap_Walk+0x5fc> <== NOT EXECUTED 3000c9c8: e1a03006 mov r3, r6 <== NOT EXECUTED 3000c9cc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c9d0: e12fff19 bx r9 <== NOT EXECUTED 3000c9d4: eafffff0 b 3000c99c <_Heap_Walk+0x2e8> <== 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 ?
3000c9d8: e596200c ldr r2, [r6, #12] <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000c9dc: e5943008 ldr r3, [r4, #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;
3000c9e0: e594100c ldr r1, [r4, #12] <== NOT EXECUTED 3000c9e4: e1530002 cmp r3, r2 <== NOT EXECUTED 3000c9e8: 059f02c4 ldreq r0, [pc, #708] ; 3000ccb4 <_Heap_Walk+0x600><== NOT EXECUTED 3000c9ec: 0a000003 beq 3000ca00 <_Heap_Walk+0x34c> <== NOT EXECUTED
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
3000c9f0: e59f32c0 ldr r3, [pc, #704] ; 3000ccb8 <_Heap_Walk+0x604> <== NOT EXECUTED 3000c9f4: e1540002 cmp r4, r2 <== NOT EXECUTED 3000c9f8: e59f02bc ldr r0, [pc, #700] ; 3000ccbc <_Heap_Walk+0x608> <== NOT EXECUTED 3000c9fc: 11a00003 movne r0, r3 <== NOT EXECUTED
block->next,
block->next == last_free_block ?
3000ca00: e5963008 ldr r3, [r6, #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)(
3000ca04: e1510003 cmp r1, r3 <== NOT EXECUTED 3000ca08: 059f12b0 ldreq r1, [pc, #688] ; 3000ccc0 <_Heap_Walk+0x60c><== NOT EXECUTED 3000ca0c: 0a000003 beq 3000ca20 <_Heap_Walk+0x36c> <== 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)" : "")
3000ca10: e59fc2ac ldr ip, [pc, #684] ; 3000ccc4 <_Heap_Walk+0x610> <== NOT EXECUTED 3000ca14: e1540003 cmp r4, r3 <== NOT EXECUTED 3000ca18: e59f1298 ldr r1, [pc, #664] ; 3000ccb8 <_Heap_Walk+0x604> <== NOT EXECUTED 3000ca1c: 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)(
3000ca20: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000ca24: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000ca28: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000ca2c: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000ca30: e1a03006 mov r3, r6 <== NOT EXECUTED 3000ca34: e58d7000 str r7, [sp] <== NOT EXECUTED 3000ca38: e1a0000a mov r0, sl <== NOT EXECUTED 3000ca3c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000ca40: e59f2280 ldr r2, [pc, #640] ; 3000ccc8 <_Heap_Walk+0x614> <== NOT EXECUTED 3000ca44: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ca48: e12fff19 bx r9 <== NOT EXECUTED
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
3000ca4c: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000ca50: e1570003 cmp r7, r3 <== NOT EXECUTED 3000ca54: 1a000011 bne 3000caa0 <_Heap_Walk+0x3ec> <== NOT EXECUTED
);
return false;
}
if ( !prev_used ) {
3000ca58: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000ca5c: 0a000019 beq 3000cac8 <_Heap_Walk+0x414> <== 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;
3000ca60: e5943008 ldr r3, [r4, #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 ) {
3000ca64: e1540003 cmp r4, r3 <== NOT EXECUTED 3000ca68: 0a000004 beq 3000ca80 <_Heap_Walk+0x3cc> <== NOT EXECUTED
if ( free_block == block ) {
3000ca6c: e1560003 cmp r6, r3 <== NOT EXECUTED 3000ca70: 0affffc9 beq 3000c99c <_Heap_Walk+0x2e8> <== NOT EXECUTED
return true;
}
free_block = free_block->next;
3000ca74: 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 ) {
3000ca78: e1540003 cmp r4, r3 <== NOT EXECUTED 3000ca7c: 1afffffa bne 3000ca6c <_Heap_Walk+0x3b8> <== NOT EXECUTED
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
3000ca80: e1a0000a mov r0, sl <== NOT EXECUTED 3000ca84: e3a01001 mov r1, #1 <== NOT EXECUTED 3000ca88: e59f223c ldr r2, [pc, #572] ; 3000cccc <_Heap_Walk+0x618> <== NOT EXECUTED 3000ca8c: e1a03006 mov r3, r6 <== NOT EXECUTED 3000ca90: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ca94: e12fff19 bx r9 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000ca98: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ca9c: eaffff18 b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
3000caa0: e98d0028 stmib sp, {r3, r5} <== NOT EXECUTED
3000caa4: e1a0000a mov r0, sl <== NOT EXECUTED
3000caa8: e58d7000 str r7, [sp] <== NOT EXECUTED
3000caac: e3a01001 mov r1, #1 <== NOT EXECUTED
3000cab0: e59f2218 ldr r2, [pc, #536] ; 3000ccd0 <_Heap_Walk+0x61c> <== NOT EXECUTED
3000cab4: e1a03006 mov r3, r6 <== NOT EXECUTED
3000cab8: e1a0e00f mov lr, pc <== NOT EXECUTED
3000cabc: e12fff19 bx r9 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000cac0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cac4: eaffff0e b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !prev_used ) {
(*printer)(
3000cac8: e1a0000a mov r0, sl <== NOT EXECUTED 3000cacc: e3a01001 mov r1, #1 <== NOT EXECUTED 3000cad0: e59f21fc ldr r2, [pc, #508] ; 3000ccd4 <_Heap_Walk+0x620> <== NOT EXECUTED 3000cad4: e1a03006 mov r3, r6 <== NOT EXECUTED 3000cad8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cadc: e12fff19 bx r9 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000cae0: e1a0000b mov r0, fp <== NOT EXECUTED 3000cae4: eaffff06 b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
3000cae8: e1a0000a mov r0, sl <== NOT EXECUTED 3000caec: e58d7000 str r7, [sp] <== NOT EXECUTED 3000caf0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000caf4: e59f21dc ldr r2, [pc, #476] ; 3000ccd8 <_Heap_Walk+0x624> <== NOT EXECUTED 3000caf8: e1a03006 mov r3, r6 <== NOT EXECUTED 3000cafc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cb00: e12fff19 bx r9 <== NOT EXECUTED
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
3000cb04: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cb08: eafffefd b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
3000cb0c: e1a0000a mov r0, sl <== NOT EXECUTED
3000cb10: e88d1080 stm sp, {r7, ip} <== NOT EXECUTED
3000cb14: e3a01001 mov r1, #1 <== NOT EXECUTED
3000cb18: e59f21bc ldr r2, [pc, #444] ; 3000ccdc <_Heap_Walk+0x628> <== NOT EXECUTED
3000cb1c: e1a03006 mov r3, r6 <== NOT EXECUTED
3000cb20: e1a0e00f mov lr, pc <== NOT EXECUTED
3000cb24: e12fff19 bx r9 <== NOT EXECUTED
block,
block_size,
min_block_size
);
return false;
3000cb28: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cb2c: eafffef4 b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
3000cb30: e1a0000a mov r0, sl <== NOT EXECUTED 3000cb34: e58d5000 str r5, [sp] <== NOT EXECUTED 3000cb38: e3a01001 mov r1, #1 <== NOT EXECUTED 3000cb3c: e59f219c ldr r2, [pc, #412] ; 3000cce0 <_Heap_Walk+0x62c> <== NOT EXECUTED 3000cb40: e1a03006 mov r3, r6 <== NOT EXECUTED 3000cb44: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cb48: e12fff19 bx r9 <== NOT EXECUTED
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
3000cb4c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cb50: eafffeeb b 3000c704 <_Heap_Walk+0x50> <== 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;
3000cb54: e594c024 ldr ip, [r4, #36] ; 0x24 <== NOT EXECUTED 3000cb58: e15c0005 cmp ip, r5 <== NOT EXECUTED 3000cb5c: 3affff52 bcc 3000c8ac <_Heap_Walk+0x1f8> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000cb60: e2850008 add r0, r5, #8 <== NOT EXECUTED 3000cb64: e1a01007 mov r1, r7 <== NOT EXECUTED 3000cb68: e58d3020 str r3, [sp, #32] <== NOT EXECUTED 3000cb6c: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000cb70: ebffe143 bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000cb74: e3500000 cmp r0, #0 <== NOT EXECUTED 3000cb78: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3000cb7c: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 3000cb80: 1a000034 bne 3000cc58 <_Heap_Walk+0x5a4> <== 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;
3000cb84: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED 3000cb88: e3c22001 bic r2, r2, #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;
3000cb8c: e0852002 add r2, r5, r2 <== NOT EXECUTED 3000cb90: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000cb94: e3120001 tst r2, #1 <== NOT EXECUTED 3000cb98: 1a000026 bne 3000cc38 <_Heap_Walk+0x584> <== NOT EXECUTED 3000cb9c: e58d8030 str r8, [sp, #48] ; 0x30 <== NOT EXECUTED 3000cba0: e58db034 str fp, [sp, #52] ; 0x34 <== NOT EXECUTED 3000cba4: e1a01004 mov r1, r4 <== NOT EXECUTED 3000cba8: e1a06005 mov r6, r5 <== NOT EXECUTED 3000cbac: e1a08003 mov r8, r3 <== NOT EXECUTED 3000cbb0: e1a0b00c mov fp, ip <== NOT EXECUTED 3000cbb4: ea000013 b 3000cc08 <_Heap_Walk+0x554> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
3000cbb8: e5955008 ldr r5, [r5, #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 ) {
3000cbbc: e1540005 cmp r4, r5 <== NOT EXECUTED 3000cbc0: 0affff41 beq 3000c8cc <_Heap_Walk+0x218> <== 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;
3000cbc4: e1550008 cmp r5, r8 <== NOT EXECUTED 3000cbc8: 3affff37 bcc 3000c8ac <_Heap_Walk+0x1f8> <== NOT EXECUTED 3000cbcc: e155000b cmp r5, fp <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000cbd0: e2850008 add r0, r5, #8 <== NOT EXECUTED 3000cbd4: e1a01007 mov r1, r7 <== 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;
3000cbd8: 8affff33 bhi 3000c8ac <_Heap_Walk+0x1f8> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000cbdc: ebffe128 bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000cbe0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000cbe4: 1a00001b bne 3000cc58 <_Heap_Walk+0x5a4> <== 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;
3000cbe8: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000cbec: e1a01006 mov r1, r6 <== NOT EXECUTED 3000cbf0: 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;
3000cbf4: e0833005 add r3, r3, r5 <== NOT EXECUTED 3000cbf8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000cbfc: e1a06005 mov r6, r5 <== NOT EXECUTED 3000cc00: e3130001 tst r3, #1 <== NOT EXECUTED 3000cc04: 1a00000b bne 3000cc38 <_Heap_Walk+0x584> <== NOT EXECUTED
);
return false;
}
if ( free_block->prev != prev_block ) {
3000cc08: e595200c ldr r2, [r5, #12] <== NOT EXECUTED 3000cc0c: e1520001 cmp r2, r1 <== NOT EXECUTED 3000cc10: 0affffe8 beq 3000cbb8 <_Heap_Walk+0x504> <== NOT EXECUTED
(*printer)(
3000cc14: e58d2000 str r2, [sp] <== NOT EXECUTED 3000cc18: e1a0000a mov r0, sl <== NOT EXECUTED 3000cc1c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000cc20: e59f20bc ldr r2, [pc, #188] ; 3000cce4 <_Heap_Walk+0x630> <== NOT EXECUTED 3000cc24: e1a03005 mov r3, r5 <== NOT EXECUTED 3000cc28: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cc2c: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000cc30: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cc34: eafffeb2 b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
3000cc38: e1a0000a mov r0, sl <== NOT EXECUTED 3000cc3c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000cc40: e59f20a0 ldr r2, [pc, #160] ; 3000cce8 <_Heap_Walk+0x634> <== NOT EXECUTED 3000cc44: e1a03005 mov r3, r5 <== NOT EXECUTED 3000cc48: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cc4c: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000cc50: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cc54: eafffeaa b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
3000cc58: e1a0000a mov r0, sl <== NOT EXECUTED 3000cc5c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000cc60: e59f2084 ldr r2, [pc, #132] ; 3000ccec <_Heap_Walk+0x638> <== NOT EXECUTED 3000cc64: e1a03005 mov r3, r5 <== NOT EXECUTED 3000cc68: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cc6c: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000cc70: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cc74: eafffea2 b 3000c704 <_Heap_Walk+0x50> <== NOT EXECUTED
3000c668 <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000c668: e92d000c push {r2, r3} <== NOT EXECUTED
3000c66c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
va_list ap;
if ( error ) {
3000c670: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
{
/* Do nothing */
}
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000c674: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000c678: e1a01000 mov r1, r0 <== NOT EXECUTED
va_list ap;
if ( error ) {
printk( "FAIL[%d]: ", source );
3000c67c: 159f0028 ldrne r0, [pc, #40] ; 3000c6ac <_Heap_Walk_print+0x44><== NOT EXECUTED
} else {
printk( "PASS[%d]: ", source );
3000c680: 059f0028 ldreq r0, [pc, #40] ; 3000c6b0 <_Heap_Walk_print+0x48><== NOT EXECUTED 3000c684: ebffed26 bl 30007b24 <printk> <== NOT EXECUTED
}
va_start( ap, fmt );
3000c688: e28d300c add r3, sp, #12 <== NOT EXECUTED
vprintk( fmt, ap );
3000c68c: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3000c690: e1a01003 mov r1, r3 <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
3000c694: e58d3000 str r3, [sp] <== NOT EXECUTED
vprintk( fmt, ap );
3000c698: ebfff774 bl 3000a470 <vprintk> <== NOT EXECUTED
va_end( ap ); }
3000c69c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c6a0: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
3000c6a4: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000c6a8: e12fff1e bx lr <== NOT EXECUTED
3000c65c <_Heap_Walk_print_nothing>:
int source,
bool error,
const char *fmt,
...
)
{
3000c65c: e92d000c push {r2, r3} <== NOT EXECUTED
/* Do nothing */ }
3000c660: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000c664: e12fff1e bx lr <== NOT EXECUTED
3000bcc4 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000bcc4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3000bcc8: e24dd00c sub sp, sp, #12
3000bccc: e1a04000 mov r4, r0
3000bcd0: e20160ff and r6, r1, #255 ; 0xff
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
3000bcd4: e1a0000d mov r0, sp 3000bcd8: e59f1040 ldr r1, [pc, #64] ; 3000bd20 <_Internal_error_Occurred+0x5c> 3000bcdc: e1a05002 mov r5, r2
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
3000bce0: e58d2008 str r2, [sp, #8] 3000bce4: e58d4000 str r4, [sp] 3000bce8: e5cd6004 strb r6, [sp, #4]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
3000bcec: eb0007dc bl 3000dc64 <_User_extensions_Iterate>
_User_extensions_Fatal( the_source, is_internal, the_error );
_Internal_errors_What_happened.the_source = the_source;
3000bcf0: e59f302c ldr r3, [pc, #44] ; 3000bd24 <_Internal_error_Occurred+0x60><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
3000bcf4: e3a02005 mov r2, #5 <== NOT EXECUTED 3000bcf8: e5834000 str r4, [r3] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
3000bcfc: e5c36004 strb r6, [r3, #4] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
3000bd00: e5835008 str r5, [r3, #8] <== NOT EXECUTED 3000bd04: e59f301c ldr r3, [pc, #28] ; 3000bd28 <_Internal_error_Occurred+0x64><== NOT EXECUTED 3000bd08: e5832000 str r2, [r3] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000bd0c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000bd10: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000bd14: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
3000bd18: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bd1c: eafffffe b 3000bd1c <_Internal_error_Occurred+0x58> <== NOT EXECUTED
3000bde0 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000bde0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000bde4: e5904034 ldr r4, [r0, #52] ; 0x34
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000bde8: e24dd014 sub sp, sp, #20
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000bdec: e3540000 cmp r4, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000bdf0: e1a05000 mov r5, r0
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000bdf4: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000bdf8: e1d081b0 ldrh r8, [r0, #16]
3000bdfc: 0a0000a0 beq 3000c084 <_Objects_Extend_information+0x2a4>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
3000be00: e1d0a1b4 ldrh sl, [r0, #20] 3000be04: e1a00008 mov r0, r8 3000be08: e1a0100a mov r1, sl 3000be0c: eb003e86 bl 3001b82c <__aeabi_uidiv> 3000be10: e1a0b800 lsl fp, r0, #16
for ( ; block < block_count; block++ ) {
3000be14: e1b0b82b lsrs fp, fp, #16
3000be18: 0a0000a1 beq 3000c0a4 <_Objects_Extend_information+0x2c4>
if ( information->object_blocks[ block ] == NULL ) {
3000be1c: e5949000 ldr r9, [r4] 3000be20: e1a0200a mov r2, sl 3000be24: e3590000 cmp r9, #0 3000be28: 11a03004 movne r3, r4
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000be2c: 11a06007 movne r6, r7
index_base = minimum_index; block = 0;
3000be30: 13a04000 movne r4, #0
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000be34: 01a06007 moveq r6, r7
index_base = minimum_index; block = 0;
3000be38: 01a04009 moveq r4, r9
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
3000be3c: 1a000003 bne 3000be50 <_Objects_Extend_information+0x70>
3000be40: ea000007 b 3000be64 <_Objects_Extend_information+0x84> <== NOT EXECUTED
3000be44: e5b39004 ldr r9, [r3, #4]! 3000be48: e3590000 cmp r9, #0
3000be4c: 0a000004 beq 3000be64 <_Objects_Extend_information+0x84>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
3000be50: e2844001 add r4, r4, #1 3000be54: e15b0004 cmp fp, r4
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
3000be58: e086600a add r6, r6, sl
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
3000be5c: 8afffff8 bhi 3000be44 <_Objects_Extend_information+0x64>
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
3000be60: e3a09001 mov r9, #1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
3000be64: e0888002 add r8, r8, r2
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
3000be68: e3580801 cmp r8, #65536 ; 0x10000
3000be6c: 2a000063 bcs 3000c000 <_Objects_Extend_information+0x220>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
3000be70: e5d53012 ldrb r3, [r5, #18]
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
3000be74: e5950018 ldr r0, [r5, #24]
if ( information->auto_extend ) {
3000be78: e3530000 cmp r3, #0
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
3000be7c: e0000092 mul r0, r2, r0
if ( information->auto_extend ) {
3000be80: 1a000060 bne 3000c008 <_Objects_Extend_information+0x228>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
3000be84: eb0008d1 bl 3000e1d0 <_Workspace_Allocate_or_fatal_error> 3000be88: e58d0004 str r0, [sp, #4]
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
3000be8c: e3590000 cmp r9, #0
3000be90: 0a000039 beq 3000bf7c <_Objects_Extend_information+0x19c>
*/
/*
* Up the block count and maximum
*/
block_count++;
3000be94: e28b9001 add r9, fp, #1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
3000be98: e0890089 add r0, r9, r9, lsl #1
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
3000be9c: e5d53012 ldrb r3, [r5, #18]
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
3000bea0: e0880000 add r0, r8, r0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
3000bea4: e0800007 add r0, r0, r7
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
3000bea8: e3530000 cmp r3, #0
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
3000beac: e1a00100 lsl r0, r0, #2
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
3000beb0: 0a000059 beq 3000c01c <_Objects_Extend_information+0x23c>
object_blocks = _Workspace_Allocate( block_size );
3000beb4: eb0008bb bl 3000e1a8 <_Workspace_Allocate>
if ( !object_blocks ) {
3000beb8: e250a000 subs sl, r0, #0
3000bebc: 0a000075 beq 3000c098 <_Objects_Extend_information+0x2b8>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
3000bec0: e1d521b0 ldrh r2, [r5, #16]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
3000bec4: e08a3109 add r3, sl, r9, lsl #2 3000bec8: e1570002 cmp r7, r2 3000becc: e08a9189 add r9, sl, r9, lsl #3
3000bed0: 3a000058 bcc 3000c038 <_Objects_Extend_information+0x258>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
3000bed4: e3570000 cmp r7, #0 3000bed8: 13a02000 movne r2, #0 3000bedc: 11a01009 movne r1, r9
local_table[ index ] = NULL;
3000bee0: 11a00002 movne r0, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
3000bee4: 0a000003 beq 3000bef8 <_Objects_Extend_information+0x118>
3000bee8: e2822001 add r2, r2, #1 3000beec: e1570002 cmp r7, r2
local_table[ index ] = NULL;
3000bef0: e4810004 str r0, [r1], #4
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
3000bef4: 8afffffb bhi 3000bee8 <_Objects_Extend_information+0x108>
3000bef8: e1a0b10b lsl fp, fp, #2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
3000befc: e1d501b4 ldrh r0, [r5, #20]
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
3000bf00: e3a0c000 mov ip, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
3000bf04: e0860000 add r0, r6, r0
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
3000bf08: e1560000 cmp r6, r0
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
3000bf0c: e78ac00b str ip, [sl, fp]
inactive_per_block[block_count] = 0;
3000bf10: e783c00b str ip, [r3, fp]
for ( index=index_base ;
3000bf14: 2a000005 bcs 3000bf30 <_Objects_Extend_information+0x150>
3000bf18: e0891106 add r1, r9, r6, lsl #2
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
3000bf1c: e1a02006 mov r2, r6
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
3000bf20: e2822001 add r2, r2, #1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
3000bf24: e1500002 cmp r0, r2
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
3000bf28: e481c004 str ip, [r1], #4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
3000bf2c: 8afffffb bhi 3000bf20 <_Objects_Extend_information+0x140>
3000bf30: e10f2000 mrs r2, CPSR 3000bf34: e3821080 orr r1, r2, #128 ; 0x80 3000bf38: e129f001 msr CPSR_fc, r1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000bf3c: e5951000 ldr r1, [r5]
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
3000bf40: e1d500b4 ldrh r0, [r5, #4] 3000bf44: e1a01c01 lsl r1, r1, #24
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
3000bf48: e1a08808 lsl r8, r8, #16 3000bf4c: e3811801 orr r1, r1, #65536 ; 0x10000 3000bf50: e1a08828 lsr r8, r8, #16
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000bf54: e1811d80 orr r1, r1, r0, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000bf58: e1811008 orr r1, r1, r8
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
3000bf5c: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
3000bf60: e5853030 str r3, [r5, #48] ; 0x30
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
3000bf64: e585a034 str sl, [r5, #52] ; 0x34
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
3000bf68: e585901c str r9, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
3000bf6c: e1c581b0 strh r8, [r5, #16]
information->maximum_id = _Objects_Build_id(
3000bf70: e585100c str r1, [r5, #12]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bf74: e129f002 msr CPSR_fc, r2
information->maximum
);
_ISR_Enable( level );
_Workspace_Free( old_tables );
3000bf78: eb000890 bl 3000e1c0 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000bf7c: e5953034 ldr r3, [r5, #52] ; 0x34 3000bf80: e59d2004 ldr r2, [sp, #4]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
3000bf84: e28d0008 add r0, sp, #8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000bf88: e7832104 str r2, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
3000bf8c: e5953034 ldr r3, [r5, #52] ; 0x34 3000bf90: e1d521b4 ldrh r2, [r5, #20] 3000bf94: e7931104 ldr r1, [r3, r4, lsl #2] 3000bf98: e5953018 ldr r3, [r5, #24]
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000bf9c: e1a04104 lsl r4, r4, #2
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
3000bfa0: ebfffcf6 bl 3000b380 <_Chain_Initialize>
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
3000bfa4: e2857020 add r7, r5, #32
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
3000bfa8: ea000008 b 3000bfd0 <_Objects_Extend_information+0x1f0> 3000bfac: e5952000 ldr r2, [r5]
the_object->id = _Objects_Build_id(
3000bfb0: e1d5c0b4 ldrh ip, [r5, #4] 3000bfb4: e1a02c02 lsl r2, r2, #24 3000bfb8: e3822801 orr r2, r2, #65536 ; 0x10000
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000bfbc: e1822d8c orr r2, r2, ip, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000bfc0: e1822006 orr r2, r2, r6 3000bfc4: e5832008 str r2, [r3, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
3000bfc8: ebfffcd4 bl 3000b320 <_Chain_Append>
index++;
3000bfcc: e2866001 add r6, r6, #1
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
3000bfd0: e28d0008 add r0, sp, #8 3000bfd4: ebfffcdc bl 3000b34c <_Chain_Get> 3000bfd8: e2503000 subs r3, r0, #0
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
3000bfdc: e1a01003 mov r1, r3 3000bfe0: e1a00007 mov r0, r7
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
3000bfe4: 1afffff0 bne 3000bfac <_Objects_Extend_information+0x1cc>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
3000bfe8: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
3000bfec: e1d531b4 ldrh r3, [r5, #20] 3000bff0: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
3000bff4: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
3000bff8: e7813004 str r3, [r1, r4]
information->inactive =
3000bffc: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
3000c000: e28dd014 add sp, sp, #20
3000c004: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
3000c008: eb000866 bl 3000e1a8 <_Workspace_Allocate>
if ( !new_object_block )
3000c00c: e3500000 cmp r0, #0 3000c010: e58d0004 str r0, [sp, #4]
3000c014: 1affff9c bne 3000be8c <_Objects_Extend_information+0xac>
3000c018: eafffff8 b 3000c000 <_Objects_Extend_information+0x220>
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
return;
}
} else {
object_blocks = _Workspace_Allocate_or_fatal_error( block_size );
3000c01c: eb00086b bl 3000e1d0 <_Workspace_Allocate_or_fatal_error>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
3000c020: e1d521b0 ldrh r2, [r5, #16]
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
return;
}
} else {
object_blocks = _Workspace_Allocate_or_fatal_error( block_size );
3000c024: e1a0a000 mov sl, r0
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
3000c028: e1570002 cmp r7, r2 3000c02c: e08a3109 add r3, sl, r9, lsl #2 3000c030: e08a9189 add r9, sl, r9, lsl #3
3000c034: 2affffa6 bcs 3000bed4 <_Objects_Extend_information+0xf4>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
3000c038: e1a0b10b lsl fp, fp, #2 3000c03c: e5951034 ldr r1, [r5, #52] ; 0x34 3000c040: e1a0200b mov r2, fp 3000c044: e1a0000a mov r0, sl 3000c048: e58d3000 str r3, [sp] 3000c04c: eb001c3f bl 30013150 <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
3000c050: e59d3000 ldr r3, [sp] 3000c054: e5951030 ldr r1, [r5, #48] ; 0x30 3000c058: e1a00003 mov r0, r3 3000c05c: e1a0200b mov r2, fp 3000c060: eb001c3a bl 30013150 <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
3000c064: e1d521b0 ldrh r2, [r5, #16]
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
3000c068: e1a00009 mov r0, r9
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
3000c06c: e0872002 add r2, r7, r2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
3000c070: e595101c ldr r1, [r5, #28] 3000c074: e1a02102 lsl r2, r2, #2 3000c078: eb001c34 bl 30013150 <memcpy> 3000c07c: e59d3000 ldr r3, [sp] 3000c080: eaffff9d b 3000befc <_Objects_Extend_information+0x11c>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000c084: e1d021b4 ldrh r2, [r0, #20]
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000c088: e1a06007 mov r6, r7
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
3000c08c: e3a09001 mov r9, #1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
3000c090: e1a0b004 mov fp, r4 3000c094: eaffff72 b 3000be64 <_Objects_Extend_information+0x84>
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
object_blocks = _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
3000c098: e59d0004 ldr r0, [sp, #4] 3000c09c: eb000847 bl 3000e1c0 <_Workspace_Free>
return;
3000c0a0: eaffffd6 b 3000c000 <_Objects_Extend_information+0x220>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
3000c0a4: e1a0200a mov r2, sl <== NOT EXECUTED
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000c0a8: e1a06007 mov r6, r7 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
3000c0ac: e3a09001 mov r9, #1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
3000c0b0: e1a0400b mov r4, fp <== NOT EXECUTED 3000c0b4: eaffff6a b 3000be64 <_Objects_Extend_information+0x84> <== NOT EXECUTED
3000c214 <_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;
3000c214: e590c008 ldr ip, [r0, #8]
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000c218: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* 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 ) {
3000c21c: e1d031b0 ldrh r3, [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;
3000c220: e26cc001 rsb ip, ip, #1 3000c224: e08c1001 add r1, ip, 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 ) {
3000c228: e1510003 cmp r1, r3
/* * 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;
3000c22c: 83a03001 movhi r3, #1
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000c230: e24dd008 sub sp, sp, #8
/* * 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;
3000c234: 85823000 strhi r3, [r2]
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000c238: 83a00000 movhi r0, #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 ) {
3000c23c: 8a000009 bhi 3000c268 <_Objects_Get+0x54>
*
* 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;
3000c240: e59f3048 ldr r3, [pc, #72] ; 3000c290 <_Objects_Get+0x7c> 3000c244: e593c000 ldr ip, [r3]
++level;
3000c248: e28cc001 add ip, ip, #1
_Thread_Dispatch_disable_level = level;
3000c24c: e583c000 str ip, [r3]
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000c250: e590301c ldr r3, [r0, #28] 3000c254: e7930101 ldr r0, [r3, r1, lsl #2] 3000c258: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000c25c: 13a03000 movne r3, #0 3000c260: 15823000 strne r3, [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 ) {
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000c264: 0a000001 beq 3000c270 <_Objects_Get+0x5c>
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
3000c268: e28dd008 add sp, sp, #8
3000c26c: e8bd8000 pop {pc}
/*
* Valid Id for this API, Class and Node but the object has not
* been allocated yet.
*/
_Thread_Enable_dispatch();
3000c270: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3000c274: e58d2000 str r2, [sp] <== NOT EXECUTED 3000c278: eb0003ae bl 3000d138 <_Thread_Enable_dispatch> <== NOT EXECUTED
*location = OBJECTS_ERROR;
3000c27c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000c280: e3a03001 mov r3, #1 <== NOT EXECUTED 3000c284: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000c288: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3000c28c: eafffff5 b 3000c268 <_Objects_Get+0x54> <== NOT EXECUTED
3000c140 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000c140: e1a01801 lsl r1, r1, #16
3000c144: e92d4030 push {r4, r5, lr}
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000c148: e1b04821 lsrs r4, r1, #16
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000c14c: e1a05000 mov r5, r0
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
3000c150: 01a00004 moveq r0, r4
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000c154: 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 );
3000c158: eb0012af bl 30010c1c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
3000c15c: e3500000 cmp r0, #0
3000c160: 08bd8030 popeq {r4, r5, pc}
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
3000c164: e1500004 cmp r0, r4
3000c168: 3a00000a bcc 3000c198 <_Objects_Get_information+0x58>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
3000c16c: e59f302c ldr r3, [pc, #44] ; 3000c1a0 <_Objects_Get_information+0x60>
3000c170: e7930105 ldr r0, [r3, r5, lsl #2]
3000c174: e3500000 cmp r0, #0
3000c178: 08bd8030 popeq {r4, r5, pc}
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
3000c17c: e7900104 ldr r0, [r0, r4, lsl #2]
if ( !info )
3000c180: e3500000 cmp r0, #0
3000c184: 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 )
3000c188: e1d031b0 ldrh r3, [r0, #16]
return NULL;
3000c18c: e3530000 cmp r3, #0
3000c190: 03a00000 moveq r0, #0
3000c194: 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;
3000c198: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
3000c19c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000c1a4 <_Objects_Get_isr_disable>:
{
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000c1a4: e590c008 ldr ip, [r0, #8]
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
3000c1a8: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000c1ac: e26cc001 rsb ip, ip, #1 3000c1b0: e08cc001 add ip, ip, r1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c1b4: e10f4000 mrs r4, CPSR 3000c1b8: e3841080 orr r1, r4, #128 ; 0x80 3000c1bc: e129f001 msr CPSR_fc, r1
_ISR_Disable( level );
if ( information->maximum >= index ) {
3000c1c0: e1d011b0 ldrh r1, [r0, #16] 3000c1c4: e15c0001 cmp ip, r1
3000c1c8: 8a000008 bhi 3000c1f0 <_Objects_Get_isr_disable+0x4c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000c1cc: e590101c ldr r1, [r0, #28] 3000c1d0: e791010c ldr r0, [r1, ip, lsl #2] 3000c1d4: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000c1d8: 13a01000 movne r1, #0 3000c1dc: 15821000 strne r1, [r2]
*level_p = level;
3000c1e0: 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 ) {
3000c1e4: 0a000006 beq 3000c204 <_Objects_Get_isr_disable+0x60>
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
3000c1e8: e8bd0010 pop {r4}
3000c1ec: e12fff1e bx lr
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c1f0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000c1f4: e3a03001 mov r3, #1 <== NOT EXECUTED 3000c1f8: 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;
3000c1fc: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c200: eafffff8 b 3000c1e8 <_Objects_Get_isr_disable+0x44> <== NOT EXECUTED 3000c204: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000c208: e3a03001 mov r3, #1 <== NOT EXECUTED 3000c20c: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000c210: eafffff4 b 3000c1e8 <_Objects_Get_isr_disable+0x44> <== NOT EXECUTED
300196d8 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
300196d8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
300196dc: e2515000 subs r5, r1, #0 <== NOT EXECUTED
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
300196e0: e1a04002 mov r4, r2 <== NOT EXECUTED 300196e4: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
return NULL;
300196e8: 01a04005 moveq r4, r5 <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
300196ec: 0a000037 beq 300197d0 <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
if ( name == NULL )
300196f0: e3540000 cmp r4, #0 <== NOT EXECUTED 300196f4: 0a000035 beq 300197d0 <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
300196f8: e3500000 cmp r0, #0 <== NOT EXECUTED 300196fc: 059f30f8 ldreq r3, [pc, #248] ; 300197fc <_Objects_Get_name_as_string+0x124><== NOT EXECUTED 30019700: 11a07000 movne r7, r0 <== NOT EXECUTED 30019704: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED 30019708: 05937008 ldreq r7, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3001970c: e1a00007 mov r0, r7 <== NOT EXECUTED 30019710: ebffe12b bl 30011bc4 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
30019714: e2506000 subs r6, r0, #0 <== NOT EXECUTED
return NULL;
30019718: 01a04006 moveq r4, r6 <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
information = _Objects_Get_information_id( tmpId );
if ( !information )
3001971c: 0a00002b beq 300197d0 <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
30019720: e1a01007 mov r1, r7 <== NOT EXECUTED 30019724: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30019728: ebffe15f bl 30011cac <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3001972c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30019730: e3530000 cmp r3, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
30019734: 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 ) {
30019738: 1a000024 bne 300197d0 <_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 ) {
3001973c: e5d63038 ldrb r3, [r6, #56] ; 0x38 <== NOT EXECUTED 30019740: e3530000 cmp r3, #0 <== NOT EXECUTED 30019744: 1a000024 bne 300197dc <_Objects_Get_name_as_string+0x104> <== NOT EXECUTED
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
30019748: e590200c ldr r2, [r0, #12] <== NOT EXECUTED
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
3001974c: e5cd3004 strb r3, [sp, #4] <== NOT EXECUTED
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
30019750: e1a00c22 lsr r0, r2, #24 <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
30019754: e1a01822 lsr r1, r2, #16 <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
30019758: e1a03422 lsr r3, r2, #8 <== NOT EXECUTED
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
3001975c: e5cd0000 strb r0, [sp] <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
30019760: e5cd1001 strb r1, [sp, #1] <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
30019764: e5cd3002 strb r3, [sp, #2] <== NOT EXECUTED
lname[ 3 ] = (u32_name >> 0) & 0xff;
30019768: e5cd2003 strb r2, [sp, #3] <== NOT EXECUTED
lname[ 4 ] = '\0';
s = lname;
3001976c: e1a0000d mov r0, sp <== NOT EXECUTED
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
30019770: e2555001 subs r5, r5, #1 <== NOT EXECUTED 30019774: 0a00001b beq 300197e8 <_Objects_Get_name_as_string+0x110> <== NOT EXECUTED 30019778: e5d03000 ldrb r3, [r0] <== NOT EXECUTED 3001977c: e3530000 cmp r3, #0 <== NOT EXECUTED 30019780: 0a000018 beq 300197e8 <_Objects_Get_name_as_string+0x110> <== NOT EXECUTED 30019784: e59fc074 ldr ip, [pc, #116] ; 30019800 <_Objects_Get_name_as_string+0x128><== NOT EXECUTED 30019788: e1a02004 mov r2, r4 <== NOT EXECUTED
* This method objects the name of an object and returns its name
* in the form of a C string. It attempts to be careful about
* overflowing the user's string and about returning unprintable characters.
*/
char *_Objects_Get_name_as_string(
3001978c: e0855004 add r5, r5, r4 <== NOT EXECUTED 30019790: ea000002 b 300197a0 <_Objects_Get_name_as_string+0xc8> <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
30019794: e5f03001 ldrb r3, [r0, #1]! <== NOT EXECUTED 30019798: e3530000 cmp r3, #0 <== NOT EXECUTED 3001979c: 0a000008 beq 300197c4 <_Objects_Get_name_as_string+0xec> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
300197a0: e59c1000 ldr r1, [ip] <== NOT EXECUTED 300197a4: e0811003 add r1, r1, r3 <== NOT EXECUTED 300197a8: e5d11001 ldrb r1, [r1, #1] <== NOT EXECUTED 300197ac: e3110097 tst r1, #151 ; 0x97 <== NOT EXECUTED 300197b0: 03a0302a moveq r3, #42 ; 0x2a <== NOT EXECUTED 300197b4: e4c23001 strb r3, [r2], #1 <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
300197b8: e1520005 cmp r2, r5 <== NOT EXECUTED 300197bc: e1a01002 mov r1, r2 <== NOT EXECUTED 300197c0: 1afffff3 bne 30019794 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
300197c4: e3a03000 mov r3, #0 <== NOT EXECUTED 300197c8: e5c13000 strb r3, [r1] <== NOT EXECUTED
_Thread_Enable_dispatch();
300197cc: ebffe525 bl 30012c68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return name;
}
return NULL; /* unreachable path */
}
300197d0: e1a00004 mov r0, r4 <== NOT EXECUTED
300197d4: e28dd00c add sp, sp, #12 <== NOT EXECUTED
300197d8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
s = the_object->name.name_p;
300197dc: e590000c ldr r0, [r0, #12] <== NOT EXECUTED
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
300197e0: e3500000 cmp r0, #0 <== NOT EXECUTED 300197e4: 1affffe1 bne 30019770 <_Objects_Get_name_as_string+0x98> <== NOT EXECUTED
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
300197e8: e1a01004 mov r1, r4 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
300197ec: e3a03000 mov r3, #0 <== NOT EXECUTED 300197f0: e5c13000 strb r3, [r1] <== NOT EXECUTED
_Thread_Enable_dispatch();
300197f4: ebffe51b bl 30012c68 <_Thread_Enable_dispatch> <== NOT EXECUTED 300197f8: eafffff4 b 300197d0 <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
3001c128 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3001c128: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3001c12c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3001c130: e1a04002 mov r4, r2 <== NOT EXECUTED 3001c134: e1a08003 mov r8, r3 <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
3001c138: 01a00005 moveq r0, r5 <== NOT EXECUTED
)
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3001c13c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return NULL;
if ( !location_p )
3001c140: e3520000 cmp r2, #0 <== NOT EXECUTED
return NULL;
3001c144: 01a00002 moveq r0, r2 <== NOT EXECUTED
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
3001c148: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return NULL;
if ( !next_id_p )
3001c14c: e3530000 cmp r3, #0 <== NOT EXECUTED 3001c150: 0a000016 beq 3001c1b0 <_Objects_Get_next+0x88> <== NOT EXECUTED
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
3001c154: e1b03801 lsls r3, r1, #16 <== NOT EXECUTED
next_id = information->minimum_id;
3001c158: 05956008 ldreq r6, [r5, #8] <== NOT EXECUTED
else
next_id = id;
3001c15c: 11a06001 movne r6, r1 <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
3001c160: e1d5c1b0 ldrh ip, [r5, #16] <== NOT EXECUTED 3001c164: e1a07806 lsl r7, r6, #16 <== NOT EXECUTED 3001c168: e15c0827 cmp ip, r7, lsr #16 <== NOT EXECUTED
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
3001c16c: e1a01006 mov r1, r6 <== NOT EXECUTED 3001c170: e1a00005 mov r0, r5 <== NOT EXECUTED 3001c174: e1a02004 mov r2, r4 <== NOT EXECUTED
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
3001c178: 3a000006 bcc 3001c198 <_Objects_Get_next+0x70> <== NOT EXECUTED
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
3001c17c: ebffd6ca bl 30011cac <_Objects_Get> <== NOT EXECUTED
next_id++;
} while (*location_p != OBJECTS_LOCAL);
3001c180: e5943000 ldr r3, [r4] <== NOT EXECUTED
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
next_id++;
3001c184: e2866001 add r6, r6, #1 <== NOT EXECUTED
} while (*location_p != OBJECTS_LOCAL);
3001c188: e3530000 cmp r3, #0 <== NOT EXECUTED 3001c18c: 1afffff3 bne 3001c160 <_Objects_Get_next+0x38> <== NOT EXECUTED
*next_id_p = next_id;
3001c190: e5886000 str r6, [r8] <== NOT EXECUTED
return object;
3001c194: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
3001c198: e3a03001 mov r3, #1 <== NOT EXECUTED 3001c19c: e5843000 str r3, [r4] <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
3001c1a0: e3e03000 mvn r3, #0 <== NOT EXECUTED
return 0;
3001c1a4: e3a00000 mov r0, #0 <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
3001c1a8: e5883000 str r3, [r8] <== NOT EXECUTED
return 0;
3001c1ac: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
3001c1b0: e1a00003 mov r0, r3 <== NOT EXECUTED
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
3001c1b4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30011d2c <_Objects_Id_to_name>:
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
30011d2c: e3500000 cmp r0, #0 30011d30: 059f3084 ldreq r3, [pc, #132] ; 30011dbc <_Objects_Id_to_name+0x90>
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
30011d34: e92d4030 push {r4, r5, lr}
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
30011d38: 05933008 ldreq r3, [r3, #8]
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
30011d3c: e1a04001 mov r4, r1
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
30011d40: 05931008 ldreq r1, [r3, #8] 30011d44: 11a01000 movne r1, r0 30011d48: e1a03c21 lsr r3, r1, #24 30011d4c: 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 )
30011d50: e2432001 sub r2, r3, #1 30011d54: e3520002 cmp r2, #2
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
30011d58: e24dd004 sub sp, sp, #4
30011d5c: 8a00000a bhi 30011d8c <_Objects_Id_to_name+0x60>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
30011d60: e59f2058 ldr r2, [pc, #88] ; 30011dc0 <_Objects_Id_to_name+0x94> 30011d64: e7923103 ldr r3, [r2, r3, lsl #2] 30011d68: e3530000 cmp r3, #0
30011d6c: 0a000006 beq 30011d8c <_Objects_Id_to_name+0x60>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
30011d70: e1a02da1 lsr r2, r1, #27
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
30011d74: e7930102 ldr r0, [r3, r2, lsl #2]
if ( !information )
30011d78: e3500000 cmp r0, #0
30011d7c: 0a000002 beq 30011d8c <_Objects_Id_to_name+0x60>
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
30011d80: e5d05038 ldrb r5, [r0, #56] ; 0x38 30011d84: e3550000 cmp r5, #0
30011d88: 0a000002 beq 30011d98 <_Objects_Id_to_name+0x6c>
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;
30011d8c: e3a00003 mov r0, #3 <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
30011d90: e28dd004 add sp, sp, #4
30011d94: e8bd8030 pop {r4, r5, pc}
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
30011d98: e1a0200d mov r2, sp 30011d9c: ebffffc2 bl 30011cac <_Objects_Get>
if ( !the_object )
30011da0: e3500000 cmp r0, #0
30011da4: 0afffff8 beq 30011d8c <_Objects_Id_to_name+0x60>
return OBJECTS_INVALID_ID;
*name = the_object->name;
30011da8: e590300c ldr r3, [r0, #12] 30011dac: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
30011db0: eb0003ac bl 30012c68 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
30011db4: e1a00005 mov r0, r5 30011db8: eafffff4 b 30011d90 <_Objects_Id_to_name+0x64>
3000c388 <_Objects_Name_to_id_u32>:
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000c388: e3530000 cmp r3, #0
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
3000c38c: e92d0030 push {r4, r5}
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
3000c390: 03a00002 moveq r0, #2
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000c394: 0a000013 beq 3000c3e8 <_Objects_Name_to_id_u32+0x60>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
3000c398: e3510000 cmp r1, #0
3000c39c: 0a000010 beq 3000c3e4 <_Objects_Name_to_id_u32+0x5c>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
3000c3a0: e1d051b0 ldrh r5, [r0, #16] 3000c3a4: e3550000 cmp r5, #0
3000c3a8: 0a00000d beq 3000c3e4 <_Objects_Name_to_id_u32+0x5c>
3000c3ac: e3720106 cmn r2, #-2147483647 ; 0x80000001 3000c3b0: 13520000 cmpne r2, #0
3000c3b4: 1a00000d bne 3000c3f0 <_Objects_Name_to_id_u32+0x68>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000c3b8: e590c01c ldr ip, [r0, #28] 3000c3bc: e3a02001 mov r2, #1
the_object = information->local_table[ index ];
3000c3c0: e5bc0004 ldr r0, [ip, #4]!
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000c3c4: e2822001 add r2, r2, #1
the_object = information->local_table[ index ];
if ( !the_object )
3000c3c8: e3500000 cmp r0, #0
3000c3cc: 0a000002 beq 3000c3dc <_Objects_Name_to_id_u32+0x54>
continue;
if ( name == the_object->name.name_u32 ) {
3000c3d0: e590400c ldr r4, [r0, #12] 3000c3d4: e1540001 cmp r4, r1
3000c3d8: 0a000007 beq 3000c3fc <_Objects_Name_to_id_u32+0x74>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000c3dc: e1550002 cmp r5, r2
3000c3e0: 2afffff6 bcs 3000c3c0 <_Objects_Name_to_id_u32+0x38>
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;
3000c3e4: e3a00001 mov r0, #1
#endif }
3000c3e8: e8bd0030 pop {r4, r5}
3000c3ec: e12fff1e bx lr
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
3000c3f0: e3520001 cmp r2, #1 <== NOT EXECUTED 3000c3f4: 1afffffa bne 3000c3e4 <_Objects_Name_to_id_u32+0x5c> <== NOT EXECUTED 3000c3f8: eaffffee b 3000c3b8 <_Objects_Name_to_id_u32+0x30> <== NOT EXECUTED
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
3000c3fc: e5902008 ldr r2, [r0, #8]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000c400: 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;
3000c404: e5832000 str r2, [r3]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000c408: eafffff6 b 3000c3e8 <_Objects_Name_to_id_u32+0x60>
3000c550 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000c550: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000c554: e1a05000 mov r5, r0
3000c558: e1a06001 mov r6, r1
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000c55c: e1a00002 mov r0, r2 3000c560: e1d513ba ldrh r1, [r5, #58] ; 0x3a
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000c564: e1a08002 mov r8, r2
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000c568: eb0020a9 bl 30014814 <strnlen>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000c56c: e5d53038 ldrb r3, [r5, #56] ; 0x38
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000c570: e1a04000 mov r4, r0
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000c574: e3530000 cmp r3, #0
3000c578: 1a000017 bne 3000c5dc <_Objects_Set_name+0x8c>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000c57c: e5d82000 ldrb r2, [r8] <== NOT EXECUTED 3000c580: e3500001 cmp r0, #1 <== NOT EXECUTED 3000c584: e1a02c02 lsl r2, r2, #24 <== NOT EXECUTED 3000c588: 9a00000c bls 3000c5c0 <_Objects_Set_name+0x70> <== NOT EXECUTED 3000c58c: e5d83001 ldrb r3, [r8, #1] <== NOT EXECUTED 3000c590: e3500002 cmp r0, #2 <== NOT EXECUTED 3000c594: e1822803 orr r2, r2, r3, lsl #16 <== NOT EXECUTED 3000c598: 0a000009 beq 3000c5c4 <_Objects_Set_name+0x74> <== NOT EXECUTED 3000c59c: e5d83002 ldrb r3, [r8, #2] <== NOT EXECUTED 3000c5a0: e3500003 cmp r0, #3 <== NOT EXECUTED 3000c5a4: e1822403 orr r2, r2, r3, lsl #8 <== NOT EXECUTED 3000c5a8: 15d83003 ldrbne r3, [r8, #3] <== NOT EXECUTED 3000c5ac: 03a03020 moveq r3, #32 <== NOT EXECUTED 3000c5b0: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000c5b4: e586300c str r3, [r6, #12] <== NOT EXECUTED
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
3000c5b8: e3a00001 mov r0, #1 <== NOT EXECUTED
3000c5bc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000c5c0: e3822602 orr r2, r2, #2097152 ; 0x200000 <== NOT EXECUTED 3000c5c4: e3822a02 orr r2, r2, #8192 ; 0x2000 <== NOT EXECUTED 3000c5c8: e3a03020 mov r3, #32 <== NOT EXECUTED 3000c5cc: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000c5d0: e586300c str r3, [r6, #12] <== NOT EXECUTED
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
3000c5d4: e3a00001 mov r0, #1 <== NOT EXECUTED
3000c5d8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
3000c5dc: e2800001 add r0, r0, #1 3000c5e0: eb000776 bl 3000e3c0 <_Workspace_Allocate>
if ( !d )
3000c5e4: e2505000 subs r5, r0, #0
3000c5e8: 0a00000b beq 3000c61c <_Objects_Set_name+0xcc>
return false;
_Workspace_Free( (void *)the_object->name.name_p );
3000c5ec: e596000c ldr r0, [r6, #12] <== NOT EXECUTED
the_object->name.name_p = NULL;
3000c5f0: e3a07000 mov r7, #0 <== NOT EXECUTED
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
_Workspace_Free( (void *)the_object->name.name_p );
3000c5f4: eb000777 bl 3000e3d8 <_Workspace_Free> <== NOT EXECUTED
the_object->name.name_p = NULL;
3000c5f8: e586700c str r7, [r6, #12] <== NOT EXECUTED
strncpy( d, name, length );
3000c5fc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c600: e1a01008 mov r1, r8 <== NOT EXECUTED 3000c604: e1a02004 mov r2, r4 <== NOT EXECUTED 3000c608: eb00204c bl 30014740 <strncpy> <== NOT EXECUTED
d[length] = '\0';
3000c60c: e7c57004 strb r7, [r5, r4] <== NOT EXECUTED
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
3000c610: e3a00001 mov r0, #1 <== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
the_object->name.name_p = NULL;
strncpy( d, name, length );
d[length] = '\0';
the_object->name.name_p = d;
3000c614: e586500c str r5, [r6, #12] <== NOT EXECUTED
3000c618: 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;
3000c61c: e1a00005 mov r0, r5
);
}
return true;
}
3000c620: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000c40c <_Objects_Shrink_information>:
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
3000c40c: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
3000c410: e1d040b8 ldrh r4, [r0, #8]
block_count = (information->maximum - index_base) /
3000c414: e1d051b4 ldrh r5, [r0, #20]
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
3000c418: e1a06000 mov r6, r0
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
3000c41c: e1d001b0 ldrh r0, [r0, #16] 3000c420: e1a01005 mov r1, r5 3000c424: e0640000 rsb r0, r4, r0 3000c428: eb003cff bl 3001b82c <__aeabi_uidiv>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
3000c42c: e3500000 cmp r0, #0
3000c430: 08bd80f0 popeq {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
3000c434: e5962030 ldr r2, [r6, #48] ; 0x30 3000c438: e5923000 ldr r3, [r2] 3000c43c: e1550003 cmp r5, r3
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
3000c440: 13a03000 movne r3, #0
if ( information->inactive_per_block[ block ] ==
3000c444: 1a000005 bne 3000c460 <_Objects_Shrink_information+0x54>
3000c448: ea000008 b 3000c470 <_Objects_Shrink_information+0x64> <== NOT EXECUTED
3000c44c: e5b21004 ldr r1, [r2, #4]!
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
3000c450: e0844005 add r4, r4, r5
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
3000c454: e1550001 cmp r5, r1 3000c458: e1a07103 lsl r7, r3, #2
3000c45c: 0a000004 beq 3000c474 <_Objects_Shrink_information+0x68>
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
3000c460: e2833001 add r3, r3, #1 3000c464: e1530000 cmp r3, r0
3000c468: 1afffff7 bne 3000c44c <_Objects_Shrink_information+0x40>
3000c46c: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
3000c470: e3a07000 mov r7, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000c474: e5960020 ldr r0, [r6, #32] 3000c478: ea000002 b 3000c488 <_Objects_Shrink_information+0x7c>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
3000c47c: e3550000 cmp r5, #0
3000c480: 0a00000b beq 3000c4b4 <_Objects_Shrink_information+0xa8>
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
3000c484: e1a00005 mov r0, r5
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
3000c488: e1d030b8 ldrh r3, [r0, #8]
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
3000c48c: e5905000 ldr r5, [r0]
if ((index >= index_base) &&
3000c490: e1530004 cmp r3, r4
3000c494: 3afffff8 bcc 3000c47c <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
3000c498: e1d621b4 ldrh r2, [r6, #20] 3000c49c: e0842002 add r2, r4, r2
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
3000c4a0: e1530002 cmp r3, r2
3000c4a4: 2afffff4 bcs 3000c47c <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
3000c4a8: eb00100a bl 300104d8 <_Chain_Extract>
}
}
while ( the_object );
3000c4ac: e3550000 cmp r5, #0
3000c4b0: 1afffff3 bne 3000c484 <_Objects_Shrink_information+0x78>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
3000c4b4: e5963034 ldr r3, [r6, #52] ; 0x34 3000c4b8: e7930007 ldr r0, [r3, r7] 3000c4bc: eb00073f bl 3000e1c0 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
3000c4c0: e5963034 ldr r3, [r6, #52] ; 0x34
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
3000c4c4: e1d612bc ldrh r1, [r6, #44] ; 0x2c
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
3000c4c8: e7835007 str r5, [r3, r7]
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
3000c4cc: e1d631b4 ldrh r3, [r6, #20]
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
3000c4d0: e5962030 ldr r2, [r6, #48] ; 0x30
information->inactive -= information->allocation_size;
3000c4d4: e0633001 rsb r3, r3, r1
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
3000c4d8: e7825007 str r5, [r2, r7]
information->inactive -= information->allocation_size;
3000c4dc: e1c632bc strh r3, [r6, #44] ; 0x2c
return;
3000c4e0: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000b718 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
3000b718: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000b71c: e1a04001 mov r4, r1 <== NOT EXECUTED
3000b720: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000b724: e1a05000 mov r5, r0 <== NOT EXECUTED
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
3000b728: e1a0100d mov r1, sp <== NOT EXECUTED 3000b72c: e1a00004 mov r0, r4 <== NOT EXECUTED
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
3000b730: e1a08002 mov r8, r2 <== NOT EXECUTED 3000b734: e20370ff and r7, 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 ) ) {
3000b738: eb00005a bl 3000b8a8 <_POSIX_Mutex_Get> <== NOT EXECUTED 3000b73c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b740: 0a000013 beq 3000b794 <_POSIX_Condition_variables_Wait_support+0x7c><== 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;
3000b744: e59f30d8 ldr r3, [pc, #216] ; 3000b824 <_POSIX_Condition_variables_Wait_support+0x10c><== NOT EXECUTED
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000b748: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b74c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b750: e1a0100d mov r1, sp <== NOT EXECUTED
--level;
3000b754: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000b758: e5832000 str r2, [r3] <== NOT EXECUTED 3000b75c: ebffff73 bl 3000b530 <_POSIX_Condition_variables_Get> <== NOT EXECUTED
switch ( location ) {
3000b760: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000b764: e1a0a000 mov sl, r0 <== NOT EXECUTED
switch ( location ) {
3000b768: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b76c: 1a000008 bne 3000b794 <_POSIX_Condition_variables_Wait_support+0x7c><== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
3000b770: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000b774: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b778: 0a000009 beq 3000b7a4 <_POSIX_Condition_variables_Wait_support+0x8c><== NOT EXECUTED 3000b77c: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000b780: e1530002 cmp r3, r2 <== NOT EXECUTED 3000b784: 0a000006 beq 3000b7a4 <_POSIX_Condition_variables_Wait_support+0x8c><== NOT EXECUTED
_Thread_Enable_dispatch();
3000b788: eb000e7e bl 3000f188 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EINVAL;
3000b78c: e3a05016 mov r5, #22 <== NOT EXECUTED 3000b790: ea000000 b 3000b798 <_POSIX_Condition_variables_Wait_support+0x80><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b794: e3a05016 mov r5, #22 <== NOT EXECUTED
}
3000b798: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b79c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b7a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
_Thread_Enable_dispatch();
return EINVAL;
}
(void) pthread_mutex_unlock( mutex );
3000b7a4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b7a8: eb0000e3 bl 3000bb3c <pthread_mutex_unlock> <== NOT EXECUTED
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
3000b7ac: e3570000 cmp r7, #0 <== NOT EXECUTED 3000b7b0: 0a000006 beq 3000b7d0 <_POSIX_Condition_variables_Wait_support+0xb8><== NOT EXECUTED
status = _Thread_Executing->Wait.return_code;
if ( status == EINTR )
status = 0;
} else {
_Thread_Enable_dispatch();
3000b7b4: eb000e73 bl 3000f188 <_Thread_Enable_dispatch> <== NOT EXECUTED
status = ETIMEDOUT;
3000b7b8: e3a05074 mov r5, #116 ; 0x74 <== NOT EXECUTED
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
3000b7bc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b7c0: eb0000bc bl 3000bab8 <pthread_mutex_lock> <== NOT EXECUTED
if ( mutex_status )
return EINVAL;
3000b7c4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b7c8: 13a05016 movne r5, #22 <== NOT EXECUTED 3000b7cc: eafffff1 b 3000b798 <_POSIX_Condition_variables_Wait_support+0x80><== NOT EXECUTED
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000b7d0: e59f6050 ldr r6, [pc, #80] ; 3000b828 <_POSIX_Condition_variables_Wait_support+0x110><== NOT EXECUTED
return EINVAL;
}
*/
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
3000b7d4: e5942000 ldr r2, [r4] <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000b7d8: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
return EINVAL;
}
*/
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
3000b7dc: e58a2014 str r2, [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;
3000b7e0: e3a02001 mov r2, #1 <== NOT EXECUTED 3000b7e4: e58a2048 str r2, [sl, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000b7e8: e5837034 str r7, [r3, #52] ; 0x34 <== NOT EXECUTED
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
_Thread_Executing->Wait.id = *cond;
3000b7ec: e595e000 ldr lr, [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;
3000b7f0: e28ac018 add ip, sl, #24 <== NOT EXECUTED 3000b7f4: e583c044 str ip, [r3, #68] ; 0x44 <== NOT EXECUTED
_Thread_Executing->Wait.id = *cond;
3000b7f8: e583e020 str lr, [r3, #32] <== NOT EXECUTED
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
3000b7fc: e1a0000c mov r0, ip <== NOT EXECUTED 3000b800: e1a01008 mov r1, r8 <== NOT EXECUTED 3000b804: e59f2020 ldr r2, [pc, #32] ; 3000b82c <_POSIX_Condition_variables_Wait_support+0x114><== NOT EXECUTED 3000b808: eb000f94 bl 3000f660 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b80c: eb000e5d bl 3000f188 <_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;
3000b810: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED 3000b814: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
if ( status == EINTR )
status = 0;
3000b818: e3550004 cmp r5, #4 <== NOT EXECUTED 3000b81c: 03a05000 moveq r5, #0 <== NOT EXECUTED 3000b820: eaffffe5 b 3000b7bc <_POSIX_Condition_variables_Wait_support+0xa4><== NOT EXECUTED
300120fc <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
300120fc: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
30012100: e5907008 ldr r7, [r0, #8] 30012104: e59f5084 ldr r5, [pc, #132] ; 30012190 <_POSIX_Keys_Run_destructors+0x94> 30012108: e1a08c27 lsr r8, r7, #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 ];
3001210c: e1a07807 lsl r7, r7, #16 30012110: e2088007 and r8, r8, #7 30012114: e1a07727 lsr r7, r7, #14
if ( value != NULL ) {
key->Values [ thread_api ][ thread_index ] = NULL;
30012118: e3a0a000 mov sl, #0
*
* 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;
3001211c: e1d541b0 ldrh r4, [r5, #16]
done = true;
for ( index = 1 ; index <= max ; ++index ) {
30012120: e3540000 cmp r4, #0
30012124: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
30012128: e3a06001 mov r6, #1 <== NOT EXECUTED 3001212c: e1a02006 mov r2, r6 <== NOT EXECUTED
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
30012130: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
30012134: e2881005 add r1, r8, #5 <== NOT EXECUTED
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
30012138: e7933106 ldr r3, [r3, r6, lsl #2] <== NOT EXECUTED
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
3001213c: e3530000 cmp r3, #0 <== NOT EXECUTED 30012140: 0a00000a beq 30012170 <_POSIX_Keys_Run_destructors+0x74> <== NOT EXECUTED 30012144: e5930010 ldr r0, [r3, #16] <== NOT EXECUTED 30012148: e3500000 cmp r0, #0 <== NOT EXECUTED 3001214c: 0a000007 beq 30012170 <_POSIX_Keys_Run_destructors+0x74> <== NOT EXECUTED
void *value = key->Values [ thread_api ][ thread_index ];
30012150: e7931101 ldr r1, [r3, r1, lsl #2] <== NOT EXECUTED 30012154: e7910007 ldr r0, [r1, r7] <== NOT EXECUTED
if ( value != NULL ) {
30012158: e3500000 cmp r0, #0 <== NOT EXECUTED 3001215c: 0a000003 beq 30012170 <_POSIX_Keys_Run_destructors+0x74> <== NOT EXECUTED
key->Values [ thread_api ][ thread_index ] = NULL;
30012160: e781a007 str sl, [r1, r7] <== NOT EXECUTED
(*key->destructor)( value );
30012164: e1a0e00f mov lr, pc <== NOT EXECUTED 30012168: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED
done = false;
3001216c: 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 ) {
30012170: e2866001 add r6, r6, #1 <== NOT EXECUTED 30012174: e1a06806 lsl r6, r6, #16 <== NOT EXECUTED 30012178: e1a06826 lsr r6, r6, #16 <== NOT EXECUTED 3001217c: e1540006 cmp r4, r6 <== NOT EXECUTED 30012180: 2affffea bcs 30012130 <_POSIX_Keys_Run_destructors+0x34> <== NOT EXECUTED
* 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 ) {
30012184: e3520000 cmp r2, #0 <== NOT EXECUTED
30012188: 0affffe3 beq 3001211c <_POSIX_Keys_Run_destructors+0x20> <== NOT EXECUTED
3001218c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30011734 <_POSIX_Message_queue_Create_support>:
*
* 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;
30011734: e59fc148 ldr ip, [pc, #328] ; 30011884 <_POSIX_Message_queue_Create_support+0x150>
size_t name_len,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
30011738: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
3001173c: e1a06000 mov r6, r0
30011740: e59c0000 ldr r0, [ip]
30011744: e1a07001 mov r7, r1
++level;
30011748: e2800001 add r0, r0, #1 3001174c: e1a09002 mov r9, r2
_Thread_Dispatch_disable_level = level;
30011750: e58c0000 str r0, [ip]
* 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 ) {
30011754: e3530000 cmp r3, #0
30011758: 0a000026 beq 300117f8 <_POSIX_Message_queue_Create_support+0xc4>
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
3001175c: e593a004 ldr sl, [r3, #4] 30011760: e35a0000 cmp sl, #0
30011764: da000031 ble 30011830 <_POSIX_Message_queue_Create_support+0xfc>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
30011768: e5938008 ldr r8, [r3, #8] 3001176c: e3580000 cmp r8, #0
30011770: da00002e ble 30011830 <_POSIX_Message_queue_Create_support+0xfc>
*/
RTEMS_INLINE_ROUTINE
POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void )
{
return (POSIX_Message_queue_Control *)
30011774: e59f510c ldr r5, [pc, #268] ; 30011888 <_POSIX_Message_queue_Create_support+0x154> 30011778: e1a00005 mov r0, r5 3001177c: ebfff08e bl 3000d9bc <_Objects_Allocate>
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
30011780: e2504000 subs r4, r0, #0
30011784: 0a000038 beq 3001186c <_POSIX_Message_queue_Create_support+0x138>
/*
* 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 );
30011788: e1a01007 mov r1, r7 3001178c: e1a00006 mov r0, r6 30011790: eb00063c bl 30013088 <_Workspace_String_duplicate>
if ( !name ) {
30011794: e2507000 subs r7, r0, #0
30011798: 0a00002a beq 30011848 <_POSIX_Message_queue_Create_support+0x114>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
the_mq->process_shared = pshared;
the_mq->named = true;
3001179c: 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;
300117a0: e3a06000 mov r6, #0
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
the_mq->process_shared = pshared;
the_mq->named = true;
300117a4: e5c43014 strb r3, [r4, #20]
the_mq->open_count = 1;
300117a8: e5843018 str r3, [r4, #24]
the_mq->linked = true;
300117ac: 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;
300117b0: 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;
300117b4: e584605c str r6, [r4, #92] ; 0x5c
if ( !_CORE_message_queue_Initialize(
300117b8: e284001c add r0, r4, #28 300117bc: e284105c add r1, r4, #92 ; 0x5c 300117c0: e1a0200a mov r2, sl 300117c4: e1a03008 mov r3, r8 300117c8: eb000348 bl 300124f0 <_CORE_message_queue_Initialize> 300117cc: e1500006 cmp r0, r6
300117d0: 0a00000b beq 30011804 <_POSIX_Message_queue_Create_support+0xd0>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300117d4: e595301c ldr r3, [r5, #28]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
300117d8: e1d420b8 ldrh r2, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300117dc: e7834102 str r4, [r3, r2, lsl #2]
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
300117e0: 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;
300117e4: e584700c str r7, [r4, #12] 300117e8: e5834000 str r4, [r3]
_Thread_Enable_dispatch();
300117ec: ebfff585 bl 3000ee08 <_Thread_Enable_dispatch>
return 0;
300117f0: e1a00006 mov r0, r6
}
300117f4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
* 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;
300117f8: 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;
300117fc: e3a0a00a mov sl, #10 <== NOT EXECUTED 30011800: eaffffdb b 30011774 <_POSIX_Message_queue_Create_support+0x40><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
30011804: e1a01004 mov r1, r4 <== NOT EXECUTED 30011808: e1a00005 mov r0, r5 <== NOT EXECUTED 3001180c: ebfff148 bl 3000dd34 <_Objects_Free> <== NOT EXECUTED
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
30011810: e1a00007 mov r0, r7 <== NOT EXECUTED 30011814: ebfff9c5 bl 3000ff30 <_Workspace_Free> <== NOT EXECUTED
_Thread_Enable_dispatch();
30011818: ebfff57a bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
3001181c: eb000bdb bl 30014790 <__errno> <== NOT EXECUTED
30011820: e3a0301c mov r3, #28 <== NOT EXECUTED
30011824: e5803000 str r3, [r0] <== NOT EXECUTED
30011828: e3e00000 mvn r0, #0 <== NOT EXECUTED
3001182c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
_Thread_Enable_dispatch();
30011830: ebfff574 bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30011834: eb000bd5 bl 30014790 <__errno> <== NOT EXECUTED
30011838: e3a03016 mov r3, #22 <== NOT EXECUTED
3001183c: e5803000 str r3, [r0] <== NOT EXECUTED
30011840: e3e00000 mvn r0, #0 <== NOT EXECUTED
30011844: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
30011848: e1a00005 mov r0, r5 <== NOT EXECUTED
3001184c: e1a01004 mov r1, r4 <== NOT EXECUTED
30011850: ebfff137 bl 3000dd34 <_Objects_Free> <== NOT EXECUTED
* dynamically constructed.
*/
name = _Workspace_String_duplicate( name_arg, name_len );
if ( !name ) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
30011854: ebfff56b bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
30011858: eb000bcc bl 30014790 <__errno> <== NOT EXECUTED
3001185c: e3a0300c mov r3, #12 <== NOT EXECUTED
30011860: e5803000 str r3, [r0] <== NOT EXECUTED
30011864: e3e00000 mvn r0, #0 <== NOT EXECUTED
30011868: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
_Thread_Enable_dispatch();
3001186c: ebfff565 bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
30011870: eb000bc6 bl 30014790 <__errno> <== NOT EXECUTED
30011874: e3a03017 mov r3, #23 <== NOT EXECUTED
30011878: e5803000 str r3, [r0] <== NOT EXECUTED
3001187c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30011880: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000fc98 <_POSIX_Message_queue_Notify_handler>:
*/
static void _POSIX_Message_queue_Notify_handler(
void *user_data
)
{
3000fc98: e92d4010 push {r4, lr} <== NOT EXECUTED
3000fc9c: e1a04000 mov r4, r0 <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
the_mq = user_data;
kill( getpid(), the_mq->notification.sigev_signo );
3000fca0: eb00198a bl 300162d0 <getpid> <== NOT EXECUTED 3000fca4: e5941094 ldr r1, [r4, #148] ; 0x94 <== NOT EXECUTED 3000fca8: eb001bcf bl 30016bec <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;
3000fcac: e3a03000 mov r3, #0 <== NOT EXECUTED 3000fcb0: e584307c str r3, [r4, #124] ; 0x7c <== NOT EXECUTED
the_message_queue->notify_argument = the_argument;
3000fcb4: e5843080 str r3, [r4, #128] ; 0x80 <== NOT EXECUTED
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
}
3000fcb8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ff3c <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000ff3c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000ff40: e1a04000 mov r4, r0
3000ff44: e24dd010 sub sp, sp, #16
3000ff48: e1a07001 mov r7, r1
3000ff4c: e1a06002 mov r6, 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(
3000ff50: e59f011c ldr r0, [pc, #284] ; 30010074 <_POSIX_Message_queue_Receive_support+0x138> 3000ff54: e1a01004 mov r1, r4 3000ff58: e28d2008 add r2, sp, #8 3000ff5c: e1a05003 mov r5, r3 3000ff60: e5dd8028 ldrb r8, [sp, #40] ; 0x28 3000ff64: eb000cda bl 300132d4 <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000ff68: e59d3008 ldr r3, [sp, #8] 3000ff6c: e3530000 cmp r3, #0
3000ff70: 0a000006 beq 3000ff90 <_POSIX_Message_queue_Receive_support+0x54>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000ff74: eb002851 bl 3001a0c0 <__errno> <== NOT EXECUTED 3000ff78: e3a03009 mov r3, #9 <== NOT EXECUTED 3000ff7c: e5803000 str r3, [r0] <== NOT EXECUTED 3000ff80: e3e03000 mvn r3, #0 <== NOT EXECUTED
}
3000ff84: e1a00003 mov r0, r3
3000ff88: e28dd010 add sp, sp, #16
3000ff8c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
3000ff90: e5903014 ldr r3, [r0, #20] 3000ff94: e2032003 and r2, r3, #3 3000ff98: e3520001 cmp r2, #1
3000ff9c: 0a00002e beq 3001005c <_POSIX_Message_queue_Receive_support+0x120>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
3000ffa0: e5900010 ldr r0, [r0, #16]
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
3000ffa4: e5902068 ldr r2, [r0, #104] ; 0x68 3000ffa8: e1520006 cmp r2, r6
3000ffac: 8a000024 bhi 30010044 <_POSIX_Message_queue_Receive_support+0x108>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
3000ffb0: e3e02000 mvn r2, #0
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000ffb4: e3580000 cmp r8, #0
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
3000ffb8: e58d200c str r2, [sp, #12]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000ffbc: 1a00001c bne 30010034 <_POSIX_Message_queue_Receive_support+0xf8>
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
3000ffc0: e59dc02c ldr ip, [sp, #44] ; 0x2c 3000ffc4: e1a01004 mov r1, r4 3000ffc8: e28d300c add r3, sp, #12 3000ffcc: e280001c add r0, r0, #28 3000ffd0: e1a02007 mov r2, r7
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
3000ffd4: e59f409c ldr r4, [pc, #156] ; 30010078 <_POSIX_Message_queue_Receive_support+0x13c>
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
3000ffd8: e58dc004 str ip, [sp, #4] 3000ffdc: e58d8000 str r8, [sp] 3000ffe0: eb000888 bl 30012208 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
3000ffe4: eb001084 bl 300141fc <_Thread_Enable_dispatch>
if (msg_prio) {
3000ffe8: e3550000 cmp r5, #0
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
3000ffec: e5943008 ldr r3, [r4, #8]
do_wait,
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
3000fff0: 0a000003 beq 30010004 <_POSIX_Message_queue_Receive_support+0xc8>
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);
3000fff4: e5932024 ldr r2, [r3, #36] ; 0x24 3000fff8: e3520000 cmp r2, #0 3000fffc: b2622000 rsblt r2, r2, #0
*msg_prio = _POSIX_Message_queue_Priority_from_core(
30010000: e5852000 str r2, [r5]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
30010004: e5933034 ldr r3, [r3, #52] ; 0x34 30010008: e3530000 cmp r3, #0
return length_out;
3001000c: 059d300c ldreq r3, [sp, #12]
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
30010010: 0affffdb beq 3000ff84 <_POSIX_Message_queue_Receive_support+0x48>
return length_out;
rtems_set_errno_and_return_minus_one(
30010014: eb002829 bl 3001a0c0 <__errno> <== NOT EXECUTED 30010018: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3001001c: e1a05000 mov r5, r0 <== NOT EXECUTED 30010020: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 30010024: eb0000b9 bl 30010310 <_POSIX_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED 30010028: e3e03000 mvn r3, #0 <== NOT EXECUTED 3001002c: e5850000 str r0, [r5] <== NOT EXECUTED 30010030: eaffffd3 b 3000ff84 <_POSIX_Message_queue_Receive_support+0x48><== NOT EXECUTED
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
30010034: e3130901 tst r3, #16384 ; 0x4000 30010038: 13a08000 movne r8, #0 3001003c: 03a08001 moveq r8, #1 30010040: eaffffde b 3000ffc0 <_POSIX_Message_queue_Receive_support+0x84>
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
_Thread_Enable_dispatch();
30010044: eb00106c bl 300141fc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMSGSIZE );
30010048: eb00281c bl 3001a0c0 <__errno> <== NOT EXECUTED 3001004c: e3a0307a mov r3, #122 ; 0x7a <== NOT EXECUTED 30010050: e5803000 str r3, [r0] <== NOT EXECUTED 30010054: e3e03000 mvn r3, #0 <== NOT EXECUTED 30010058: eaffffc9 b 3000ff84 <_POSIX_Message_queue_Receive_support+0x48><== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
_Thread_Enable_dispatch();
3001005c: eb001066 bl 300141fc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
30010060: eb002816 bl 3001a0c0 <__errno> <== NOT EXECUTED 30010064: e3a03009 mov r3, #9 <== NOT EXECUTED 30010068: e5803000 str r3, [r0] <== NOT EXECUTED 3001006c: e3e03000 mvn r3, #0 <== NOT EXECUTED 30010070: eaffffc3 b 3000ff84 <_POSIX_Message_queue_Receive_support+0x48><== NOT EXECUTED
3001009c <_POSIX_Message_queue_Send_support>:
size_t msg_len,
unsigned int msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3001009c: 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 )
300100a0: e3530020 cmp r3, #32
size_t msg_len,
unsigned int msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
300100a4: e24dd014 sub sp, sp, #20 300100a8: e1a04003 mov r4, r3 300100ac: e1a05000 mov r5, r0 300100b0: e1a08001 mov r8, r1 300100b4: e1a07002 mov r7, r2 300100b8: e5dd602c ldrb r6, [sp, #44] ; 0x2c
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
300100bc: 8a00002b bhi 30010170 <_POSIX_Message_queue_Send_support+0xd4>
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(
300100c0: e59f00f0 ldr r0, [pc, #240] ; 300101b8 <_POSIX_Message_queue_Send_support+0x11c> 300100c4: e1a01005 mov r1, r5 300100c8: e28d2010 add r2, sp, #16 300100cc: eb000c80 bl 300132d4 <_Objects_Get>
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
300100d0: e59d3010 ldr r3, [sp, #16] 300100d4: e3530000 cmp r3, #0
300100d8: 1a00001f bne 3001015c <_POSIX_Message_queue_Send_support+0xc0>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
300100dc: e5903014 ldr r3, [r0, #20] 300100e0: e3130003 tst r3, #3
300100e4: 0a000026 beq 30010184 <_POSIX_Message_queue_Send_support+0xe8>
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
300100e8: e3560000 cmp r6, #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;
300100ec: e5900010 ldr r0, [r0, #16]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
300100f0: 1a000015 bne 3001014c <_POSIX_Message_queue_Send_support+0xb0>
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
300100f4: e3a0c000 mov ip, #0 300100f8: e58dc000 str ip, [sp] 300100fc: e59dc030 ldr ip, [sp, #48] ; 0x30 30010100: e1a03005 mov r3, r5 30010104: e1a01008 mov r1, r8 30010108: e1a02007 mov r2, r7
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;
3001010c: e2644000 rsb r4, r4, #0
30010110: e280001c add r0, r0, #28
30010114: e98d0050 stmib sp, {r4, r6}
30010118: e58dc00c str ip, [sp, #12]
3001011c: eb000882 bl 3001232c <_CORE_message_queue_Submit>
30010120: e1a04000 mov r4, r0
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
30010124: eb001034 bl 300141fc <_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 )
30010128: e3540007 cmp r4, #7
msg_status = _Thread_Executing->Wait.return_code;
3001012c: 059f3088 ldreq r3, [pc, #136] ; 300101bc <_POSIX_Message_queue_Send_support+0x120> 30010130: 05933008 ldreq r3, [r3, #8] 30010134: 05934034 ldreq r4, [r3, #52] ; 0x34
if ( !msg_status )
30010138: e3540000 cmp r4, #0
3001013c: 1a000016 bne 3001019c <_POSIX_Message_queue_Send_support+0x100>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
30010140: e1a00004 mov r0, r4
30010144: e28dd014 add sp, sp, #20
30010148: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3001014c: e3130901 tst r3, #16384 ; 0x4000 30010150: 13a06000 movne r6, #0 30010154: 03a06001 moveq r6, #1 30010158: eaffffe5 b 300100f4 <_POSIX_Message_queue_Send_support+0x58>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3001015c: eb0027d7 bl 3001a0c0 <__errno> <== NOT EXECUTED 30010160: e3a03009 mov r3, #9 <== NOT EXECUTED 30010164: e5803000 str r3, [r0] <== NOT EXECUTED 30010168: e3e04000 mvn r4, #0 <== NOT EXECUTED 3001016c: eafffff3 b 30010140 <_POSIX_Message_queue_Send_support+0xa4><== NOT EXECUTED
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
30010170: eb0027d2 bl 3001a0c0 <__errno> <== NOT EXECUTED 30010174: e3a03016 mov r3, #22 <== NOT EXECUTED 30010178: e5803000 str r3, [r0] <== NOT EXECUTED 3001017c: e3e04000 mvn r4, #0 <== NOT EXECUTED 30010180: eaffffee b 30010140 <_POSIX_Message_queue_Send_support+0xa4><== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
_Thread_Enable_dispatch();
30010184: eb00101c bl 300141fc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
30010188: eb0027cc bl 3001a0c0 <__errno> <== NOT EXECUTED 3001018c: e3a03009 mov r3, #9 <== NOT EXECUTED 30010190: e5803000 str r3, [r0] <== NOT EXECUTED 30010194: e3e04000 mvn r4, #0 <== NOT EXECUTED 30010198: eaffffe8 b 30010140 <_POSIX_Message_queue_Send_support+0xa4><== NOT EXECUTED
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
return msg_status;
rtems_set_errno_and_return_minus_one(
3001019c: eb0027c7 bl 3001a0c0 <__errno> <== NOT EXECUTED 300101a0: e1a05000 mov r5, r0 <== NOT EXECUTED 300101a4: e1a00004 mov r0, r4 <== NOT EXECUTED 300101a8: eb000058 bl 30010310 <_POSIX_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED 300101ac: e3e04000 mvn r4, #0 <== NOT EXECUTED 300101b0: e5850000 str r0, [r5] <== NOT EXECUTED 300101b4: eaffffe1 b 30010140 <_POSIX_Message_queue_Send_support+0xa4><== NOT EXECUTED
30010310 <_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];
30010310: e59f3004 ldr r3, [pc, #4] ; 3001031c <_POSIX_Message_queue_Translate_core_message_queue_return_code+0xc><== NOT EXECUTED
}
30010314: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 30010318: e12fff1e bx lr <== NOT EXECUTED
30010de8 <_POSIX_Priority_Is_valid>:
bool _POSIX_Priority_Is_valid(
int priority
)
{
return ((priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY) &&
30010de8: e3500000 cmp r0, #0
30010dec: da000005 ble 30010e08 <_POSIX_Priority_Is_valid+0x20>
(priority <= POSIX_SCHEDULER_MAXIMUM_PRIORITY));
30010df0: e59f3018 ldr r3, [pc, #24] ; 30010e10 <_POSIX_Priority_Is_valid+0x28> 30010df4: e5d33000 ldrb r3, [r3]
#endif
#include <rtems/system.h>
#include <rtems/posix/priority.h>
bool _POSIX_Priority_Is_valid(
30010df8: e1500003 cmp r0, r3 30010dfc: a3a00000 movge r0, #0 30010e00: b3a00001 movlt r0, #1 30010e04: e12fff1e bx lr
int priority
)
{
return ((priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY) &&
30010e08: e3a00000 mov r0, #0 <== NOT EXECUTED
(priority <= POSIX_SCHEDULER_MAXIMUM_PRIORITY));
}
30010e0c: e12fff1e bx lr <== NOT EXECUTED
30011e30 <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
30011e30: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
30011e34: e2527000 subs r7, r2, #0
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
30011e38: e1a05000 mov r5, r0 30011e3c: e1a0a001 mov sl, r1 30011e40: e1a08003 mov r8, 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)
30011e44: 1a00002a bne 30011ef4 <_POSIX_Semaphore_Create_support+0xc4>
*
* 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;
30011e48: e59f30f4 ldr r3, [pc, #244] ; 30011f44 <_POSIX_Semaphore_Create_support+0x114> 30011e4c: e5932000 ldr r2, [r3]
++level;
30011e50: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
30011e54: e5832000 str r2, [r3]
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
30011e58: e59f60e8 ldr r6, [pc, #232] ; 30011f48 <_POSIX_Semaphore_Create_support+0x118> 30011e5c: e1a00006 mov r0, r6 30011e60: ebffeed5 bl 3000d9bc <_Objects_Allocate>
rtems_set_errno_and_return_minus_one( ENOSYS );
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
30011e64: e2504000 subs r4, r0, #0
30011e68: 0a000026 beq 30011f08 <_POSIX_Semaphore_Create_support+0xd8>
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
30011e6c: e3550000 cmp r5, #0
30011e70: 0a00001a beq 30011ee0 <_POSIX_Semaphore_Create_support+0xb0>
name = _Workspace_String_duplicate( name_arg, name_len );
30011e74: e1a00005 mov r0, r5 30011e78: e1a0100a mov r1, sl 30011e7c: eb000481 bl 30013088 <_Workspace_String_duplicate>
if ( !name ) {
30011e80: e2505000 subs r5, r0, #0
30011e84: 0a000025 beq 30011f20 <_POSIX_Semaphore_Create_support+0xf0>
}
the_semaphore->process_shared = pshared;
if ( name ) {
the_semaphore->named = true;
30011e88: e3a03001 mov r3, #1
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
30011e8c: e5847010 str r7, [r4, #16]
if ( name ) {
the_semaphore->named = true;
30011e90: e5c43014 strb r3, [r4, #20]
the_semaphore->open_count = 1;
30011e94: e5843018 str r3, [r4, #24]
the_semaphore->linked = true;
30011e98: e5c43015 strb r3, [r4, #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;
30011e9c: e3a07000 mov r7, #0
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
30011ea0: e3e03000 mvn r3, #0
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
30011ea4: e284001c add r0, r4, #28 30011ea8: e284105c add r1, r4, #92 ; 0x5c 30011eac: e1a02008 mov r2, r8
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
30011eb0: e584305c str r3, [r4, #92] ; 0x5c
* 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;
30011eb4: e5847060 str r7, [r4, #96] ; 0x60
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
30011eb8: ebffed33 bl 3000d38c <_CORE_semaphore_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30011ebc: e596301c ldr r3, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
30011ec0: e1d420b8 ldrh r2, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30011ec4: e7834102 str r4, [r3, r2, lsl #2]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
30011ec8: e59d301c ldr r3, [sp, #28]
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
30011ecc: e584500c str r5, [r4, #12] 30011ed0: e5834000 str r4, [r3]
_Thread_Enable_dispatch();
30011ed4: ebfff3cb bl 3000ee08 <_Thread_Enable_dispatch>
return 0;
30011ed8: e1a00007 mov r0, r7
}
30011edc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
30011ee0: e5845010 str r5, [r4, #16]
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
the_semaphore->linked = true;
} else {
the_semaphore->named = false;
30011ee4: e5c45014 strb r5, [r4, #20]
the_semaphore->open_count = 0;
30011ee8: e5845018 str r5, [r4, #24]
the_semaphore->linked = false;
30011eec: e5c45015 strb r5, [r4, #21] 30011ef0: eaffffe9 b 30011e9c <_POSIX_Semaphore_Create_support+0x6c>
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
rtems_set_errno_and_return_minus_one( ENOSYS );
30011ef4: eb000a25 bl 30014790 <__errno> <== NOT EXECUTED
30011ef8: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED
30011efc: e5803000 str r3, [r0] <== NOT EXECUTED
30011f00: e3e00000 mvn r0, #0 <== NOT EXECUTED
30011f04: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
30011f08: ebfff3be bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
30011f0c: eb000a1f bl 30014790 <__errno> <== NOT EXECUTED
30011f10: e3a0301c mov r3, #28 <== NOT EXECUTED
30011f14: e5803000 str r3, [r0] <== NOT EXECUTED
30011f18: e3e00000 mvn r0, #0 <== NOT EXECUTED
30011f1c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
30011f20: e1a00006 mov r0, r6 <== NOT EXECUTED 30011f24: e1a01004 mov r1, r4 <== NOT EXECUTED 30011f28: ebffef81 bl 3000dd34 <_Objects_Free> <== NOT EXECUTED
*/
if ( name_arg != NULL ) {
name = _Workspace_String_duplicate( name_arg, name_len );
if ( !name ) {
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
30011f2c: ebfff3b5 bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
30011f30: eb000a16 bl 30014790 <__errno> <== NOT EXECUTED
30011f34: e3a0300c mov r3, #12 <== NOT EXECUTED
30011f38: e5803000 str r3, [r0] <== NOT EXECUTED
30011f3c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30011f40: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30010e70 <_POSIX_Semaphore_Wait_support>:
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
30010e70: e92d4070 push {r4, r5, r6, lr}
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
30010e74: e5903000 ldr r3, [r0] 30010e78: e24dd004 sub sp, sp, #4 30010e7c: e1a06001 mov r6, r1 30010e80: e1a05002 mov r5, r2 30010e84: e1a01003 mov r1, r3 30010e88: e1a0200d mov r2, sp 30010e8c: e59f007c ldr r0, [pc, #124] ; 30010f10 <_POSIX_Semaphore_Wait_support+0xa0> 30010e90: ebffefa7 bl 3000cd34 <_Objects_Get>
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
30010e94: e59d2000 ldr r2, [sp]
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
30010e98: e20660ff and r6, r6, #255 ; 0xff
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
30010e9c: e3520000 cmp r2, #0 30010ea0: e1a03000 mov r3, r0
30010ea4: 0a000006 beq 30010ec4 <_POSIX_Semaphore_Wait_support+0x54>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
30010ea8: eb0009b7 bl 3001358c <__errno> <== NOT EXECUTED 30010eac: e3a03016 mov r3, #22 <== NOT EXECUTED 30010eb0: e5803000 str r3, [r0] <== NOT EXECUTED 30010eb4: e3e03000 mvn r3, #0 <== NOT EXECUTED
}
30010eb8: e1a00003 mov r0, r3
30010ebc: e28dd004 add sp, sp, #4
30010ec0: e8bd8070 pop {r4, r5, r6, pc}
blocking,
timeout
);
_Thread_Enable_dispatch();
if ( !_Thread_Executing->Wait.return_code )
30010ec4: e59f4048 ldr r4, [pc, #72] ; 30010f14 <_POSIX_Semaphore_Wait_support+0xa4>
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
30010ec8: e5931008 ldr r1, [r3, #8] 30010ecc: e280001c add r0, r0, #28 30010ed0: e1a03005 mov r3, r5 30010ed4: e1a02006 mov r2, r6 30010ed8: eb0001af bl 3001159c <_CORE_semaphore_Seize>
&the_semaphore->Semaphore,
the_semaphore->Object.id,
blocking,
timeout
);
_Thread_Enable_dispatch();
30010edc: ebfff33c bl 3000dbd4 <_Thread_Enable_dispatch>
if ( !_Thread_Executing->Wait.return_code )
30010ee0: e5943008 ldr r3, [r4, #8] 30010ee4: e5933034 ldr r3, [r3, #52] ; 0x34 30010ee8: e3530000 cmp r3, #0
30010eec: 0afffff1 beq 30010eb8 <_POSIX_Semaphore_Wait_support+0x48>
return 0;
rtems_set_errno_and_return_minus_one(
30010ef0: eb0009a5 bl 3001358c <__errno> 30010ef4: e5943008 ldr r3, [r4, #8] 30010ef8: e1a05000 mov r5, r0 30010efc: e5930034 ldr r0, [r3, #52] ; 0x34 30010f00: eb0008cc bl 30013238 <_POSIX_Semaphore_Translate_core_semaphore_return_code> 30010f04: e3e03000 mvn r3, #0 30010f08: e5850000 str r0, [r5] 30010f0c: eaffffe9 b 30010eb8 <_POSIX_Semaphore_Wait_support+0x48>
3000aa70 <_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];
3000aa70: e59f3004 ldr r3, [pc, #4] ; 3000aa7c <_POSIX_Spinlock_Translate_core_spinlock_return_code+0xc><== NOT EXECUTED
}
3000aa74: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000aa78: e12fff1e bx lr <== NOT EXECUTED
3000f99c <_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 ];
3000f99c: e59030f4 ldr r3, [r0, #244] ; 0xf4 <== NOT EXECUTED
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
3000f9a0: e59320d8 ldr r2, [r3, #216] ; 0xd8 <== NOT EXECUTED 3000f9a4: e3520000 cmp r2, #0 <== NOT EXECUTED 3000f9a8: 1a000002 bne 3000f9b8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x1c><== NOT EXECUTED 3000f9ac: e59320dc ldr r2, [r3, #220] ; 0xdc <== NOT EXECUTED 3000f9b0: e3520001 cmp r2, #1 <== NOT EXECUTED 3000f9b4: 0a000000 beq 3000f9bc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x20><== NOT EXECUTED
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
3000f9b8: eafff63c b 3000d2b0 <_Thread_Enable_dispatch> <== NOT EXECUTED
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
3000f9bc: e59330e0 ldr r3, [r3, #224] ; 0xe0 <== NOT EXECUTED 3000f9c0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f9c4: 0afffffb beq 3000f9b8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x1c><== 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;
3000f9c8: e59f3010 ldr r3, [pc, #16] ; 3000f9e0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NOT EXECUTED
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
3000f9cc: e3e01000 mvn r1, #0 <== NOT EXECUTED 3000f9d0: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000f9d4: e0822001 add r2, r2, r1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000f9d8: e5832000 str r2, [r3] <== NOT EXECUTED 3000f9dc: ea0001d1 b 30010128 <_POSIX_Thread_Exit> <== NOT EXECUTED
300123a0 <_POSIX_Thread_Exit>:
void _POSIX_Thread_Exit(
Thread_Control *the_thread,
void *value_ptr
)
{
300123a0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
300123a4: 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 );
300123a8: e5900008 ldr r0, [r0, #8]
void _POSIX_Thread_Exit(
Thread_Control *the_thread,
void *value_ptr
)
{
300123ac: e1a08001 mov r8, r1
Objects_Information *the_information;
Thread_Control *unblocked;
POSIX_API_Control *api;
the_information = _Objects_Get_information_id( the_thread->Object.id );
300123b0: ebffe75d bl 3000c12c <_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();
300123b4: e59f50b4 ldr r5, [pc, #180] ; 30012470 <_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;
300123b8: e59f60b4 ldr r6, [pc, #180] ; 30012474 <_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 );
300123bc: 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();
300123c0: e5950000 ldr r0, [r5]
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 ];
300123c4: e594a0f4 ldr sl, [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();
300123c8: ebffe3ac bl 3000b280 <_API_Mutex_Lock> 300123cc: e5963000 ldr r3, [r6]
++level;
300123d0: e2833001 add r3, r3, #1
_Thread_Dispatch_disable_level = level;
300123d4: e5863000 str r3, [r6]
the_thread->Wait.return_argument = value_ptr;
/*
* Process join
*/
if ( api->detachstate == PTHREAD_CREATE_JOINABLE ) {
300123d8: e59a3040 ldr r3, [sl, #64] ; 0x40
*/
_RTEMS_Lock_allocator();
_Thread_Disable_dispatch();
the_thread->Wait.return_argument = value_ptr;
300123dc: e5848028 str r8, [r4, #40] ; 0x28
/*
* Process join
*/
if ( api->detachstate == PTHREAD_CREATE_JOINABLE ) {
300123e0: e3530001 cmp r3, #1
300123e4: 0a000009 beq 30012410 <_POSIX_Thread_Exit+0x70>
}
/*
* Now shut down the thread
*/
_Thread_Close( the_information, the_thread );
300123e8: e1a00007 mov r0, r7 <== NOT EXECUTED 300123ec: e1a01004 mov r1, r4 <== NOT EXECUTED 300123f0: ebffea6e bl 3000cdb0 <_Thread_Close> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
300123f4: e1a01004 mov r1, r4 <== NOT EXECUTED 300123f8: e59f0078 ldr r0, [pc, #120] ; 30012478 <_POSIX_Thread_Exit+0xd8><== NOT EXECUTED 300123fc: ebffe72d bl 3000c0b8 <_Objects_Free> <== NOT EXECUTED
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
30012400: e5950000 ldr r0, [r5] <== NOT EXECUTED 30012404: ebffe3b9 bl 3000b2f0 <_API_Mutex_Unlock> <== NOT EXECUTED
_Thread_Enable_dispatch(); }
30012408: 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();
3001240c: eaffeb49 b 3000d138 <_Thread_Enable_dispatch> <== NOT EXECUTED
/*
* Process join
*/
if ( api->detachstate == PTHREAD_CREATE_JOINABLE ) {
unblocked = _Thread_queue_Dequeue( &api->Join_List );
30012410: e28aa044 add sl, sl, #68 ; 0x44 30012414: e1a0000a mov r0, sl 30012418: ebffec21 bl 3000d4a4 <_Thread_queue_Dequeue>
if ( unblocked ) {
3001241c: e3500000 cmp r0, #0
30012420: 0a000006 beq 30012440 <_POSIX_Thread_Exit+0xa0>
do {
*(void **)unblocked->Wait.return_argument = value_ptr;
30012424: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
} while ( (unblocked = _Thread_queue_Dequeue( &api->Join_List )) );
30012428: e1a0000a mov r0, sl <== 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;
3001242c: e5838000 str r8, [r3] <== NOT EXECUTED
} while ( (unblocked = _Thread_queue_Dequeue( &api->Join_List )) );
30012430: ebffec1b bl 3000d4a4 <_Thread_queue_Dequeue> <== NOT EXECUTED 30012434: e3500000 cmp r0, #0 <== NOT EXECUTED 30012438: 1afffff9 bne 30012424 <_POSIX_Thread_Exit+0x84> <== NOT EXECUTED 3001243c: eaffffe9 b 300123e8 <_POSIX_Thread_Exit+0x48> <== NOT EXECUTED
} else {
_Thread_Set_state(
30012440: e59f1034 ldr r1, [pc, #52] ; 3001247c <_POSIX_Thread_Exit+0xdc> 30012444: e1a00004 mov r0, r4 30012448: ebffed66 bl 3000d9e8 <_Thread_Set_state>
the_thread,
STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT
);
_RTEMS_Unlock_allocator();
3001244c: e5950000 ldr r0, [r5] 30012450: ebffe3a6 bl 3000b2f0 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
30012454: ebffeb37 bl 3000d138 <_Thread_Enable_dispatch>
/* now waiting for thread to arrive */
_RTEMS_Lock_allocator();
30012458: e5950000 ldr r0, [r5] <== NOT EXECUTED 3001245c: ebffe387 bl 3000b280 <_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;
30012460: e5963000 ldr r3, [r6] <== NOT EXECUTED
++level;
30012464: e2833001 add r3, r3, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30012468: e5863000 str r3, [r6] <== NOT EXECUTED
void _Thread_Disable_dispatch( void );
#else
RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void )
{
_Thread_Dispatch_increment_disable_level();
RTEMS_COMPILER_MEMORY_BARRIER();
3001246c: eaffffdd b 300123e8 <_POSIX_Thread_Exit+0x48> <== NOT EXECUTED
30010e14 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
30010e14: e92d40f0 push {r4, r5, r6, r7, lr}
30010e18: e1a05000 mov r5, r0
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
30010e1c: e5910000 ldr r0, [r1]
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
30010e20: e1a04001 mov r4, r1 30010e24: e1a06002 mov r6, r2 30010e28: e1a07003 mov r7, r3
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
30010e2c: ebffffed bl 30010de8 <_POSIX_Priority_Is_valid> 30010e30: e3500000 cmp r0, #0
30010e34: 1a000001 bne 30010e40 <_POSIX_Thread_Translate_sched_param+0x2c>
(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;
30010e38: e3a00016 mov r0, #22 <== NOT EXECUTED
30010e3c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
30010e40: e3a00000 mov r0, #0
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
30010e44: e1550000 cmp r5, r0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
30010e48: 03a03001 moveq r3, #1
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
30010e4c: e5860000 str r0, [r6]
*budget_callout = NULL;
30010e50: e5870000 str r0, [r7]
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
30010e54: 05863000 streq r3, [r6]
return 0;
30010e58: 01a00005 moveq r0, r5
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
30010e5c: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
30010e60: e3550001 cmp r5, #1
30010e64: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
30010e68: e3550002 cmp r5, #2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
30010e6c: 05865000 streq r5, [r6]
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
30010e70: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
30010e74: e3550004 cmp r5, #4 <== NOT EXECUTED 30010e78: 1affffee bne 30010e38 <_POSIX_Thread_Translate_sched_param+0x24><== NOT EXECUTED
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
30010e7c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30010e80: e3530000 cmp r3, #0 <== NOT EXECUTED 30010e84: 1a000002 bne 30010e94 <_POSIX_Thread_Translate_sched_param+0x80><== NOT EXECUTED 30010e88: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 30010e8c: e3530000 cmp r3, #0 <== NOT EXECUTED 30010e90: 0affffe8 beq 30010e38 <_POSIX_Thread_Translate_sched_param+0x24><== NOT EXECUTED
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
30010e94: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 30010e98: e3530000 cmp r3, #0 <== NOT EXECUTED 30010e9c: 1a000002 bne 30010eac <_POSIX_Thread_Translate_sched_param+0x98><== NOT EXECUTED 30010ea0: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 30010ea4: e3530000 cmp r3, #0 <== NOT EXECUTED 30010ea8: 0affffe2 beq 30010e38 <_POSIX_Thread_Translate_sched_param+0x24><== NOT EXECUTED
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
30010eac: e2840008 add r0, r4, #8 <== NOT EXECUTED 30010eb0: ebfff733 bl 3000eb84 <_Timespec_To_ticks> <== NOT EXECUTED 30010eb4: e1a05000 mov r5, r0 <== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
30010eb8: e2840010 add r0, r4, #16 <== NOT EXECUTED 30010ebc: ebfff730 bl 3000eb84 <_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 ) <
30010ec0: e1550000 cmp r5, r0 <== NOT EXECUTED 30010ec4: 3affffdb bcc 30010e38 <_POSIX_Thread_Translate_sched_param+0x24><== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
30010ec8: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30010ecc: ebffffc5 bl 30010de8 <_POSIX_Priority_Is_valid> <== NOT EXECUTED 30010ed0: e3500000 cmp r0, #0 <== NOT EXECUTED 30010ed4: 1a000001 bne 30010ee0 <_POSIX_Thread_Translate_sched_param+0xcc><== NOT EXECUTED
return EINVAL;
30010ed8: e3a00016 mov r0, #22 <== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
30010edc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
30010ee0: e3a03003 mov r3, #3 <== NOT EXECUTED 30010ee4: e5863000 str r3, [r6] <== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
30010ee8: e59f3008 ldr r3, [pc, #8] ; 30010ef8 <_POSIX_Thread_Translate_sched_param+0xe4><== NOT EXECUTED
return 0;
30010eec: 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;
30010ef0: e5873000 str r3, [r7] <== NOT EXECUTED
return 0;
30010ef4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000fc6c <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
3000fc6c: e92d40f0 push {r4, r5, r6, r7, lr}
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
3000fc70: e1a00001 mov r0, r1
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
3000fc74: e1a06001 mov r6, r1
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
3000fc78: e59170f4 ldr r7, [r1, #244] ; 0xf4
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
3000fc7c: eb000905 bl 30012098 <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
3000fc80: e1a00006 mov r0, r6 3000fc84: eb00091c bl 300120fc <_POSIX_Keys_Run_destructors> 3000fc88: e2874044 add r4, r7, #68 ; 0x44
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
3000fc8c: e5965028 ldr r5, [r6, #40] ; 0x28
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
3000fc90: ea000001 b 3000fc9c <_POSIX_Threads_Delete_extension+0x30>
*(void **)the_thread->Wait.return_argument = value_ptr;
3000fc94: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 3000fc98: e5835000 str r5, [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 )) )
3000fc9c: e1a00004 mov r0, r4 3000fca0: ebfff5ff bl 3000d4a4 <_Thread_queue_Dequeue> 3000fca4: e3500000 cmp r0, #0
3000fca8: 1afffff9 bne 3000fc94 <_POSIX_Threads_Delete_extension+0x28>
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
3000fcac: e5973084 ldr r3, [r7, #132] ; 0x84 3000fcb0: e3530004 cmp r3, #4
3000fcb4: 0a000004 beq 3000fccc <_POSIX_Threads_Delete_extension+0x60>
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
3000fcb8: e3a03000 mov r3, #0
_Workspace_Free( api );
3000fcbc: e1a00007 mov r0, r7
*(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;
3000fcc0: e58630f4 str r3, [r6, #244] ; 0xf4
_Workspace_Free( api );
}
3000fcc4: 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 );
3000fcc8: eafff93c b 3000e1c0 <_Workspace_Free>
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
3000fccc: e28700a8 add r0, r7, #168 ; 0xa8 <== NOT EXECUTED 3000fcd0: ebfff896 bl 3000df30 <_Watchdog_Remove> <== NOT EXECUTED 3000fcd4: eafffff7 b 3000fcb8 <_POSIX_Threads_Delete_extension+0x4c> <== NOT EXECUTED
3000fdf4 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
3000fdf4: 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 ];
3000fdf8: e59140f4 ldr r4, [r1, #244] ; 0xf4 <== NOT EXECUTED
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
3000fdfc: 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 );
3000fe00: e2840098 add r0, r4, #152 ; 0x98 <== NOT EXECUTED 3000fe04: eb000437 bl 30010ee8 <_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);
3000fe08: e59f3054 ldr r3, [pc, #84] ; 3000fe64 <_POSIX_Threads_Sporadic_budget_TSR+0x70><== NOT EXECUTED 3000fe0c: e5942088 ldr r2, [r4, #136] ; 0x88 <== NOT EXECUTED 3000fe10: e5d31000 ldrb r1, [r3] <== 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 ) {
3000fe14: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3000fe18: e0621001 rsb r1, r2, r1 <== NOT EXECUTED 3000fe1c: e3530000 cmp r3, #0 <== NOT EXECUTED
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 );
the_thread->cpu_time_budget = ticks;
3000fe20: e5850074 str r0, [r5, #116] ; 0x74 <== NOT EXECUTED
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
3000fe24: 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 ) {
3000fe28: 1a000002 bne 3000fe38 <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NOT EXECUTED
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
3000fe2c: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3000fe30: e1530001 cmp r3, r1 <== NOT EXECUTED 3000fe34: 8a000006 bhi 3000fe54 <_POSIX_Threads_Sporadic_budget_TSR+0x60><== NOT EXECUTED
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
3000fe38: e2840090 add r0, r4, #144 ; 0x90 <== NOT EXECUTED 3000fe3c: eb000429 bl 30010ee8 <_Timespec_To_ticks> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000fe40: e58400b4 str r0, [r4, #180] ; 0xb4 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000fe44: e59f001c ldr r0, [pc, #28] ; 3000fe68 <_POSIX_Threads_Sporadic_budget_TSR+0x74><== NOT EXECUTED 3000fe48: e28410a8 add r1, r4, #168 ; 0xa8 <== NOT EXECUTED
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
3000fe4c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3000fe50: eafff7c9 b 3000dd7c <_Watchdog_Insert> <== NOT EXECUTED
if ( the_thread->resource_count == 0 ) {
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
_Thread_Change_priority( the_thread, new_priority, true );
3000fe54: e1a00005 mov r0, r5 <== NOT EXECUTED 3000fe58: e3a02001 mov r2, #1 <== NOT EXECUTED 3000fe5c: ebfff382 bl 3000cc6c <_Thread_Change_priority> <== NOT EXECUTED 3000fe60: eafffff4 b 3000fe38 <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NOT EXECUTED
3000fe6c <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000fe6c: e59020f4 ldr r2, [r0, #244] ; 0xf4 <== NOT EXECUTED 3000fe70: e592108c ldr r1, [r2, #140] ; 0x8c <== NOT EXECUTED 3000fe74: e59f2030 ldr r2, [pc, #48] ; 3000feac <_POSIX_Threads_Sporadic_budget_callout+0x40><== NOT EXECUTED 3000fe78: e5d2c000 ldrb ip, [r2] <== 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 ) {
3000fe7c: e590201c ldr r2, [r0, #28] <== NOT EXECUTED 3000fe80: e061100c rsb r1, r1, ip <== NOT EXECUTED 3000fe84: e3520000 cmp r2, #0 <== 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 */
3000fe88: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000fe8c: e5802074 str r2, [r0, #116] ; 0x74 <== NOT EXECUTED
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
3000fe90: 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 ) {
3000fe94: 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 ) {
3000fe98: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000fe9c: e1530001 cmp r3, r1 <== NOT EXECUTED 3000fea0: 212fff1e bxcs lr <== NOT EXECUTED
_Thread_Change_priority( the_thread, new_priority, true );
3000fea4: e3a02001 mov r2, #1 <== NOT EXECUTED 3000fea8: eafff36f b 3000cc6c <_Thread_Change_priority> <== NOT EXECUTED
30012098 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
30012098: 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 ];
3001209c: e59050f4 ldr r5, [r0, #244] ; 0xf4
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
300120a0: e59530e4 ldr r3, [r5, #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 );
300120a4: e28560e8 add r6, r5, #232 ; 0xe8 300120a8: e1530006 cmp r3, r6
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
300120ac: e3a03001 mov r3, #1 300120b0: e58530d8 str r3, [r5, #216] ; 0xd8
while ( !_Chain_Is_empty( handler_stack ) ) {
300120b4: 08bd8070 popeq {r4, r5, r6, pc}
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
300120b8: e10f1000 mrs r1, CPSR <== NOT EXECUTED 300120bc: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 300120c0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Disable( level );
handler = (POSIX_Cancel_Handler_control *)
300120c4: e59540ec ldr r4, [r5, #236] ; 0xec <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
300120c8: e894000c ldm r4, {r2, r3} <== NOT EXECUTED
next->previous = previous;
300120cc: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
300120d0: 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 (
300120d4: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
(*handler->routine)( handler->arg );
300120d8: e594000c ldr r0, [r4, #12] <== NOT EXECUTED 300120dc: e1a0e00f mov lr, pc <== NOT EXECUTED 300120e0: e594f008 ldr pc, [r4, #8] <== NOT EXECUTED
_Workspace_Free( handler );
300120e4: e1a00004 mov r0, r4 <== NOT EXECUTED 300120e8: ebfff034 bl 3000e1c0 <_Workspace_Free> <== NOT EXECUTED
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
300120ec: e59530e4 ldr r3, [r5, #228] ; 0xe4 <== NOT EXECUTED
300120f0: e1530006 cmp r3, r6 <== NOT EXECUTED
300120f4: 1affffef bne 300120b8 <_POSIX_Threads_cancel_run+0x20> <== NOT EXECUTED
300120f8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3001074c <_POSIX_Timer_Insert_helper>:
Watchdog_Interval ticks,
Objects_Id id,
Watchdog_Service_routine_entry TSR,
void *arg
)
{
3001074c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30010750: e1a04000 mov r4, r0 <== NOT EXECUTED
30010754: e1a05001 mov r5, r1 <== NOT EXECUTED
30010758: e1a07002 mov r7, r2 <== NOT EXECUTED
3001075c: e1a08003 mov r8, r3 <== NOT EXECUTED
ISR_Level level;
(void) _Watchdog_Remove( timer );
30010760: ebfff79b bl 3000e5d4 <_Watchdog_Remove> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30010764: e10f6000 mrs r6, CPSR <== NOT EXECUTED 30010768: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3001076c: 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 ) {
30010770: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30010774: e3530000 cmp r3, #0 <== NOT EXECUTED 30010778: 0a000002 beq 30010788 <_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 (
3001077c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
return false;
30010780: e3a00000 mov r0, #0 <== NOT EXECUTED
30010784: 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;
30010788: e5843008 str r3, [r4, #8] <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3001078c: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30010790: e584801c str r8, [r4, #28] <== NOT EXECUTED
the_watchdog->id = id;
30010794: e5847020 str r7, [r4, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
30010798: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001079c: e584500c str r5, [r4, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
300107a0: e59f0010 ldr r0, [pc, #16] ; 300107b8 <_POSIX_Timer_Insert_helper+0x6c><== NOT EXECUTED 300107a4: e1a01004 mov r1, r4 <== NOT EXECUTED 300107a8: ebfff71c bl 3000e420 <_Watchdog_Insert> <== NOT EXECUTED 300107ac: 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;
300107b0: e3a00001 mov r0, #1 <== NOT EXECUTED
}
300107b4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000a5e4 <_POSIX_Timer_TSR>:
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
3000a5e4: e92d40d0 push {r4, r6, r7, lr} <== NOT EXECUTED
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
3000a5e8: e5913068 ldr r3, [r1, #104] ; 0x68 <== NOT EXECUTED
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
3000a5ec: e5912054 ldr r2, [r1, #84] ; 0x54 <== NOT EXECUTED
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
3000a5f0: e2833001 add r3, r3, #1 <== NOT EXECUTED
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
3000a5f4: e3520000 cmp r2, #0 <== NOT EXECUTED
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
3000a5f8: e24dd00c sub sp, sp, #12 <== NOT EXECUTED 3000a5fc: e1a04001 mov r4, r1 <== NOT EXECUTED
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
3000a600: e5813068 str r3, [r1, #104] ; 0x68 <== NOT EXECUTED
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
3000a604: 1a000004 bne 3000a61c <_POSIX_Timer_TSR+0x38> <== NOT EXECUTED 3000a608: e5913058 ldr r3, [r1, #88] ; 0x58 <== NOT EXECUTED 3000a60c: 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;
3000a610: 03a03004 moveq r3, #4 <== NOT EXECUTED 3000a614: 05c1303c strbeq r3, [r1, #60] ; 0x3c <== 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 ) ||
3000a618: 0a00001b beq 3000a68c <_POSIX_Timer_TSR+0xa8> <== NOT EXECUTED
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
3000a61c: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 3000a620: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3000a624: e2840010 add r0, r4, #16 <== NOT EXECUTED 3000a628: e59f3074 ldr r3, [pc, #116] ; 3000a6a4 <_POSIX_Timer_TSR+0xc0><== NOT EXECUTED 3000a62c: e58d4000 str r4, [sp] <== NOT EXECUTED 3000a630: eb001845 bl 3001074c <_POSIX_Timer_Insert_helper> <== NOT EXECUTED
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
3000a634: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a638: 1a000001 bne 3000a644 <_POSIX_Timer_TSR+0x60> <== NOT EXECUTED
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
3000a63c: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000a640: e8bd80d0 pop {r4, r6, r7, pc} <== NOT EXECUTED
3000a644: e59f105c ldr r1, [pc, #92] ; 3000a6a8 <_POSIX_Timer_TSR+0xc4><== NOT EXECUTED
3000a648: e28d0004 add r0, sp, #4 <== NOT EXECUTED
3000a64c: eb0005d2 bl 3000bd9c <_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);
3000a650: e59f2054 ldr r2, [pc, #84] ; 3000a6ac <_POSIX_Timer_TSR+0xc8><== NOT EXECUTED
3000a654: e89000c0 ldm r0, {r6, r7} <== NOT EXECUTED
3000a658: e3a03000 mov r3, #0 <== NOT EXECUTED
3000a65c: e1a00006 mov r0, r6 <== NOT EXECUTED
3000a660: e1a01007 mov r1, r7 <== NOT EXECUTED
3000a664: eb004a6d bl 3001d020 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a668: 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);
3000a66c: e584006c str r0, [r4, #108] ; 0x6c <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a670: e59f2034 ldr r2, [pc, #52] ; 3000a6ac <_POSIX_Timer_TSR+0xc8><== NOT EXECUTED 3000a674: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a678: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a67c: eb004ba2 bl 3001d50c <__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;
3000a680: e3a03003 mov r3, #3 <== NOT EXECUTED 3000a684: e5840070 str r0, [r4, #112] ; 0x70 <== NOT EXECUTED 3000a688: 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 ) ) {
3000a68c: e5940038 ldr r0, [r4, #56] ; 0x38 <== NOT EXECUTED 3000a690: e5941044 ldr r1, [r4, #68] ; 0x44 <== NOT EXECUTED 3000a694: eb00170e bl 300102d4 <pthread_kill> <== NOT EXECUTED
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
3000a698: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a69c: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED 3000a6a0: eaffffe5 b 3000a63c <_POSIX_Timer_TSR+0x58> <== NOT EXECUTED
3000fae4 <_POSIX_signals_Abnormal_termination_handler>:
sigset_t _POSIX_signals_Pending;
void _POSIX_signals_Abnormal_termination_handler(
int signo __attribute__((unused)) )
{
3000fae4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
exit( 1 );
3000fae8: e3a00001 mov r0, #1 <== NOT EXECUTED 3000faec: eb000b61 bl 30012878 <exit> <== NOT EXECUTED
3000c4ec <_POSIX_signals_Alarm_TSR>:
static void _POSIX_signals_Alarm_TSR(
Objects_Id id __attribute__((unused)),
void *argument __attribute__((unused))
)
{
3000c4ec: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
kill( getpid(), SIGALRM );
3000c4f0: ebfff18c bl 30008b28 <getpid> <== NOT EXECUTED 3000c4f4: e3a0100e mov r1, #14 <== NOT EXECUTED
/* XXX can't print from an ISR, should this be fatal? */ }
3000c4f8: 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 );
3000c4fc: ea000051 b 3000c648 <kill> <== NOT EXECUTED
30012194 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
30012194: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
30012198: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED
3001219c: e20230ff and r3, r2, #255 ; 0xff <== 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,
300121a0: e3a0c001 mov ip, #1 <== NOT EXECUTED 300121a4: e28d202c add r2, sp, #44 ; 0x2c <== NOT EXECUTED
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
300121a8: e1a05000 mov r5, r0 <== NOT EXECUTED 300121ac: e1a04001 mov r4, 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,
300121b0: e58dc000 str ip, [sp] <== NOT EXECUTED 300121b4: eb000032 bl 30012284 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 300121b8: e2503000 subs r3, r0, #0 <== NOT EXECUTED 300121bc: 0a000026 beq 3001225c <_POSIX_signals_Check_signal+0xc8> <== NOT EXECUTED
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
300121c0: e59fc0b4 ldr ip, [pc, #180] ; 3001227c <_POSIX_signals_Check_signal+0xe8><== NOT EXECUTED 300121c4: e0848084 add r8, r4, r4, lsl #1 <== NOT EXECUTED 300121c8: e1a08108 lsl r8, r8, #2 <== NOT EXECUTED 300121cc: e08c3008 add r3, ip, r8 <== NOT EXECUTED 300121d0: e593a008 ldr sl, [r3, #8] <== NOT EXECUTED 300121d4: e35a0001 cmp sl, #1 <== NOT EXECUTED
return false;
300121d8: 03a03000 moveq r3, #0 <== NOT EXECUTED
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
300121dc: 0a00001e beq 3001225c <_POSIX_signals_Check_signal+0xc8> <== 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,
300121e0: e59f6098 ldr r6, [pc, #152] ; 30012280 <_POSIX_signals_Check_signal+0xec><== NOT EXECUTED
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
300121e4: e59590d0 ldr r9, [r5, #208] ; 0xd0 <== NOT EXECUTED
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
300121e8: 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,
300121ec: e5967008 ldr r7, [r6, #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;
300121f0: e1833009 orr r3, r3, r9 <== NOT EXECUTED 300121f4: e58530d0 str r3, [r5, #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,
300121f8: e28de004 add lr, sp, #4 <== NOT EXECUTED
300121fc: e2877020 add r7, r7, #32 <== NOT EXECUTED
30012200: e8b7000f ldm r7!, {r0, r1, r2, r3} <== NOT EXECUTED
30012204: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30012208: e8b7000f ldm r7!, {r0, r1, r2, r3} <== NOT EXECUTED
3001220c: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30012210: e8970003 ldm r7, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
30012214: e79c3008 ldr r3, [ip, r8] <== 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,
30012218: e88e0003 stm lr, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
3001221c: e3530002 cmp r3, #2 <== NOT EXECUTED
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
30012220: e1a00004 mov r0, r4 <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
30012224: 0a00000f beq 30012268 <_POSIX_signals_Check_signal+0xd4> <== NOT EXECUTED
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
30012228: e1a0e00f mov lr, pc <== NOT EXECUTED 3001222c: e12fff1a bx sl <== NOT EXECUTED
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
30012230: e596c008 ldr ip, [r6, #8] <== NOT EXECUTED
30012234: e28d4004 add r4, sp, #4 <== NOT EXECUTED
30012238: e28cc020 add ip, ip, #32 <== NOT EXECUTED
3001223c: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
30012240: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30012244: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
30012248: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3001224c: e8940003 ldm r4, {r0, r1} <== NOT EXECUTED
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
30012250: e3a03001 mov r3, #1 <== NOT EXECUTED
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
30012254: e88c0003 stm ip, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
30012258: e58590d0 str r9, [r5, #208] ; 0xd0 <== NOT EXECUTED
return true;
}
3001225c: e1a00003 mov r0, r3 <== NOT EXECUTED
30012260: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
30012264: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
30012268: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 3001226c: e3a02000 mov r2, #0 <== NOT EXECUTED 30012270: e1a0e00f mov lr, pc <== NOT EXECUTED 30012274: e12fff1a bx sl <== NOT EXECUTED
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
30012278: eaffffec b 30012230 <_POSIX_signals_Check_signal+0x9c> <== NOT EXECUTED
300127d0 <_POSIX_signals_Clear_process_signals>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
300127d0: e10f2000 mrs r2, CPSR <== NOT EXECUTED 300127d4: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 300127d8: 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 ) {
300127dc: e59f1050 ldr r1, [pc, #80] ; 30012834 <_POSIX_signals_Clear_process_signals+0x64><== NOT EXECUTED 300127e0: e0803080 add r3, r0, r0, lsl #1 <== NOT EXECUTED 300127e4: e1a03103 lsl r3, r3, #2 <== NOT EXECUTED 300127e8: e7911003 ldr r1, [r1, r3] <== NOT EXECUTED 300127ec: e3510002 cmp r1, #2 <== NOT EXECUTED 300127f0: 0a000007 beq 30012814 <_POSIX_signals_Clear_process_signals+0x44><== NOT EXECUTED
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
300127f4: e59f303c ldr r3, [pc, #60] ; 30012838 <_POSIX_signals_Clear_process_signals+0x68><== NOT EXECUTED 300127f8: e3a0c001 mov ip, #1 <== NOT EXECUTED 300127fc: e5931000 ldr r1, [r3] <== NOT EXECUTED 30012800: e2400001 sub r0, r0, #1 <== NOT EXECUTED 30012804: e1c1001c bic r0, r1, ip, lsl r0 <== NOT EXECUTED 30012808: 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 (
3001280c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
_ISR_Enable( level );
}
30012810: e12fff1e bx lr <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
30012814: e59f1020 ldr r1, [pc, #32] ; 3001283c <_POSIX_signals_Clear_process_signals+0x6c><== NOT EXECUTED 30012818: e083c001 add ip, r3, r1 <== NOT EXECUTED 3001281c: e7931001 ldr r1, [r3, r1] <== 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 );
30012820: e28c3004 add r3, ip, #4 <== NOT EXECUTED 30012824: e1510003 cmp r1, r3 <== NOT EXECUTED 30012828: 0afffff1 beq 300127f4 <_POSIX_signals_Clear_process_signals+0x24><== NOT EXECUTED 3001282c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
30012830: e12fff1e bx lr <== NOT EXECUTED
30012284 <_POSIX_signals_Clear_signals>:
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
30012284: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30012288: e5ddc018 ldrb ip, [sp, #24] <== NOT EXECUTED
3001228c: 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 )
30012290: e35c0000 cmp ip, #0 <== NOT EXECUTED
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
30012294: e1a06002 mov r6, r2 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
30012298: e2411001 sub r1, r1, #1 <== NOT EXECUTED 3001229c: e3a02001 mov r2, #1 <== NOT EXECUTED 300122a0: e1a01112 lsl r1, r2, 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 )
signals_blocked = ~api->signals_blocked;
300122a4: 159020d0 ldrne r2, [r0, #208] ; 0xd0 <== NOT EXECUTED
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
300122a8: 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;
300122ac: 11e02002 mvnne r2, r2 <== NOT EXECUTED
else
signals_blocked = SIGNAL_ALL_MASK;
300122b0: 03e02000 mvneq r2, #0 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
300122b4: e10f5000 mrs r5, CPSR <== NOT EXECUTED 300122b8: e385c080 orr ip, r5, #128 ; 0x80 <== NOT EXECUTED 300122bc: 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 ) {
300122c0: e3530000 cmp r3, #0 <== NOT EXECUTED 300122c4: 0a00000f beq 30012308 <_POSIX_signals_Clear_signals+0x84> <== NOT EXECUTED
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
300122c8: e59f30c0 ldr r3, [pc, #192] ; 30012390 <_POSIX_signals_Clear_signals+0x10c><== NOT EXECUTED 300122cc: e5930000 ldr r0, [r3] <== NOT EXECUTED 300122d0: e0011000 and r1, r1, r0 <== NOT EXECUTED 300122d4: e0110002 ands r0, r1, r2 <== NOT EXECUTED 300122d8: 0a000008 beq 30012300 <_POSIX_signals_Clear_signals+0x7c> <== NOT EXECUTED
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
300122dc: e0843084 add r3, r4, r4, lsl #1 <== NOT EXECUTED 300122e0: e59f20ac ldr r2, [pc, #172] ; 30012394 <_POSIX_signals_Clear_signals+0x110><== NOT EXECUTED 300122e4: e1a03103 lsl r3, r3, #2 <== NOT EXECUTED 300122e8: e7922003 ldr r2, [r2, r3] <== NOT EXECUTED 300122ec: e3520002 cmp r2, #2 <== NOT EXECUTED 300122f0: 0a00000d beq 3001232c <_POSIX_signals_Clear_signals+0xa8> <== NOT EXECUTED
&psiginfo->Node
);
} else
do_callout = false;
}
_POSIX_signals_Clear_process_signals( signo );
300122f4: e1a00004 mov r0, r4 <== NOT EXECUTED 300122f8: eb000134 bl 300127d0 <_POSIX_signals_Clear_process_signals><== NOT EXECUTED
do_callout = true;
300122fc: 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 (
30012300: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
do_callout = true;
}
}
_ISR_Enable( level );
return do_callout;
}
30012304: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
_POSIX_signals_Clear_process_signals( signo );
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
30012308: e590c0d4 ldr ip, [r0, #212] ; 0xd4 <== NOT EXECUTED 3001230c: e001400c and r4, r1, ip <== NOT EXECUTED 30012310: e1140002 tst r4, r2 <== NOT EXECUTED
api->signals_pending &= ~mask;
30012314: 11cc1001 bicne r1, ip, r1 <== NOT EXECUTED 30012318: 158010d4 strne r1, [r0, #212] ; 0xd4 <== NOT EXECUTED
bool do_callout;
POSIX_signals_Siginfo_node *psiginfo;
mask = signo_to_mask( signo );
do_callout = false;
3001231c: 01a00003 moveq r0, r3 <== NOT EXECUTED
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
api->signals_pending &= ~mask;
do_callout = true;
30012320: 13a00001 movne r0, #1 <== NOT EXECUTED 30012324: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
}
}
_ISR_Enable( level );
return do_callout;
}
30012328: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
_ISR_Disable( level );
if ( is_global ) {
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
3001232c: e59f2064 ldr r2, [pc, #100] ; 30012398 <_POSIX_signals_Clear_signals+0x114><== NOT EXECUTED 30012330: e0831002 add r1, r3, r2 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
30012334: e7937002 ldr r7, [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 );
30012338: e2810004 add r0, r1, #4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
3001233c: e1570000 cmp r7, r0 <== NOT EXECUTED 30012340: 0a00000f beq 30012384 <_POSIX_signals_Clear_signals+0x100> <== 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;
30012344: e1a08007 mov r8, r7 <== NOT EXECUTED 30012348: e498c008 ldr ip, [r8], #8 <== NOT EXECUTED
_POSIX_signals_Clear_process_signals( signo );
3001234c: e1a00004 mov r0, r4 <== NOT EXECUTED
head->next = new_first;
30012350: e783c002 str ip, [r3, r2] <== NOT EXECUTED
new_first->previous = head;
30012354: e58c1004 str r1, [ip, #4] <== NOT EXECUTED 30012358: eb00011c bl 300127d0 <_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 ) {
*info = psiginfo->Info;
3001235c: e8980007 ldm r8, {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;
30012360: e59f3034 ldr r3, [pc, #52] ; 3001239c <_POSIX_signals_Clear_signals+0x118><== NOT EXECUTED
30012364: e8860007 stm r6, {r0, r1, r2} <== NOT EXECUTED
30012368: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
the_node->next = tail;
3001236c: e2831004 add r1, r3, #4 <== NOT EXECUTED 30012370: e5871000 str r1, [r7] <== NOT EXECUTED
tail->previous = the_node;
30012374: e5837008 str r7, [r3, #8] <== NOT EXECUTED
old_last->next = the_node;
30012378: e5827000 str r7, [r2] <== NOT EXECUTED
the_node->previous = old_last;
3001237c: e5872004 str r2, [r7, #4] <== NOT EXECUTED 30012380: eaffffdb b 300122f4 <_POSIX_signals_Clear_signals+0x70> <== NOT EXECUTED
if ( is_global ) {
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
_POSIX_signals_Clear_process_signals( signo );
30012384: e1a00004 mov r0, r4 <== NOT EXECUTED 30012388: eb000110 bl 300127d0 <_POSIX_signals_Clear_process_signals><== NOT EXECUTED 3001238c: eaffffd8 b 300122f4 <_POSIX_signals_Clear_signals+0x70> <== NOT EXECUTED
3000fa20 <_POSIX_signals_Post_switch_hook>:
*/
static void _POSIX_signals_Post_switch_hook(
Thread_Control *the_thread
)
{
3000fa20: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* 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;
3000fa24: e59f70b0 ldr r7, [pc, #176] ; 3000fadc <_POSIX_signals_Post_switch_hook+0xbc>
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000fa28: e59050f4 ldr r5, [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;
3000fa2c: e5973008 ldr r3, [r7, #8]
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
3000fa30: e3550000 cmp r5, #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;
3000fa34: e5938034 ldr r8, [r3, #52] ; 0x34
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
3000fa38: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
3000fa3c: e59f609c ldr r6, [pc, #156] ; 3000fae0 <_POSIX_signals_Post_switch_hook+0xc0>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000fa40: e10f3000 mrs r3, CPSR 3000fa44: e3832080 orr r2, r3, #128 ; 0x80 3000fa48: e129f002 msr CPSR_fc, r2
* 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)) ) {
3000fa4c: e5960000 ldr r0, [r6] 3000fa50: e59520d4 ldr r2, [r5, #212] ; 0xd4
* 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 &
3000fa54: e59510d0 ldr r1, [r5, #208] ; 0xd0 3000fa58: e1802002 orr r2, r0, r2 3000fa5c: e1c22001 bic r2, r2, r1
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000fa60: e129f003 msr CPSR_fc, r3 3000fa64: e3520000 cmp r2, #0
3000fa68: 0a000018 beq 3000fad0 <_POSIX_signals_Post_switch_hook+0xb0>
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000fa6c: e3a0401b mov r4, #27 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
3000fa70: e1a01004 mov r1, r4 <== NOT EXECUTED 3000fa74: e3a02000 mov r2, #0 <== NOT EXECUTED 3000fa78: e1a00005 mov r0, r5 <== NOT EXECUTED 3000fa7c: eb0009c4 bl 30012194 <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
3000fa80: e3a02001 mov r2, #1 <== NOT EXECUTED 3000fa84: e1a01004 mov r1, r4 <== NOT EXECUTED 3000fa88: e1a00005 mov r0, r5 <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000fa8c: e0844002 add r4, r4, r2 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
3000fa90: eb0009bf bl 30012194 <_POSIX_signals_Check_signal> <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000fa94: e3540020 cmp r4, #32 <== NOT EXECUTED 3000fa98: 1afffff4 bne 3000fa70 <_POSIX_signals_Post_switch_hook+0x50><== NOT EXECUTED 3000fa9c: e3a04001 mov r4, #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 );
3000faa0: e1a01004 mov r1, r4 <== NOT EXECUTED 3000faa4: e3a02000 mov r2, #0 <== NOT EXECUTED 3000faa8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000faac: eb0009b8 bl 30012194 <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
3000fab0: e3a02001 mov r2, #1 <== NOT EXECUTED 3000fab4: e1a01004 mov r1, r4 <== NOT EXECUTED 3000fab8: e1a00005 mov r0, r5 <== 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++ ) {
3000fabc: e0844002 add r4, r4, r2 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
3000fac0: eb0009b3 bl 30012194 <_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++ ) {
3000fac4: e354001b cmp r4, #27 <== NOT EXECUTED 3000fac8: 1afffff4 bne 3000faa0 <_POSIX_signals_Post_switch_hook+0x80><== NOT EXECUTED 3000facc: eaffffdb b 3000fa40 <_POSIX_signals_Post_switch_hook+0x20> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
}
_Thread_Executing->Wait.return_code = hold_errno;
3000fad0: e5973008 ldr r3, [r7, #8]
3000fad4: e5838034 str r8, [r3, #52] ; 0x34
3000fad8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000a524 <_POSIX_signals_Ualarm_TSR>:
static void _POSIX_signals_Ualarm_TSR(
Objects_Id id __attribute__((unused)),
void *argument __attribute__((unused))
)
{
3000a524: e92d4010 push {r4, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Reset(
Watchdog_Control *the_watchdog
)
{
(void) _Watchdog_Remove( the_watchdog );
3000a528: e59f4020 ldr r4, [pc, #32] ; 3000a550 <_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 );
3000a52c: ebfff0e0 bl 300068b4 <getpid> <== NOT EXECUTED 3000a530: e3a0100e mov r1, #14 <== NOT EXECUTED 3000a534: ebffff7b bl 3000a328 <kill> <== NOT EXECUTED 3000a538: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a53c: eb000fc0 bl 3000e444 <_Watchdog_Remove> <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a540: e59f000c ldr r0, [pc, #12] ; 3000a554 <_POSIX_signals_Ualarm_TSR+0x30><== NOT EXECUTED 3000a544: e1a01004 mov r1, r4 <== NOT EXECUTED
/*
* If the reset interval is non-zero, reschedule ourselves.
*/
_Watchdog_Reset( &_POSIX_signals_Ualarm_timer );
}
3000a548: e8bd4010 pop {r4, lr} <== NOT EXECUTED
3000a54c: ea000f4f b 3000e290 <_Watchdog_Insert> <== NOT EXECUTED
3001df74 <_POSIX_signals_Unblock_thread>:
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
3001df74: e590c010 ldr ip, [r0, #16] <== NOT EXECUTED 3001df78: e59f310c ldr r3, [pc, #268] ; 3001e08c <_POSIX_signals_Unblock_thread+0x118><== NOT EXECUTED
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
3001df7c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
3001df80: e59f7104 ldr r7, [pc, #260] ; 3001e08c <_POSIX_signals_Unblock_thread+0x118><== NOT EXECUTED 3001df84: e00c3003 and r3, ip, r3 <== NOT EXECUTED 3001df88: e2416001 sub r6, r1, #1 <== NOT EXECUTED 3001df8c: e3a05001 mov r5, #1 <== NOT EXECUTED 3001df90: e1530007 cmp r3, r7 <== NOT EXECUTED
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
3001df94: 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 ];
3001df98: e59030f4 ldr r3, [r0, #244] ; 0xf4 <== NOT EXECUTED 3001df9c: e1a06615 lsl r6, r5, r6 <== NOT EXECUTED
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
3001dfa0: 0a000017 beq 3001e004 <_POSIX_signals_Unblock_thread+0x90> <== NOT EXECUTED
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
3001dfa4: e59330d0 ldr r3, [r3, #208] ; 0xd0 <== NOT EXECUTED 3001dfa8: e1d66003 bics r6, r6, r3 <== NOT EXECUTED 3001dfac: 0a000012 beq 3001dffc <_POSIX_signals_Unblock_thread+0x88> <== 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 ) ) {
3001dfb0: e21c6201 ands r6, ip, #268435456 ; 0x10000000 <== NOT EXECUTED 3001dfb4: 0a00000e beq 3001dff4 <_POSIX_signals_Unblock_thread+0x80> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3001dfb8: e59f50d0 ldr r5, [pc, #208] ; 3001e090 <_POSIX_signals_Unblock_thread+0x11c><== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
3001dfbc: e3a03004 mov r3, #4 <== NOT EXECUTED 3001dfc0: e00c5005 and r5, ip, 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) )
3001dfc4: 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;
3001dfc8: e5803034 str r3, [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) )
3001dfcc: 1a00002b bne 3001e080 <_POSIX_signals_Unblock_thread+0x10c><== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
3001dfd0: e21c0008 ands r0, ip, #8 <== NOT EXECUTED
3001dfd4: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
3001dfd8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3001dfdc: ebffbfd3 bl 3000df30 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3001dfe0: e1a00004 mov r0, r4 <== NOT EXECUTED 3001dfe4: e59f10a8 ldr r1, [pc, #168] ; 3001e094 <_POSIX_signals_Unblock_thread+0x120><== NOT EXECUTED 3001dfe8: ebffbb5d bl 3000cd64 <_Thread_Clear_state> <== 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;
3001dfec: e1a00005 mov r0, r5 <== NOT EXECUTED
3001dff0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
3001dff4: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001dff8: 0a000015 beq 3001e054 <_POSIX_signals_Unblock_thread+0xe0> <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
3001dffc: e1a00006 mov r0, r6 <== NOT EXECUTED
3001e000: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
3001e004: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED 3001e008: e1160000 tst r6, r0 <== NOT EXECUTED 3001e00c: 0a00000c beq 3001e044 <_POSIX_signals_Unblock_thread+0xd0> <== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
3001e010: e3a03004 mov r3, #4 <== NOT EXECUTED 3001e014: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
the_info = (siginfo_t *) the_thread->Wait.return_argument;
3001e018: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
if ( !info ) {
3001e01c: e3520000 cmp r2, #0 <== NOT EXECUTED
the_info->si_signo = signo;
3001e020: 05831000 streq r1, [r3] <== NOT EXECUTED
the_info->si_code = SI_USER;
3001e024: 03a01001 moveq r1, #1 <== NOT EXECUTED
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
3001e028: 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;
3001e02c: 09830006 stmibeq r3, {r1, r2} <== NOT EXECUTED
} else {
*the_info = *info;
3001e030: 18830007 stmne r3, {r0, r1, r2} <== NOT EXECUTED
}
_Thread_queue_Extract_with_proxy( the_thread );
3001e034: e1a00004 mov r0, r4 <== NOT EXECUTED 3001e038: ebffbe09 bl 3000d864 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED
return true;
3001e03c: e3a00001 mov r0, #1 <== NOT EXECUTED
3001e040: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
3001e044: e59300d0 ldr r0, [r3, #208] ; 0xd0 <== NOT EXECUTED
3001e048: e1d60000 bics r0, r6, r0 <== NOT EXECUTED
3001e04c: 1affffef bne 3001e010 <_POSIX_signals_Unblock_thread+0x9c> <== NOT EXECUTED
3001e050: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
3001e054: e59f203c ldr r2, [pc, #60] ; 3001e098 <_POSIX_signals_Unblock_thread+0x124><== NOT EXECUTED
3001e058: e5920000 ldr r0, [r2] <== NOT EXECUTED
3001e05c: e3500000 cmp r0, #0 <== NOT EXECUTED
3001e060: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
3001e064: e5923008 ldr r3, [r2, #8] <== NOT EXECUTED
3001e068: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3001e06c: 05c25004 strbeq r5, [r2, #4] <== NOT EXECUTED
}
}
return false;
3001e070: 01a0000c moveq r0, ip <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
3001e074: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
}
}
return false;
3001e078: e1a0000c mov r0, ip <== NOT EXECUTED
}
3001e07c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== 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 );
3001e080: ebffbdf7 bl 3000d864 <_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;
3001e084: e3a00000 mov r0, #0 <== NOT EXECUTED
3001e088: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000c4fc <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000c4fc: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000c500: e59f403c ldr r4, [pc, #60] ; 3000c544 <_Protected_heap_Extend+0x48><== NOT EXECUTED
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000c504: e1a05000 mov r5, r0 <== NOT EXECUTED 3000c508: e1a07001 mov r7, r1 <== NOT EXECUTED 3000c50c: e1a06002 mov r6, r2 <== NOT EXECUTED
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000c510: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000c514: ebfffb6d bl 3000b2d0 <_API_Mutex_Lock> <== NOT EXECUTED
amount_extended = _Heap_Extend( the_heap, starting_address, size, 0 );
3000c518: e1a01007 mov r1, r7 <== NOT EXECUTED 3000c51c: e1a02006 mov r2, r6 <== NOT EXECUTED 3000c520: e3a03000 mov r3, #0 <== NOT EXECUTED 3000c524: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c528: eb0010f5 bl 30010904 <_Heap_Extend> <== NOT EXECUTED 3000c52c: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
3000c530: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000c534: ebfffb81 bl 3000b340 <_API_Mutex_Unlock> <== NOT EXECUTED
return amount_extended != 0;
}
3000c538: e2950000 adds r0, r5, #0 <== NOT EXECUTED
3000c53c: 13a00001 movne r0, #1 <== NOT EXECUTED
3000c540: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30011948 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
30011948: e92d4070 push {r4, r5, r6, lr}
if ( !the_heap )
3001194c: e2505000 subs r5, r0, #0
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
30011950: e1a06001 mov r6, r1
if ( !the_heap )
return false;
30011954: 01a00005 moveq r0, r5
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
if ( !the_heap )
30011958: 08bd8070 popeq {r4, r5, r6, pc}
return false;
if ( !the_info )
3001195c: e3510000 cmp r1, #0
30011960: 0a000009 beq 3001198c <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
30011964: e59f4028 ldr r4, [pc, #40] ; 30011994 <_Protected_heap_Get_information+0x4c> 30011968: e5940000 ldr r0, [r4] 3001196c: ebfff79f bl 3000f7f0 <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
30011970: e1a00005 mov r0, r5 30011974: e1a01006 mov r1, r6 30011978: eb001156 bl 30015ed8 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
3001197c: e5940000 ldr r0, [r4] 30011980: ebfff7b6 bl 3000f860 <_API_Mutex_Unlock>
return true;
30011984: e3a00001 mov r0, #1
30011988: e8bd8070 pop {r4, r5, r6, pc}
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
3001198c: e1a00001 mov r0, r1 <== NOT EXECUTED
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
30011990: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300119fc <_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 )
300119fc: e59f3054 ldr r3, [pc, #84] ; 30011a58 <_Protected_heap_Walk+0x5c><== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30011a00: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30011a04: e5933000 ldr r3, [r3] <== NOT EXECUTED
30011a08: e1a07000 mov r7, r0 <== NOT EXECUTED
30011a0c: e3530000 cmp r3, #0 <== NOT EXECUTED
30011a10: e1a06001 mov r6, r1 <== NOT EXECUTED
30011a14: e20250ff and r5, r2, #255 ; 0xff <== NOT EXECUTED
30011a18: 1a00000b bne 30011a4c <_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();
30011a1c: e59f4038 ldr r4, [pc, #56] ; 30011a5c <_Protected_heap_Walk+0x60><== NOT EXECUTED 30011a20: e5940000 ldr r0, [r4] <== NOT EXECUTED 30011a24: ebfff771 bl 3000f7f0 <_API_Mutex_Lock> <== NOT EXECUTED
status = _Heap_Walk( the_heap, source, do_dump );
30011a28: e1a02005 mov r2, r5 <== NOT EXECUTED 30011a2c: e1a01006 mov r1, r6 <== NOT EXECUTED 30011a30: e1a00007 mov r0, r7 <== NOT EXECUTED 30011a34: ebfffbd8 bl 3001099c <_Heap_Walk> <== NOT EXECUTED 30011a38: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
30011a3c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30011a40: ebfff786 bl 3000f860 <_API_Mutex_Unlock> <== NOT EXECUTED
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
30011a44: e1a00005 mov r0, r5 <== NOT EXECUTED
30011a48: 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 );
30011a4c: e1a02005 mov r2, r5 <== NOT EXECUTED
} return status; }
30011a50: 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 );
30011a54: eafffbd0 b 3001099c <_Heap_Walk> <== NOT EXECUTED
3000d1e8 <_RBTree_Extract_validate_unprotected>:
)
{
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
3000d1e8: e5903000 ldr r3, [r0]
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
RBTree_Node *the_node
)
{
3000d1ec: e92d07f0 push {r4, r5, r6, r7, r8, r9, sl}
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
if(!parent->parent) return;
3000d1f0: e5932000 ldr r2, [r3] 3000d1f4: e3520000 cmp r2, #0
3000d1f8: 0a00002f beq 3000d2bc <_RBTree_Extract_validate_unprotected+0xd4>
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
3000d1fc: e5932004 ldr r2, [r3, #4]
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
3000d200: e3a06000 mov r6, #0 3000d204: e1500002 cmp r0, r2
return the_node->parent->child[RBT_RIGHT];
3000d208: 05932008 ldreq r2, [r3, #8]
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000d20c: e3a05001 mov r5, #1 3000d210: ea000022 b 3000d2a0 <_RBTree_Extract_validate_unprotected+0xb8>
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
3000d214: e5931000 ldr r1, [r3] 3000d218: e3510000 cmp r1, #0
3000d21c: 0a000022 beq 3000d2ac <_RBTree_Extract_validate_unprotected+0xc4>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
3000d220: e3520000 cmp r2, #0
3000d224: 0a000002 beq 3000d234 <_RBTree_Extract_validate_unprotected+0x4c>
3000d228: e592c00c ldr ip, [r2, #12] 3000d22c: e35c0001 cmp ip, #1
3000d230: 0a000023 beq 3000d2c4 <_RBTree_Extract_validate_unprotected+0xdc>
_RBTree_Rotate(parent, dir);
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
3000d234: e5921008 ldr r1, [r2, #8] 3000d238: e3510000 cmp r1, #0
3000d23c: 0a000002 beq 3000d24c <_RBTree_Extract_validate_unprotected+0x64>
3000d240: e591c00c ldr ip, [r1, #12] 3000d244: e35c0001 cmp ip, #1
3000d248: 0a000042 beq 3000d358 <_RBTree_Extract_validate_unprotected+0x170>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
3000d24c: e592c004 ldr ip, [r2, #4] 3000d250: e35c0000 cmp ip, #0
3000d254: 0a000002 beq 3000d264 <_RBTree_Extract_validate_unprotected+0x7c>
3000d258: e59cc00c ldr ip, [ip, #12] 3000d25c: e35c0001 cmp ip, #1
3000d260: 0a00003c beq 3000d358 <_RBTree_Extract_validate_unprotected+0x170>
sibling->color = RBT_RED;
3000d264: e582500c str r5, [r2, #12] 3000d268: e593200c ldr r2, [r3, #12] 3000d26c: e3520001 cmp r2, #1
3000d270: 0a000033 beq 3000d344 <_RBTree_Extract_validate_unprotected+0x15c>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
3000d274: e5931000 ldr r1, [r3]
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
3000d278: e3510000 cmp r1, #0
3000d27c: 0a000033 beq 3000d350 <_RBTree_Extract_validate_unprotected+0x168> if(!(the_node->parent->parent)) return NULL;
3000d280: e5912000 ldr r2, [r1] 3000d284: e3520000 cmp r2, #0
3000d288: 0a000002 beq 3000d298 <_RBTree_Extract_validate_unprotected+0xb0>
if(the_node == the_node->parent->child[RBT_LEFT])
3000d28c: e5912004 ldr r2, [r1, #4] 3000d290: e1530002 cmp r3, r2
return the_node->parent->child[RBT_RIGHT];
3000d294: 05912008 ldreq r2, [r1, #8]
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
c->parent = the_node->parent;
the_node->parent = c;
3000d298: e1a00003 mov r0, r3
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
3000d29c: e1a03001 mov r3, r1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
3000d2a0: e590100c ldr r1, [r0, #12] 3000d2a4: e3510001 cmp r1, #1
3000d2a8: 1affffd9 bne 3000d214 <_RBTree_Extract_validate_unprotected+0x2c>
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
3000d2ac: e5903000 ldr r3, [r0] 3000d2b0: e5933000 ldr r3, [r3] 3000d2b4: e3530000 cmp r3, #0 3000d2b8: 0580300c streq r3, [r0, #12]
}
3000d2bc: e8bd07f0 pop {r4, r5, r6, r7, r8, r9, sl}
3000d2c0: e12fff1e bx lr
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
3000d2c4: e5934004 ldr r4, [r3, #4]
* then rotate parent left, making the sibling be the_node's grandparent.
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
3000d2c8: e583c00c str ip, [r3, #12]
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
3000d2cc: e054a000 subs sl, r4, r0 3000d2d0: 13a0a001 movne sl, #1
* This function maintains the properties of the red-black tree. * * @note It does NOT disable interrupts to ensure the atomicity * of the extract operation. */ static void _RBTree_Extract_validate_unprotected(
3000d2d4: e22a7001 eor r7, sl, #1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
3000d2d8: e2878001 add r8, r7, #1 3000d2dc: e7939108 ldr r9, [r3, r8, lsl #2]
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
3000d2e0: e582600c str r6, [r2, #12] 3000d2e4: e3590000 cmp r9, #0 3000d2e8: 01a02009 moveq r2, r9
3000d2ec: 0affffd0 beq 3000d234 <_RBTree_Extract_validate_unprotected+0x4c>
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000d2f0: e3570000 cmp r7, #0
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
3000d2f4: 15934008 ldrne r4, [r3, #8]
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
3000d2f8: e28a2001 add r2, sl, #1 3000d2fc: e794a102 ldr sl, [r4, r2, lsl #2]
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000d300: 01a0c007 moveq ip, r7
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
3000d304: e28cc001 add ip, ip, #1 3000d308: e783a10c str sl, [r3, ip, lsl #2]
if (c->child[dir])
3000d30c: e794c102 ldr ip, [r4, r2, lsl #2]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
3000d310: e7843102 str r3, [r4, r2, lsl #2]
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
3000d314: e35c0000 cmp ip, #0
c->child[dir]->parent = the_node;
3000d318: 158c3000 strne r3, [ip] 3000d31c: 15931000 ldrne r1, [r3]
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
3000d320: e5912004 ldr r2, [r1, #4]
c->parent = the_node->parent;
3000d324: e5841000 str r1, [r4]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
3000d328: e1530002 cmp r3, r2 3000d32c: 13a02008 movne r2, #8 3000d330: 03a02004 moveq r2, #4 3000d334: e7824001 str r4, [r2, r1]
c->parent = the_node->parent;
the_node->parent = c;
3000d338: e5834000 str r4, [r3] 3000d33c: e7932108 ldr r2, [r3, r8, lsl #2] 3000d340: eaffffbb b 3000d234 <_RBTree_Extract_validate_unprotected+0x4c>
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
3000d344: e3a02000 mov r2, #0 3000d348: e583200c str r2, [r3, #12]
break;
3000d34c: eaffffd6 b 3000d2ac <_RBTree_Extract_validate_unprotected+0xc4>
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
3000d350: e1a02001 mov r2, r1 <== NOT EXECUTED 3000d354: eaffffcf b 3000d298 <_RBTree_Extract_validate_unprotected+0xb0><== NOT EXECUTED
* cases, either the_node is to the left or the right of the parent.
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
3000d358: e5936004 ldr r6, [r3, #4] 3000d35c: e0566000 subs r6, r6, r0 3000d360: 13a06001 movne r6, #1
* This function maintains the properties of the red-black tree. * * @note It does NOT disable interrupts to ensure the atomicity * of the extract operation. */ static void _RBTree_Extract_validate_unprotected(
3000d364: e2265001 eor r5, r6, #1
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
3000d368: e285c001 add ip, r5, #1 3000d36c: e792410c ldr r4, [r2, ip, lsl #2]
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
3000d370: e3540000 cmp r4, #0
3000d374: 0a000003 beq 3000d388 <_RBTree_Extract_validate_unprotected+0x1a0>
3000d378: e594700c ldr r7, [r4, #12] 3000d37c: e3570001 cmp r7, #1 3000d380: 0793710c ldreq r7, [r3, ip, lsl #2]
3000d384: 0a00001f beq 3000d408 <_RBTree_Extract_validate_unprotected+0x220> * This function maintains the properties of the red-black tree. * * @note It does NOT disable interrupts to ensure the atomicity * of the extract operation. */ static void _RBTree_Extract_validate_unprotected(
3000d388: e2254001 eor r4, r5, #1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
3000d38c: e2848001 add r8, r4, #1 3000d390: e792a108 ldr sl, [r2, r8, lsl #2]
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
3000d394: e2867001 add r7, r6, #1 3000d398: e7928107 ldr r8, [r2, r7, lsl #2] 3000d39c: e35a0000 cmp sl, #0
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
3000d3a0: e3a07001 mov r7, #1
sibling->child[dir]->color = RBT_BLACK;
3000d3a4: e3a0a000 mov sl, #0
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
3000d3a8: e582700c str r7, [r2, #12]
sibling->child[dir]->color = RBT_BLACK;
3000d3ac: e588a00c str sl, [r8, #12]
3000d3b0: 0a000011 beq 3000d3fc <_RBTree_Extract_validate_unprotected+0x214>
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000d3b4: e3540000 cmp r4, #0
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
3000d3b8: 05921004 ldreq r1, [r2, #4]
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000d3bc: 11a04007 movne r4, r7
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
3000d3c0: e791810c ldr r8, [r1, ip, lsl #2] 3000d3c4: e2844001 add r4, r4, #1 3000d3c8: e7828104 str r8, [r2, r4, lsl #2]
if (c->child[dir])
3000d3cc: e791410c ldr r4, [r1, ip, lsl #2]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
3000d3d0: e781210c str r2, [r1, ip, lsl #2]
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
3000d3d4: e3540000 cmp r4, #0
c->child[dir]->parent = the_node;
3000d3d8: 15842000 strne r2, [r4]
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
3000d3dc: e5924000 ldr r4, [r2] 3000d3e0: e5947004 ldr r7, [r4, #4]
c->parent = the_node->parent;
3000d3e4: e5814000 str r4, [r1]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
3000d3e8: e1520007 cmp r2, r7 3000d3ec: 13a07008 movne r7, #8 3000d3f0: 03a07004 moveq r7, #4 3000d3f4: e7871004 str r1, [r7, r4]
c->parent = the_node->parent;
the_node->parent = c;
3000d3f8: e5821000 str r1, [r2]
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
3000d3fc: e793210c ldr r2, [r3, ip, lsl #2] 3000d400: e792410c ldr r4, [r2, ip, lsl #2] 3000d404: e1a07002 mov r7, r2
}
sibling->color = parent->color;
3000d408: e593c00c ldr ip, [r3, #12]
parent->color = RBT_BLACK;
3000d40c: e3a01000 mov r1, #0
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
3000d410: e1570001 cmp r7, r1
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
sibling->color = parent->color;
3000d414: e582c00c str ip, [r2, #12]
parent->color = RBT_BLACK;
3000d418: e583100c str r1, [r3, #12]
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
3000d41c: e584100c str r1, [r4, #12]
3000d420: 0affffa1 beq 3000d2ac <_RBTree_Extract_validate_unprotected+0xc4>
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000d424: e1550001 cmp r5, r1
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
3000d428: 05932004 ldreq r2, [r3, #4] 3000d42c: 15932008 ldrne r2, [r3, #8]
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
3000d430: e2866001 add r6, r6, #1 3000d434: e7921106 ldr r1, [r2, r6, lsl #2]
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000d438: 13a05001 movne r5, #1
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
3000d43c: e2855001 add r5, r5, #1 3000d440: e7831105 str r1, [r3, r5, lsl #2]
if (c->child[dir])
3000d444: e7921106 ldr r1, [r2, r6, lsl #2]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
3000d448: e7823106 str r3, [r2, r6, lsl #2]
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
3000d44c: e3510000 cmp r1, #0
c->child[dir]->parent = the_node;
3000d450: 15813000 strne r3, [r1]
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
3000d454: e5931000 ldr r1, [r3] 3000d458: e591c004 ldr ip, [r1, #4]
c->parent = the_node->parent;
3000d45c: e5821000 str r1, [r2]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
3000d460: e153000c cmp r3, ip 3000d464: 13a0c008 movne ip, #8 3000d468: 03a0c004 moveq ip, #4 3000d46c: e78c2001 str r2, [ip, r1]
c->parent = the_node->parent;
the_node->parent = c;
3000d470: e5832000 str r2, [r3] 3000d474: eaffff8c b 3000d2ac <_RBTree_Extract_validate_unprotected+0xc4>
3000d898 <_RBTree_Iterate_unprotected>:
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
3000d898: e3510000 cmp r1, #0 <== NOT EXECUTED
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
3000d89c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000d8a0: e1a05001 mov r5, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
3000d8a4: 13a01002 movne r1, #2 <== NOT EXECUTED 3000d8a8: 03a01003 moveq r1, #3 <== NOT EXECUTED 3000d8ac: e7904101 ldr r4, [r0, r1, lsl #2] <== NOT EXECUTED 3000d8b0: e1a06002 mov r6, r2 <== 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 ) {
3000d8b4: e3540000 cmp r4, #0 <== NOT EXECUTED
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
3000d8b8: e1a07003 mov r7, r3 <== 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 ) {
3000d8bc: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
stop = (*visitor)( current, dir, visitor_arg );
3000d8c0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d8c4: e1a02007 mov r2, r7 <== NOT EXECUTED 3000d8c8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000d8cc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000d8d0: e12fff16 bx r6 <== NOT EXECUTED
current = _RBTree_Next_unprotected( current, dir );
3000d8d4: e1a01005 mov r1, r5 <== 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 );
3000d8d8: e1a08000 mov r8, r0 <== NOT EXECUTED
current = _RBTree_Next_unprotected( current, dir );
3000d8dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d8e0: eb000005 bl 3000d8fc <_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 ) {
3000d8e4: e3580000 cmp r8, #0 <== NOT EXECUTED
stop = (*visitor)( current, dir, visitor_arg );
current = _RBTree_Next_unprotected( current, dir );
3000d8e8: e1a04000 mov r4, 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 ) {
3000d8ec: 18bd81f0 popne {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000d8f0: e3500000 cmp r0, #0 <== NOT EXECUTED
3000d8f4: 1afffff1 bne 3000d8c0 <_RBTree_Iterate_unprotected+0x28> <== NOT EXECUTED
3000d8f8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000d8fc <_RBTree_Next_unprotected>:
const RBTree_Node *node,
RBTree_Direction dir
)
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
RBTree_Node *current = node->child [dir];
3000d8fc: e2812001 add r2, r1, #1 3000d900: e7903102 ldr r3, [r0, r2, lsl #2]
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000d904: e2711001 rsbs r1, r1, #1 3000d908: 33a01000 movcc r1, #0
RBTree_Node *next = NULL;
if ( current != NULL ) {
3000d90c: e3530000 cmp r3, #0 3000d910: 12811001 addne r1, r1, #1
3000d914: 1a000001 bne 3000d920 <_RBTree_Next_unprotected+0x24>
3000d918: ea000005 b 3000d934 <_RBTree_Next_unprotected+0x38>
next = current;
while ( (current = current->child [opp_dir]) != NULL ) {
3000d91c: e1a03002 mov r3, r2 <== NOT EXECUTED
3000d920: e7932101 ldr r2, [r3, r1, lsl #2] 3000d924: e3520000 cmp r2, #0
3000d928: 1afffffb bne 3000d91c <_RBTree_Next_unprotected+0x20>
next = current;
}
} else {
RBTree_Node *parent = node->parent;
if ( parent->parent && node == parent->child [opp_dir] ) {
3000d92c: e1a00003 mov r0, r3 3000d930: e12fff1e bx lr
next = current;
while ( (current = current->child [opp_dir]) != NULL ) {
next = current;
}
} else {
RBTree_Node *parent = node->parent;
3000d934: e5903000 ldr r3, [r0]
if ( parent->parent && node == parent->child [opp_dir] ) {
3000d938: e593c000 ldr ip, [r3] 3000d93c: e35c0000 cmp ip, #0
3000d940: 0a00000d beq 3000d97c <_RBTree_Next_unprotected+0x80>
3000d944: e2811001 add r1, r1, #1 3000d948: e7931101 ldr r1, [r3, r1, lsl #2] 3000d94c: e1510000 cmp r1, r0
3000d950: 1a000002 bne 3000d960 <_RBTree_Next_unprotected+0x64>
3000d954: eafffff4 b 3000d92c <_RBTree_Next_unprotected+0x30>
next = parent;
} else {
while ( parent->parent && node == parent->child [dir] ) {
3000d958: e1a0300c mov r3, ip 3000d95c: e59cc000 ldr ip, [ip] 3000d960: e35c0000 cmp ip, #0
3000d964: 0a000004 beq 3000d97c <_RBTree_Next_unprotected+0x80>
3000d968: e7931102 ldr r1, [r3, r2, lsl #2] 3000d96c: e1510000 cmp r1, r0 3000d970: e1a00003 mov r0, r3
3000d974: 0afffff7 beq 3000d958 <_RBTree_Next_unprotected+0x5c>
}
}
}
return next;
}
3000d978: e12fff1e bx lr
RBTree_Direction dir
)
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
RBTree_Node *current = node->child [dir];
RBTree_Node *next = NULL;
3000d97c: e3a00000 mov r0, #0 3000d980: e12fff1e bx lr
300102b0 <_RTEMS_tasks_Delete_extension>:
static void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
300102b0: e92d4030 push {r4, r5, lr}
300102b4: e1a05001 mov r5, r1
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
300102b8: e59110fc ldr r1, [r1, #252] ; 0xfc
deleted->task_variables = NULL;
300102bc: e3a03000 mov r3, #0
while (tvp) {
300102c0: e3510000 cmp r1, #0
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
300102c4: e58530fc str r3, [r5, #252] ; 0xfc
while (tvp) {
300102c8: 1a000001 bne 300102d4 <_RTEMS_tasks_Delete_extension+0x24>
300102cc: ea000005 b 300102e8 <_RTEMS_tasks_Delete_extension+0x38>
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
tvp = next;
300102d0: e1a01004 mov r1, r4 <== NOT EXECUTED
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
300102d4: e5914000 ldr r4, [r1] <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
300102d8: e1a00005 mov r0, r5 <== NOT EXECUTED 300102dc: eb00003f bl 300103e0 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
300102e0: e3540000 cmp r4, #0 <== NOT EXECUTED 300102e4: 1afffff9 bne 300102d0 <_RTEMS_tasks_Delete_extension+0x20> <== NOT EXECUTED
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
300102e8: e59500f0 ldr r0, [r5, #240] ; 0xf0 300102ec: ebfff7b3 bl 3000e1c0 <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
300102f0: e3a03000 mov r3, #0 300102f4: e58530f0 str r3, [r5, #240] ; 0xf0
}
300102f8: e8bd8030 pop {r4, r5, pc}
30010230 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
30010230: e59030fc ldr r3, [r0, #252] ; 0xfc
while (tvp) {
30010234: e3530000 cmp r3, #0
30010238: 0a000007 beq 3001025c <_RTEMS_tasks_Switch_extension+0x2c>
tvp->tval = *tvp->ptr;
3001023c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
30010240: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
30010244: e592c000 ldr ip, [r2] <== NOT EXECUTED 30010248: e583c00c str ip, [r3, #12] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
3001024c: e5820000 str r0, [r2] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
30010250: e5933000 ldr r3, [r3] <== NOT EXECUTED
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
30010254: e3530000 cmp r3, #0 <== NOT EXECUTED 30010258: 1afffff7 bne 3001023c <_RTEMS_tasks_Switch_extension+0xc> <== NOT EXECUTED
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
3001025c: e59130fc ldr r3, [r1, #252] ; 0xfc
while (tvp) {
30010260: e3530000 cmp r3, #0 30010264: 012fff1e bxeq lr
tvp->gval = *tvp->ptr;
30010268: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
3001026c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
30010270: e5920000 ldr r0, [r2] <== NOT EXECUTED 30010274: e5830008 str r0, [r3, #8] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
30010278: e5821000 str r1, [r2] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
3001027c: e5933000 ldr r3, [r3] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
30010280: e3530000 cmp r3, #0 <== NOT EXECUTED 30010284: 1afffff7 bne 30010268 <_RTEMS_tasks_Switch_extension+0x38> <== NOT EXECUTED 30010288: e12fff1e bx lr <== NOT EXECUTED
300374b8 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
300374b8: e92d4010 push {r4, lr} <== NOT EXECUTED
300374bc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
300374c0: e1a01000 mov r1, r0 <== NOT EXECUTED
300374c4: e1a0200d mov r2, sp <== NOT EXECUTED
300374c8: e59f0094 ldr r0, [pc, #148] ; 30037564 <_Rate_monotonic_Timeout+0xac><== NOT EXECUTED
300374cc: ebff555f bl 3000ca50 <_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 ) {
300374d0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300374d4: e1a04000 mov r4, r0 <== NOT EXECUTED 300374d8: e3530000 cmp r3, #0 <== NOT EXECUTED 300374dc: 1a000010 bne 30037524 <_Rate_monotonic_Timeout+0x6c> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_thread = the_period->owner;
300374e0: 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);
300374e4: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
300374e8: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 300374ec: 0a000003 beq 30037500 <_Rate_monotonic_Timeout+0x48> <== NOT EXECUTED 300374f0: e5902020 ldr r2, [r0, #32] <== NOT EXECUTED 300374f4: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 300374f8: e1520003 cmp r2, r3 <== NOT EXECUTED 300374fc: 0a000014 beq 30037554 <_Rate_monotonic_Timeout+0x9c> <== 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 ) {
30037500: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 30037504: 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;
30037508: 13a03004 movne r3, #4 <== NOT EXECUTED 3003750c: 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 ) {
30037510: 0a000005 beq 3003752c <_Rate_monotonic_Timeout+0x74> <== 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;
30037514: e59f304c ldr r3, [pc, #76] ; 30037568 <_Rate_monotonic_Timeout+0xb0><== NOT EXECUTED 30037518: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3003751c: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30037520: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
30037524: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30037528: e8bd8010 pop {r4, pc} <== NOT EXECUTED
_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 ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
3003752c: e3a03003 mov r3, #3 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
30037530: e1a00004 mov r0, r4 <== NOT EXECUTED
_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 ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
30037534: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
30037538: ebffff49 bl 30037264 <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3003753c: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30037540: e59f0024 ldr r0, [pc, #36] ; 3003756c <_Rate_monotonic_Timeout+0xb4><== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30037544: e584301c str r3, [r4, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30037548: e2841010 add r1, r4, #16 <== NOT EXECUTED 3003754c: ebff5bf8 bl 3000e534 <_Watchdog_Insert> <== NOT EXECUTED 30037550: eaffffef b 30037514 <_Rate_monotonic_Timeout+0x5c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30037554: e59f1014 ldr r1, [pc, #20] ; 30037570 <_Rate_monotonic_Timeout+0xb8><== NOT EXECUTED 30037558: ebff57ef bl 3000d51c <_Thread_Clear_state> <== NOT EXECUTED
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
3003755c: e1a00004 mov r0, r4 <== NOT EXECUTED 30037560: eafffff4 b 30037538 <_Rate_monotonic_Timeout+0x80> <== NOT EXECUTED
3000de08 <_Scheduler_CBS_Attach_thread>:
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000de08: e92d4070 push {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 )
3000de0c: e59f3098 ldr r3, [pc, #152] ; 3000deac <_Scheduler_CBS_Attach_thread+0xa4><== NOT EXECUTED
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000de10: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000de14: e5933000 ldr r3, [r3] <== NOT EXECUTED
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000de18: e1a04000 mov r4, r0 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000de1c: e1530000 cmp r3, r0 <== NOT EXECUTED
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000de20: e1a05001 mov r5, r1 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000de24: 9a00001c bls 3000de9c <_Scheduler_CBS_Attach_thread+0x94> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
the_thread = _Thread_Get(task_id, &location);
3000de28: e1a00001 mov r0, r1 <== NOT EXECUTED 3000de2c: e1a0100d mov r1, sp <== NOT EXECUTED 3000de30: eb0003fa bl 3000ee20 <_Thread_Get> <== NOT EXECUTED
/* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread )
3000de34: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000de38: 0a000017 beq 3000de9c <_Scheduler_CBS_Attach_thread+0x94> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000de3c: eb0003ef bl 3000ee00 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
3000de40: e5962088 ldr r2, [r6, #136] ; 0x88 <== NOT EXECUTED
/* Thread is already attached to a server. */
if ( sched_info->cbs_server )
3000de44: e5920018 ldr r0, [r2, #24] <== NOT EXECUTED 3000de48: e3500000 cmp r0, #0 <== NOT EXECUTED 3000de4c: 1a000014 bne 3000dea4 <_Scheduler_CBS_Attach_thread+0x9c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
3000de50: e59f3058 ldr r3, [pc, #88] ; 3000deb0 <_Scheduler_CBS_Attach_thread+0xa8><== NOT EXECUTED 3000de54: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000de58: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000de5c: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000de60: 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] )
3000de64: 0a00000a beq 3000de94 <_Scheduler_CBS_Attach_thread+0x8c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Server is already attached to a thread. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != -1 )
3000de68: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000de6c: e3710001 cmn r1, #1 <== NOT EXECUTED 3000de70: 1a00000b bne 3000dea4 <_Scheduler_CBS_Attach_thread+0x9c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
_Scheduler_CBS_Server_list[server_id]->task_id = task_id;
3000de74: e5835000 str r5, [r3] <== NOT EXECUTED
sched_info->cbs_server = (void *) _Scheduler_CBS_Server_list[server_id];
3000de78: e5823018 str r3, [r2, #24] <== NOT EXECUTED
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
3000de7c: e59f3030 ldr r3, [pc, #48] ; 3000deb4 <_Scheduler_CBS_Attach_thread+0xac><== NOT EXECUTED 3000de80: e586307c str r3, [r6, #124] ; 0x7c <== NOT EXECUTED
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
3000de84: e3a03003 mov r3, #3 <== NOT EXECUTED 3000de88: e5863078 str r3, [r6, #120] ; 0x78 <== NOT EXECUTED
the_thread->is_preemptible = true;
3000de8c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000de90: e5c63070 strb r3, [r6, #112] ; 0x70 <== NOT EXECUTED
return SCHEDULER_CBS_OK;
}
3000de94: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000de98: e8bd8070 pop {r4, r5, r6, pc} <== 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;
3000de9c: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000dea0: eafffffb b 3000de94 <_Scheduler_CBS_Attach_thread+0x8c> <== 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;
3000dea4: e3e00019 mvn r0, #25 <== NOT EXECUTED 3000dea8: eafffff9 b 3000de94 <_Scheduler_CBS_Attach_thread+0x8c> <== NOT EXECUTED
3000e340 <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
3000e340: e92d4010 push {r4, lr} <== NOT EXECUTED
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;
3000e344: e59010ac ldr r1, [r0, #172] ; 0xac <== NOT EXECUTED
if ( the_thread->real_priority != new_priority )
3000e348: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
3000e34c: e24dd004 sub sp, sp, #4 <== 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 )
3000e350: e1530001 cmp r3, r1 <== NOT EXECUTED
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
3000e354: 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;
3000e358: 15801018 strne r1, [r0, #24] <== NOT EXECUTED
if ( the_thread->current_priority != new_priority )
3000e35c: e1530001 cmp r3, r1 <== NOT EXECUTED
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
3000e360: 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);
3000e364: 13a02001 movne r2, #1 <== NOT EXECUTED 3000e368: 1b000171 blne 3000e934 <_Thread_Change_priority> <== NOT EXECUTED
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
3000e36c: e5944088 ldr r4, [r4, #136] ; 0x88 <== NOT EXECUTED
if ( sched_info->cbs_server->cbs_budget_overrun ) {
3000e370: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 3000e374: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000e378: e3520000 cmp r2, #0 <== NOT EXECUTED 3000e37c: 0a000006 beq 3000e39c <_Scheduler_CBS_Budget_callout+0x5c> <== NOT EXECUTED
_Scheduler_CBS_Get_server_id(
3000e380: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e384: e1a0100d mov r1, sp <== NOT EXECUTED 3000e388: ebffffd3 bl 3000e2dc <_Scheduler_CBS_Get_server_id> <== NOT EXECUTED
sched_info->cbs_server->task_id,
&server_id
);
sched_info->cbs_server->cbs_budget_overrun( server_id );
3000e38c: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 3000e390: e59d0000 ldr r0, [sp] <== NOT EXECUTED 3000e394: e1a0e00f mov lr, pc <== NOT EXECUTED 3000e398: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
} }
3000e39c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000e3a0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000deb8 <_Scheduler_CBS_Cleanup>:
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Cleanup (void)
{
3000deb8: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000debc: e59f5058 ldr r5, [pc, #88] ; 3000df1c <_Scheduler_CBS_Cleanup+0x64><== NOT EXECUTED 3000dec0: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000dec4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000dec8: 0a000010 beq 3000df10 <_Scheduler_CBS_Cleanup+0x58> <== NOT EXECUTED 3000decc: e59f604c ldr r6, [pc, #76] ; 3000df20 <_Scheduler_CBS_Cleanup+0x68><== NOT EXECUTED 3000ded0: e3a04000 mov r4, #0 <== NOT EXECUTED 3000ded4: e5962000 ldr r2, [r6] <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[ i ] )
3000ded8: e7923104 ldr r3, [r2, r4, lsl #2] <== NOT EXECUTED
_Scheduler_CBS_Destroy_server( i );
3000dedc: e1a00004 mov r0, r4 <== NOT EXECUTED
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[ i ] )
3000dee0: e3530000 cmp r3, #0 <== NOT EXECUTED
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000dee4: e2844001 add r4, r4, #1 <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[ i ] )
3000dee8: 0a000001 beq 3000def4 <_Scheduler_CBS_Cleanup+0x3c> <== NOT EXECUTED
_Scheduler_CBS_Destroy_server( i );
3000deec: eb000043 bl 3000e000 <_Scheduler_CBS_Destroy_server> <== NOT EXECUTED 3000def0: e5962000 ldr r2, [r6] <== NOT EXECUTED
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000def4: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000def8: e1530004 cmp r3, r4 <== NOT EXECUTED 3000defc: 8afffff5 bhi 3000ded8 <_Scheduler_CBS_Cleanup+0x20> <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
3000df00: e1a00002 mov r0, r2 <== NOT EXECUTED 3000df04: eb0007df bl 3000fe88 <_Workspace_Free> <== NOT EXECUTED
return SCHEDULER_CBS_OK; }
3000df08: e3a00000 mov r0, #0 <== NOT EXECUTED
3000df0c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000df10: e59f3008 ldr r3, [pc, #8] ; 3000df20 <_Scheduler_CBS_Cleanup+0x68><== NOT EXECUTED 3000df14: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000df18: eafffff8 b 3000df00 <_Scheduler_CBS_Cleanup+0x48> <== NOT EXECUTED
3000df24 <_Scheduler_CBS_Create_server>:
)
{
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
3000df24: 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
)
{
3000df28: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
3000df2c: 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
)
{
3000df30: e1a04000 mov r4, r0 <== NOT EXECUTED 3000df34: e1a05001 mov r5, r1 <== NOT EXECUTED 3000df38: e1a07002 mov r7, r2 <== NOT EXECUTED
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
3000df3c: da000029 ble 3000dfe8 <_Scheduler_CBS_Create_server+0xc4> <== NOT EXECUTED 3000df40: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000df44: e3530000 cmp r3, #0 <== NOT EXECUTED 3000df48: da000026 ble 3000dfe8 <_Scheduler_CBS_Create_server+0xc4> <== 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++ ) {
3000df4c: e59f30a4 ldr r3, [pc, #164] ; 3000dff8 <_Scheduler_CBS_Create_server+0xd4><== NOT EXECUTED 3000df50: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000df54: e3500000 cmp r0, #0 <== NOT EXECUTED 3000df58: 0a00000d beq 3000df94 <_Scheduler_CBS_Create_server+0x70> <== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[i] )
3000df5c: e59f8098 ldr r8, [pc, #152] ; 3000dffc <_Scheduler_CBS_Create_server+0xd8><== NOT EXECUTED 3000df60: e5986000 ldr r6, [r8] <== NOT EXECUTED 3000df64: e596a000 ldr sl, [r6] <== NOT EXECUTED 3000df68: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000df6c: 11a02006 movne r2, r6 <== NOT EXECUTED 3000df70: 13a03000 movne r3, #0 <== NOT EXECUTED 3000df74: 1a000003 bne 3000df88 <_Scheduler_CBS_Create_server+0x64> <== NOT EXECUTED 3000df78: ea000018 b 3000dfe0 <_Scheduler_CBS_Create_server+0xbc> <== NOT EXECUTED 3000df7c: e5b21004 ldr r1, [r2, #4]! <== NOT EXECUTED 3000df80: e3510000 cmp r1, #0 <== NOT EXECUTED 3000df84: 0a000004 beq 3000df9c <_Scheduler_CBS_Create_server+0x78> <== 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++ ) {
3000df88: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000df8c: e1530000 cmp r3, r0 <== NOT EXECUTED 3000df90: 1afffff9 bne 3000df7c <_Scheduler_CBS_Create_server+0x58> <== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
3000df94: e3e00019 mvn r0, #25 <== NOT EXECUTED
3000df98: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== 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++ ) {
3000df9c: e1a0a103 lsl sl, r3, #2 <== NOT EXECUTED
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
3000dfa0: e5873000 str r3, [r7] <== NOT EXECUTED
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
3000dfa4: e3a00010 mov r0, #16 <== NOT EXECUTED 3000dfa8: eb0007b0 bl 3000fe70 <_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 *)
3000dfac: e786000a str r0, [r6, sl] <== NOT EXECUTED
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
3000dfb0: e5972000 ldr r2, [r7] <== NOT EXECUTED 3000dfb4: e5983000 ldr r3, [r8] <== NOT EXECUTED 3000dfb8: e7933102 ldr r3, [r3, r2, lsl #2] <== NOT EXECUTED
if ( !the_server )
3000dfbc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000dfc0: 0a00000a beq 3000dff0 <_Scheduler_CBS_Create_server+0xcc> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
the_server->task_id = -1;
3000dfc4: 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;
3000dfc8: e89400c0 ldm r4, {r6, r7} <== NOT EXECUTED
the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback; return SCHEDULER_CBS_OK;
3000dfcc: e3a00000 mov r0, #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;
3000dfd0: e98300c0 stmib r3, {r6, r7} <== NOT EXECUTED
the_server->task_id = -1;
3000dfd4: e5832000 str r2, [r3] <== NOT EXECUTED
the_server->cbs_budget_overrun = budget_overrun_callback;
3000dfd8: e583500c str r5, [r3, #12] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000dfdc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
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++ ) {
if ( !_Scheduler_CBS_Server_list[i] )
3000dfe0: e1a0300a mov r3, sl <== NOT EXECUTED 3000dfe4: eaffffed b 3000dfa0 <_Scheduler_CBS_Create_server+0x7c> <== 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;
3000dfe8: e3e00011 mvn r0, #17 <== NOT EXECUTED
3000dfec: e8bd85f0 pop {r4, r5, r6, r7, r8, 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;
3000dff0: 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;
}
3000dff4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000e000 <_Scheduler_CBS_Destroy_server>:
)
{
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e000: e59f3068 ldr r3, [pc, #104] ; 3000e070 <_Scheduler_CBS_Destroy_server+0x70><== NOT EXECUTED
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
3000e004: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e008: e5933000 ldr r3, [r3] <== NOT EXECUTED
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
3000e00c: e1a04000 mov r4, r0 <== NOT EXECUTED
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e010: e1530000 cmp r3, r0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000e014: 93e06011 mvnls r6, #17 <== NOT EXECUTED
)
{
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e018: 9a000012 bls 3000e068 <_Scheduler_CBS_Destroy_server+0x68> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000e01c: e59f5050 ldr r5, [pc, #80] ; 3000e074 <_Scheduler_CBS_Destroy_server+0x74><== NOT EXECUTED 3000e020: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000e024: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000e028: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000e02c: 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] )
3000e030: 0a00000c beq 3000e068 <_Scheduler_CBS_Destroy_server+0x68> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( (tid = _Scheduler_CBS_Server_list[server_id]->task_id) != -1 )
3000e034: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000e038: e3710001 cmn r1, #1 <== NOT EXECUTED
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
int ret = SCHEDULER_CBS_OK;
3000e03c: 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 )
3000e040: 0a000003 beq 3000e054 <_Scheduler_CBS_Destroy_server+0x54> <== NOT EXECUTED
ret = _Scheduler_CBS_Detach_thread ( server_id, tid );
3000e044: eb00000b bl 3000e078 <_Scheduler_CBS_Detach_thread> <== NOT EXECUTED 3000e048: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000e04c: e1a06000 mov r6, r0 <== NOT EXECUTED 3000e050: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED
_Workspace_Free( _Scheduler_CBS_Server_list[server_id] );
3000e054: e1a00003 mov r0, r3 <== NOT EXECUTED 3000e058: eb00078a bl 3000fe88 <_Workspace_Free> <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id] = NULL;
3000e05c: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000e060: e3a02000 mov r2, #0 <== NOT EXECUTED 3000e064: e7832104 str r2, [r3, r4, lsl #2] <== NOT EXECUTED
return ret; }
3000e068: e1a00006 mov r0, r6 <== NOT EXECUTED
3000e06c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000e078 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000e078: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000e07c: e1a05001 mov r5, r1 <== NOT EXECUTED
3000e080: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000e084: e1a04000 mov r4, r0 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
the_thread = _Thread_Get(task_id, &location);
3000e088: e1a0100d mov r1, sp <== NOT EXECUTED 3000e08c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000e090: eb000362 bl 3000ee20 <_Thread_Get> <== NOT EXECUTED
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
3000e094: e2506000 subs r6, r0, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000e098: 1b000358 blne 3000ee00 <_Thread_Enable_dispatch> <== NOT EXECUTED
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e09c: e59f3074 ldr r3, [pc, #116] ; 3000e118 <_Scheduler_CBS_Detach_thread+0xa0><== NOT EXECUTED 3000e0a0: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e0a4: e1530004 cmp r3, r4 <== NOT EXECUTED 3000e0a8: 9a000018 bls 3000e110 <_Scheduler_CBS_Detach_thread+0x98> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
3000e0ac: e3560000 cmp r6, #0 <== NOT EXECUTED 3000e0b0: 0a000016 beq 3000e110 <_Scheduler_CBS_Detach_thread+0x98> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
3000e0b4: e59f3060 ldr r3, [pc, #96] ; 3000e11c <_Scheduler_CBS_Detach_thread+0xa4><== NOT EXECUTED 3000e0b8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e0bc: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000e0c0: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000e0c4: 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] )
3000e0c8: 0a00000e beq 3000e108 <_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 )
3000e0cc: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000e0d0: e1520005 cmp r2, r5 <== NOT EXECUTED 3000e0d4: 1a00000d bne 3000e110 <_Scheduler_CBS_Detach_thread+0x98> <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
3000e0d8: e59640a0 ldr r4, [r6, #160] ; 0xa0 <== NOT EXECUTED
the_thread->budget_callout = the_thread->Start.budget_callout;
3000e0dc: e596c0a4 ldr ip, [r6, #164] ; 0xa4 <== NOT EXECUTED
the_thread->is_preemptible = the_thread->Start.is_preemptible;
3000e0e0: e5d6109c ldrb r1, [r6, #156] ; 0x9c <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
3000e0e4: e5965088 ldr r5, [r6, #136] ; 0x88 <== NOT EXECUTED 3000e0e8: e3a02000 mov r2, #0 <== NOT EXECUTED
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;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
3000e0ec: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e0f0: e5830000 str r0, [r3] <== NOT EXECUTED
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL;
3000e0f4: e5852018 str r2, [r5, #24] <== 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;
3000e0f8: e1a00002 mov r0, r2 <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
3000e0fc: e5864078 str r4, [r6, #120] ; 0x78 <== NOT EXECUTED
the_thread->budget_callout = the_thread->Start.budget_callout;
3000e100: e586c07c str ip, [r6, #124] ; 0x7c <== NOT EXECUTED
the_thread->is_preemptible = the_thread->Start.is_preemptible;
3000e104: e5c61070 strb r1, [r6, #112] ; 0x70 <== NOT EXECUTED
return SCHEDULER_CBS_OK;
}
3000e108: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000e10c: e8bd8070 pop {r4, r5, r6, pc} <== 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;
3000e110: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000e114: eafffffb b 3000e108 <_Scheduler_CBS_Detach_thread+0x90> <== NOT EXECUTED
3000e120 <_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 )
3000e120: e59f3030 ldr r3, [pc, #48] ; 3000e158 <_Scheduler_CBS_Get_approved_budget+0x38><== NOT EXECUTED 3000e124: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e128: e1530000 cmp r3, r0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000e12c: 93e00011 mvnls 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 )
3000e130: 912fff1e bxls lr <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000e134: e59f3020 ldr r3, [pc, #32] ; 3000e15c <_Scheduler_CBS_Get_approved_budget+0x3c><== NOT EXECUTED 3000e138: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e13c: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000e140: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
*approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000e144: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000e148: 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;
3000e14c: 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;
3000e150: 03e00018 mvneq r0, #24 <== NOT EXECUTED
*approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
return SCHEDULER_CBS_OK;
}
3000e154: e12fff1e bx lr <== NOT EXECUTED
3000e160 <_Scheduler_CBS_Get_execution_time>:
int _Scheduler_CBS_Get_execution_time (
Scheduler_CBS_Server_id server_id,
time_t *exec_time,
time_t *abs_time
)
{
3000e160: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e164: e59f3094 ldr r3, [pc, #148] ; 3000e200 <_Scheduler_CBS_Get_execution_time+0xa0><== NOT EXECUTED
int _Scheduler_CBS_Get_execution_time (
Scheduler_CBS_Server_id server_id,
time_t *exec_time,
time_t *abs_time
)
{
3000e168: e1a04000 mov r4, r0 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e16c: 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
)
{
3000e170: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e174: e1530000 cmp r3, r0 <== NOT EXECUTED
int _Scheduler_CBS_Get_execution_time (
Scheduler_CBS_Server_id server_id,
time_t *exec_time,
time_t *abs_time
)
{
3000e178: e1a06001 mov r6, r1 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000e17c: 93e00011 mvnls r0, #17 <== NOT EXECUTED
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e180: 9a000016 bls 3000e1e0 <_Scheduler_CBS_Get_execution_time+0x80><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000e184: e59f5078 ldr r5, [pc, #120] ; 3000e204 <_Scheduler_CBS_Get_execution_time+0xa4><== NOT EXECUTED 3000e188: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000e18c: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000e190: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000e194: 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] )
3000e198: 0a000010 beq 3000e1e0 <_Scheduler_CBS_Get_execution_time+0x80><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) {
3000e19c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e1a0: e3700001 cmn r0, #1 <== NOT EXECUTED
*exec_time = 0;
3000e1a4: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000e1a8: 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 ) {
3000e1ac: 0a00000b beq 3000e1e0 <_Scheduler_CBS_Get_execution_time+0x80><== NOT EXECUTED
*exec_time = 0;
return SCHEDULER_CBS_OK;
}
the_thread = _Thread_Get(
3000e1b0: e1a0100d mov r1, sp <== NOT EXECUTED 3000e1b4: eb000319 bl 3000ee20 <_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 ) {
3000e1b8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000e1bc: 0a000009 beq 3000e1e8 <_Scheduler_CBS_Get_execution_time+0x88><== NOT EXECUTED
_Thread_Enable_dispatch();
3000e1c0: eb00030e bl 3000ee00 <_Thread_Enable_dispatch> <== NOT EXECUTED
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget -
3000e1c4: e5952000 ldr r2, [r5] <== NOT EXECUTED 3000e1c8: e5973074 ldr r3, [r7, #116] ; 0x74 <== NOT EXECUTED 3000e1cc: e7922104 ldr r2, [r2, r4, lsl #2] <== NOT EXECUTED
the_thread->cpu_time_budget;
}
else {
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
}
return SCHEDULER_CBS_OK;
3000e1d0: 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 -
3000e1d4: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000e1d8: e0633002 rsb r3, r3, r2 <== NOT EXECUTED 3000e1dc: e5863000 str r3, [r6] <== NOT EXECUTED
}
else {
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
}
return SCHEDULER_CBS_OK;
}
3000e1e0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000e1e4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== 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;
3000e1e8: e5953000 ldr r3, [r5] <== NOT EXECUTED
} return SCHEDULER_CBS_OK;
3000e1ec: 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;
3000e1f0: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000e1f4: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000e1f8: e5863000 str r3, [r6] <== NOT EXECUTED 3000e1fc: eafffff7 b 3000e1e0 <_Scheduler_CBS_Get_execution_time+0x80><== NOT EXECUTED
3000e208 <_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 )
3000e208: e59f3038 ldr r3, [pc, #56] ; 3000e248 <_Scheduler_CBS_Get_parameters+0x40><== NOT EXECUTED 3000e20c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e210: e1530000 cmp r3, r0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000e214: 93e00011 mvnls 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 )
3000e218: 912fff1e bxls lr <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000e21c: e59f3028 ldr r3, [pc, #40] ; 3000e24c <_Scheduler_CBS_Get_parameters+0x44><== NOT EXECUTED 3000e220: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e224: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000e228: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e22c: 0a000003 beq 3000e240 <_Scheduler_CBS_Get_parameters+0x38> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
*params = _Scheduler_CBS_Server_list[server_id]->parameters;
3000e230: e993000c ldmib r3, {r2, r3} <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000e234: 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;
3000e238: e881000c stm r1, {r2, r3} <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000e23c: 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;
3000e240: e3e00018 mvn r0, #24 <== NOT EXECUTED
*params = _Scheduler_CBS_Server_list[server_id]->parameters;
return SCHEDULER_CBS_OK;
}
3000e244: e12fff1e bx lr <== NOT EXECUTED
3000e250 <_Scheduler_CBS_Get_remaining_budget>:
int _Scheduler_CBS_Get_remaining_budget (
Scheduler_CBS_Server_id server_id,
time_t *remaining_budget
)
{
3000e250: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e254: e59f3078 ldr r3, [pc, #120] ; 3000e2d4 <_Scheduler_CBS_Get_remaining_budget+0x84><== NOT EXECUTED
int _Scheduler_CBS_Get_remaining_budget (
Scheduler_CBS_Server_id server_id,
time_t *remaining_budget
)
{
3000e258: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e25c: e5933000 ldr r3, [r3] <== NOT EXECUTED
int _Scheduler_CBS_Get_remaining_budget (
Scheduler_CBS_Server_id server_id,
time_t *remaining_budget
)
{
3000e260: e1a04001 mov r4, r1 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e264: e1530000 cmp r3, r0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000e268: 93e00011 mvnls r0, #17 <== NOT EXECUTED
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e26c: 9a000012 bls 3000e2bc <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000e270: e59f3060 ldr r3, [pc, #96] ; 3000e2d8 <_Scheduler_CBS_Get_remaining_budget+0x88><== NOT EXECUTED 3000e274: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e278: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000e27c: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000e280: 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] )
3000e284: 0a00000c beq 3000e2bc <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) {
3000e288: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e28c: e3700001 cmn r0, #1 <== NOT EXECUTED 3000e290: 0a00000b beq 3000e2c4 <_Scheduler_CBS_Get_remaining_budget+0x74><== NOT EXECUTED
*remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
return SCHEDULER_CBS_OK;
}
the_thread = _Thread_Get(
3000e294: e1a0100d mov r1, sp <== NOT EXECUTED 3000e298: eb0002e0 bl 3000ee20 <_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 ) {
3000e29c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
*remaining_budget = the_thread->cpu_time_budget;
}
else {
*remaining_budget = 0;
3000e2a0: 05845000 streq r5, [r4] <== NOT EXECUTED
}
return SCHEDULER_CBS_OK;
3000e2a4: 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 ) {
3000e2a8: 0a000003 beq 3000e2bc <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
_Thread_Enable_dispatch();
3000e2ac: eb0002d3 bl 3000ee00 <_Thread_Enable_dispatch> <== NOT EXECUTED
*remaining_budget = the_thread->cpu_time_budget;
3000e2b0: e5953074 ldr r3, [r5, #116] ; 0x74 <== NOT EXECUTED
}
else {
*remaining_budget = 0;
}
return SCHEDULER_CBS_OK;
3000e2b4: e3a00000 mov r0, #0 <== NOT EXECUTED
&location
);
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
_Thread_Enable_dispatch();
*remaining_budget = the_thread->cpu_time_budget;
3000e2b8: e5843000 str r3, [r4] <== NOT EXECUTED
else {
*remaining_budget = 0;
}
return SCHEDULER_CBS_OK;
}
3000e2bc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000e2c0: e8bd8030 pop {r4, r5, pc} <== 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 ) {
*remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000e2c4: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000e2c8: 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;
if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) {
*remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000e2cc: e5813000 str r3, [r1] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000e2d0: eafffff9 b 3000e2bc <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
3000e2dc <_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++ ) {
3000e2dc: e59f3054 ldr r3, [pc, #84] ; 3000e338 <_Scheduler_CBS_Get_server_id+0x5c><== NOT EXECUTED
int _Scheduler_CBS_Get_server_id (
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
3000e2e0: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000e2e4: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e2e8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e2ec: 0a00000b beq 3000e320 <_Scheduler_CBS_Get_server_id+0x44> <== NOT EXECUTED 3000e2f0: e59fc044 ldr ip, [pc, #68] ; 3000e33c <_Scheduler_CBS_Get_server_id+0x60><== NOT EXECUTED 3000e2f4: e3a02000 mov r2, #0 <== NOT EXECUTED 3000e2f8: e59c4000 ldr r4, [ip] <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[i] &&
3000e2fc: e494c004 ldr ip, [r4], #4 <== NOT EXECUTED 3000e300: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000e304: 0a000002 beq 3000e314 <_Scheduler_CBS_Get_server_id+0x38> <== NOT EXECUTED 3000e308: e59cc000 ldr ip, [ip] <== NOT EXECUTED 3000e30c: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000e310: 0a000005 beq 3000e32c <_Scheduler_CBS_Get_server_id+0x50> <== NOT EXECUTED
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000e314: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000e318: e1520003 cmp r2, r3 <== NOT EXECUTED 3000e31c: 1afffff6 bne 3000e2fc <_Scheduler_CBS_Get_server_id+0x20> <== NOT EXECUTED
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
3000e320: e3e00018 mvn r0, #24 <== NOT EXECUTED
}
3000e324: e8bd0010 pop {r4} <== NOT EXECUTED
3000e328: e12fff1e bx lr <== NOT EXECUTED
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[i] &&
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
3000e32c: e5812000 str r2, [r1] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000e330: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e334: eafffffa b 3000e324 <_Scheduler_CBS_Get_server_id+0x48> <== NOT EXECUTED
3000e3a4 <_Scheduler_CBS_Initialize>:
int _Scheduler_CBS_Initialize(void)
{
3000e3a4: e92d4010 push {r4, lr} <== NOT EXECUTED
unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
3000e3a8: e59f4054 ldr r4, [pc, #84] ; 3000e404 <_Scheduler_CBS_Initialize+0x60><== NOT EXECUTED 3000e3ac: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000e3b0: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED 3000e3b4: eb0006ad bl 3000fe70 <_Workspace_Allocate> <== NOT EXECUTED 3000e3b8: e59f1048 ldr r1, [pc, #72] ; 3000e408 <_Scheduler_CBS_Initialize+0x64><== NOT EXECUTED
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
3000e3bc: e3500000 cmp r0, #0 <== NOT EXECUTED
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
3000e3c0: e5810000 str r0, [r1] <== NOT EXECUTED
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
3000e3c4: 03e00010 mvneq r0, #16 <== 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 )
3000e3c8: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
3000e3cc: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000e3d0: e3520000 cmp r2, #0 <== NOT EXECUTED
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
3000e3d4: 01a00002 moveq r0, r2 <== 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++) {
3000e3d8: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
3000e3dc: e3a03000 mov r3, #0 <== NOT EXECUTED
_Scheduler_CBS_Server_list[i] = NULL;
3000e3e0: e1a0c003 mov ip, r3 <== NOT EXECUTED 3000e3e4: ea000000 b 3000e3ec <_Scheduler_CBS_Initialize+0x48> <== 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++) {
3000e3e8: e5910000 ldr r0, [r1] <== NOT EXECUTED
_Scheduler_CBS_Server_list[i] = NULL;
3000e3ec: e780c103 str ip, [r0, 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++) {
3000e3f0: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000e3f4: e1530002 cmp r3, r2 <== NOT EXECUTED 3000e3f8: 1afffffa bne 3000e3e8 <_Scheduler_CBS_Initialize+0x44> <== NOT EXECUTED
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
3000e3fc: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000e400: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cfc8 <_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;
3000cfc8: e5903088 ldr r3, [r0, #136] ; 0x88 <== NOT EXECUTED
if (deadline) {
3000cfcc: 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 =
3000cfd0: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
(Scheduler_CBS_Server *) sched_info->cbs_server;
if (deadline) {
3000cfd4: 0a00000b beq 3000d008 <_Scheduler_CBS_Release_job+0x40> <== NOT EXECUTED
/* Initializing or shifting deadline. */
if (serv_info)
3000cfd8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000cfdc: 0a00000d beq 3000d018 <_Scheduler_CBS_Release_job+0x50> <== NOT EXECUTED
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
3000cfe0: e59f1044 ldr r1, [pc, #68] ; 3000d02c <_Scheduler_CBS_Release_job+0x64><== NOT EXECUTED 3000cfe4: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000cfe8: e5911000 ldr r1, [r1] <== NOT EXECUTED 3000cfec: e0811002 add r1, r1, r2 <== NOT EXECUTED 3000cff0: e3c11102 bic r1, r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
the_thread->cpu_time_budget = serv_info->parameters.budget;
3000cff4: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000cff8: e5803074 str r3, [r0, #116] ; 0x74 <== NOT EXECUTED
the_thread->real_priority = new_priority;
_Thread_Change_priority(the_thread, new_priority, true);
3000cffc: 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;
3000d000: e5801018 str r1, [r0, #24] <== NOT EXECUTED
_Thread_Change_priority(the_thread, new_priority, true);
3000d004: ea000120 b 3000d48c <_Thread_Change_priority> <== NOT EXECUTED
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
3000d008: 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;
3000d00c: e59010ac ldr r1, [r0, #172] ; 0xac <== NOT EXECUTED
}
/* Budget replenishment for the next job. */
if (serv_info)
3000d010: 1afffff7 bne 3000cff4 <_Scheduler_CBS_Release_job+0x2c> <== NOT EXECUTED 3000d014: eafffff8 b 3000cffc <_Scheduler_CBS_Release_job+0x34> <== NOT EXECUTED
/* Initializing or shifting deadline. */
if (serv_info)
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
3000d018: e59f300c ldr r3, [pc, #12] ; 3000d02c <_Scheduler_CBS_Release_job+0x64><== NOT EXECUTED 3000d01c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d020: e0811003 add r1, r1, r3 <== NOT EXECUTED 3000d024: e3c11102 bic r1, r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000d028: eafffff3 b 3000cffc <_Scheduler_CBS_Release_job+0x34> <== NOT EXECUTED
3000e474 <_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 )
3000e474: e59f3054 ldr r3, [pc, #84] ; 3000e4d0 <_Scheduler_CBS_Set_parameters+0x5c><== NOT EXECUTED
int _Scheduler_CBS_Set_parameters (
Scheduler_CBS_Server_id server_id,
Scheduler_CBS_Parameters *params
)
{
3000e478: e92d0030 push {r4, r5} <== NOT EXECUTED
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000e47c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e480: e1530000 cmp r3, r0 <== NOT EXECUTED 3000e484: 9a00000f bls 3000e4c8 <_Scheduler_CBS_Set_parameters+0x54> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( params->budget <= 0 ||
3000e488: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 3000e48c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e490: da00000c ble 3000e4c8 <_Scheduler_CBS_Set_parameters+0x54> <== NOT EXECUTED 3000e494: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000e498: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e49c: da000009 ble 3000e4c8 <_Scheduler_CBS_Set_parameters+0x54> <== 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] )
3000e4a0: e59f302c ldr r3, [pc, #44] ; 3000e4d4 <_Scheduler_CBS_Set_parameters+0x60><== NOT EXECUTED 3000e4a4: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e4a8: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000e4ac: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000e4b0: 03e00018 mvneq r0, #24 <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id]->parameters = *params;
3000e4b4: 18910030 ldmne r1, {r4, r5} <== NOT EXECUTED
3000e4b8: 19830030 stmibne r3, {r4, r5} <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000e4bc: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000e4c0: e8bd0030 pop {r4, r5} <== NOT EXECUTED
3000e4c4: 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;
3000e4c8: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000e4cc: eafffffb b 3000e4c0 <_Scheduler_CBS_Set_parameters+0x4c> <== NOT EXECUTED
3000d030 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
3000d030: e92d4030 push {r4, r5, lr}
3000d034: e1a04000 mov r4, r0
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server *serv_info;
Priority_Control new_priority;
_Scheduler_EDF_Enqueue(the_thread);
3000d038: eb000042 bl 3000d148 <_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;
3000d03c: e5943088 ldr r3, [r4, #136] ; 0x88 3000d040: 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) {
3000d044: e3530000 cmp r3, #0
3000d048: 0a00000a beq 3000d078 <_Scheduler_CBS_Unblock+0x48>
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 -
3000d04c: e59f10a4 ldr r1, [pc, #164] ; 3000d0f8 <_Scheduler_CBS_Unblock+0xc8><== NOT EXECUTED 3000d050: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED 3000d054: e5911000 ldr r1, [r1] <== NOT EXECUTED
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
3000d058: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED 3000d05c: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED 3000d060: e5933008 ldr r3, [r3, #8] <== 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 -
3000d064: e0611002 rsb r1, r1, r2 <== NOT EXECUTED
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
3000d068: e001019c mul r1, ip, r1 <== NOT EXECUTED 3000d06c: e0030390 mul r3, r0, r3 <== NOT EXECUTED 3000d070: e1510003 cmp r1, r3 <== NOT EXECUTED 3000d074: ca000010 bgt 3000d0bc <_Scheduler_CBS_Unblock+0x8c> <== NOT EXECUTED
/* 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 )
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
_Thread_Change_priority(the_thread, new_priority, true);
3000d078: e5940014 ldr r0, [r4, #20]
* 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,
3000d07c: e59f5078 ldr r5, [pc, #120] ; 3000d0fc <_Scheduler_CBS_Unblock+0xcc>
3000d080: e595300c ldr r3, [r5, #12]
3000d084: e5931014 ldr r1, [r3, #20]
3000d088: e59f3070 ldr r3, [pc, #112] ; 3000d100 <_Scheduler_CBS_Unblock+0xd0>
3000d08c: e1a0e00f mov lr, pc
3000d090: e593f030 ldr pc, [r3, #48] ; 0x30
3000d094: e3500000 cmp r0, #0
3000d098: d8bd8030 pople {r4, r5, pc}
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000d09c: 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;
3000d0a0: e585400c str r4, [r5, #12]
if ( _Thread_Executing->is_preemptible ||
3000d0a4: e5d33070 ldrb r3, [r3, #112] ; 0x70 3000d0a8: e3530000 cmp r3, #0
3000d0ac: 0a00000c beq 3000d0e4 <_Scheduler_CBS_Unblock+0xb4>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000d0b0: e3a03001 mov r3, #1
3000d0b4: e5c53004 strb r3, [r5, #4]
3000d0b8: e8bd8030 pop {r4, r5, pc}
time_t budget_left = the_thread->real_priority -
_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;
3000d0bc: 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 )
3000d0c0: e5940014 ldr r0, [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 )
3000d0c4: e1520001 cmp r2, r1 <== NOT EXECUTED
the_thread->real_priority = new_priority;
3000d0c8: 15841018 strne r1, [r4, #24] <== NOT EXECUTED
if ( the_thread->current_priority != new_priority )
3000d0cc: e1500001 cmp r0, r1 <== NOT EXECUTED 3000d0d0: 0affffe9 beq 3000d07c <_Scheduler_CBS_Unblock+0x4c> <== NOT EXECUTED
_Thread_Change_priority(the_thread, new_priority, true);
3000d0d4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d0d8: e3a02001 mov r2, #1 <== NOT EXECUTED 3000d0dc: eb0000ea bl 3000d48c <_Thread_Change_priority> <== NOT EXECUTED 3000d0e0: eaffffe4 b 3000d078 <_Scheduler_CBS_Unblock+0x48> <== NOT EXECUTED
* 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;
if ( _Thread_Executing->is_preemptible ||
3000d0e4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000d0e8: e3530000 cmp r3, #0 <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000d0ec: 03a03001 moveq r3, #1 <== NOT EXECUTED
3000d0f0: 05c53004 strbeq r3, [r5, #4] <== NOT EXECUTED
3000d0f4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000d104 <_Scheduler_EDF_Block>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Block(
Thread_Control *the_thread
)
{
3000d104: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
3000d108: e59f5030 ldr r5, [pc, #48] ; 3000d140 <_Scheduler_EDF_Block+0x3c><== NOT EXECUTED 3000d10c: e1a04000 mov r4, r0 <== NOT EXECUTED
_Scheduler_EDF_Extract( the_thread );
3000d110: eb000015 bl 3000d16c <_Scheduler_EDF_Extract> <== NOT EXECUTED
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
3000d114: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000d118: e1540003 cmp r4, r3 <== NOT EXECUTED 3000d11c: 0a000005 beq 3000d138 <_Scheduler_EDF_Block+0x34> <== NOT EXECUTED
_Scheduler_EDF_Schedule();
if ( _Thread_Is_executing( the_thread ) )
3000d120: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000d124: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000d128: 059f3010 ldreq r3, [pc, #16] ; 3000d140 <_Scheduler_EDF_Block+0x3c><== NOT EXECUTED
3000d12c: 03a02001 moveq r2, #1 <== NOT EXECUTED
3000d130: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED
3000d134: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_Scheduler_EDF_Extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_EDF_Schedule();
3000d138: eb00003b bl 3000d22c <_Scheduler_EDF_Schedule> <== NOT EXECUTED 3000d13c: eafffff7 b 3000d120 <_Scheduler_EDF_Block+0x1c> <== NOT EXECUTED
3000d144 <_Scheduler_EDF_Enqueue_first>:
void _Scheduler_EDF_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler_EDF_Enqueue(the_thread);
3000d144: eaffffff b 3000d148 <_Scheduler_EDF_Enqueue> <== NOT EXECUTED
3000d16c <_Scheduler_EDF_Extract>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Extract(
Thread_Control *the_thread
)
{
3000d16c: e92d4010 push {r4, lr} <== NOT EXECUTED
Scheduler_EDF_Per_thread *sched_info =
3000d170: 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 );
3000d174: e59f0010 ldr r0, [pc, #16] ; 3000d18c <_Scheduler_EDF_Extract+0x20><== NOT EXECUTED 3000d178: e2841004 add r1, r4, #4 <== NOT EXECUTED 3000d17c: eb0011e6 bl 3001191c <_RBTree_Extract> <== NOT EXECUTED
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
3000d180: e3a03000 mov r3, #0 <== NOT EXECUTED 3000d184: e5843014 str r3, [r4, #20] <== NOT EXECUTED
}
3000d188: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000d190 <_Scheduler_EDF_Free>:
void _Scheduler_EDF_Free(
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
3000d190: e5900088 ldr r0, [r0, #136] ; 0x88 <== NOT EXECUTED 3000d194: ea00063f b 3000ea98 <_Workspace_Free> <== NOT EXECUTED
3000d0e4 <_Scheduler_EDF_Release_job>:
uint32_t deadline
)
{
Priority_Control new_priority;
if (deadline) {
3000d0e4: e3510000 cmp r1, #0 <== NOT EXECUTED
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
3000d0e8: 159f3018 ldrne r3, [pc, #24] ; 3000d108 <_Scheduler_EDF_Release_job+0x24><== NOT EXECUTED
& ~SCHEDULER_EDF_PRIO_MSB;
}
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
3000d0ec: 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)
3000d0f0: 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);
3000d0f4: e3a02001 mov r2, #1 <== NOT EXECUTED
{
Priority_Control new_priority;
if (deadline) {
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
3000d0f8: 10811003 addne r1, r1, r3 <== NOT EXECUTED 3000d0fc: 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;
3000d100: e5801018 str r1, [r0, #24] <== NOT EXECUTED
_Thread_Change_priority(the_thread, new_priority, true);
3000d104: ea0000b3 b 3000d3d8 <_Thread_Change_priority> <== NOT EXECUTED
3000d22c <_Scheduler_EDF_Schedule>:
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
3000d22c: e59f3010 ldr r3, [pc, #16] ; 3000d244 <_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;
3000d230: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000d234: e5132004 ldr r2, [r3, #-4] <== NOT EXECUTED 3000d238: e59f3008 ldr r3, [pc, #8] ; 3000d248 <_Scheduler_EDF_Schedule+0x1c><== NOT EXECUTED 3000d23c: e583200c str r2, [r3, #12] <== NOT EXECUTED
}
3000d240: e12fff1e bx lr <== NOT EXECUTED
3000d12c <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
3000d12c: 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(
3000d130: e59f4058 ldr r4, [pc, #88] ; 3000d190 <_Scheduler_EDF_Unblock+0x64>
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
3000d134: e1a05000 mov r5, r0
_Scheduler_EDF_Enqueue(the_thread);
3000d138: ebffffb0 bl 3000d000 <_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(
3000d13c: e594300c ldr r3, [r4, #12]
3000d140: e5951014 ldr r1, [r5, #20]
3000d144: e5930014 ldr r0, [r3, #20]
3000d148: e59f3044 ldr r3, [pc, #68] ; 3000d194 <_Scheduler_EDF_Unblock+0x68>
3000d14c: e1a0e00f mov lr, pc
3000d150: e593f030 ldr pc, [r3, #48] ; 0x30
3000d154: e3500000 cmp r0, #0
3000d158: a8bd8030 popge {r4, r5, pc}
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000d15c: e5943008 ldr r3, [r4, #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;
3000d160: e584500c str r5, [r4, #12]
if ( _Thread_Executing->is_preemptible ||
3000d164: e5d33070 ldrb r3, [r3, #112] ; 0x70 3000d168: e3530000 cmp r3, #0
3000d16c: 0a000002 beq 3000d17c <_Scheduler_EDF_Unblock+0x50>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000d170: e3a03001 mov r3, #1
3000d174: e5c43004 strb r3, [r4, #4]
3000d178: e8bd8030 pop {r4, r5, pc}
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000d17c: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3000d180: e3530000 cmp r3, #0 <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000d184: 03a03001 moveq r3, #1 <== NOT EXECUTED
3000d188: 05c43004 strbeq r3, [r4, #4] <== NOT EXECUTED
3000d18c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000d27c <_Scheduler_EDF_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
3000d27c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000d280: e59f5050 ldr r5, [pc, #80] ; 3000d2d8 <_Scheduler_EDF_Yield+0x5c><== NOT EXECUTED
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
3000d284: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
RBTree_Node *executing_node = &(executing_info->Node);
3000d288: e5936088 ldr r6, [r3, #136] ; 0x88 <== NOT EXECUTED 3000d28c: e2866004 add r6, r6, #4 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d290: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000d294: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000d298: 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 );
3000d29c: e59f7038 ldr r7, [pc, #56] ; 3000d2dc <_Scheduler_EDF_Yield+0x60><== NOT EXECUTED 3000d2a0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000d2a4: e1a00007 mov r0, r7 <== NOT EXECUTED 3000d2a8: eb00119b bl 3001191c <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node );
3000d2ac: e1a00007 mov r0, r7 <== NOT EXECUTED 3000d2b0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000d2b4: eb00123a bl 30011ba4 <_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 (
3000d2b8: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000d2bc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000d2c0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Flash( level );
_Scheduler_EDF_Schedule();
3000d2c4: ebffffd8 bl 3000d22c <_Scheduler_EDF_Schedule> <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000d2c8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000d2cc: 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 (
3000d2d0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level );
}
3000d2d4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000c9bc <_Scheduler_priority_Tick>:
void _Scheduler_priority_Tick( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
3000c9bc: e59f308c ldr r3, [pc, #140] ; 3000ca50 <_Scheduler_priority_Tick+0x94>
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
3000c9c0: e92d4010 push {r4, lr}
Thread_Control *executing;
executing = _Thread_Executing;
3000c9c4: e5934008 ldr r4, [r3, #8]
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
3000c9c8: e5d43070 ldrb r3, [r4, #112] ; 0x70
3000c9cc: e3530000 cmp r3, #0
3000c9d0: 08bd8010 popeq {r4, pc}
return;
if ( !_States_Is_ready( executing->current_state ) )
3000c9d4: e5943010 ldr r3, [r4, #16]
3000c9d8: e3530000 cmp r3, #0
3000c9dc: 18bd8010 popne {r4, pc}
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
3000c9e0: e5943078 ldr r3, [r4, #120] ; 0x78
3000c9e4: e3530001 cmp r3, #1
3000c9e8: 38bd8010 popcc {r4, pc}
3000c9ec: e3530002 cmp r3, #2 <== NOT EXECUTED
3000c9f0: 9a00000a bls 3000ca20 <_Scheduler_priority_Tick+0x64> <== NOT EXECUTED
3000c9f4: e3530003 cmp r3, #3 <== NOT EXECUTED
3000c9f8: 18bd8010 popne {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 )
3000c9fc: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000ca00: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000ca04: e3530000 cmp r3, #0 <== NOT EXECUTED
3000ca08: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000ca0c: 18bd8010 popne {r4, pc} <== NOT EXECUTED
(*executing->budget_callout)( executing );
3000ca10: e1a00004 mov r0, r4 <== NOT EXECUTED
3000ca14: e1a0e00f mov lr, pc <== NOT EXECUTED
3000ca18: e594f07c ldr pc, [r4, #124] ; 0x7c <== NOT EXECUTED
3000ca1c: e8bd8010 pop {r4, pc} <== 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 ) {
3000ca20: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000ca24: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000ca28: e3530000 cmp r3, #0 <== NOT EXECUTED
3000ca2c: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000ca30: 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();
3000ca34: e59f3018 ldr r3, [pc, #24] ; 3000ca54 <_Scheduler_priority_Tick+0x98><== NOT EXECUTED 3000ca38: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ca3c: 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;
3000ca40: e59f3010 ldr r3, [pc, #16] ; 3000ca58 <_Scheduler_priority_Tick+0x9c><== NOT EXECUTED
3000ca44: e5933000 ldr r3, [r3] <== NOT EXECUTED
3000ca48: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000ca4c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000d018 <_Scheduler_simple_Block>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Block(
Thread_Control *the_thread
)
{
3000d018: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
3000d01c: e59f5030 ldr r5, [pc, #48] ; 3000d054 <_Scheduler_simple_Block+0x3c><== NOT EXECUTED 3000d020: e1a04000 mov r4, r0 <== NOT EXECUTED
_Scheduler_simple_Extract(the_thread);
3000d024: eb00000d bl 3000d060 <_Scheduler_simple_Extract> <== NOT EXECUTED
if ( _Thread_Is_heir( the_thread ) )
3000d028: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000d02c: e1540003 cmp r4, r3 <== NOT EXECUTED 3000d030: 0a000005 beq 3000d04c <_Scheduler_simple_Block+0x34> <== NOT EXECUTED
_Scheduler_simple_Schedule();
if ( _Thread_Is_executing( the_thread ) )
3000d034: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000d038: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000d03c: 059f3010 ldreq r3, [pc, #16] ; 3000d054 <_Scheduler_simple_Block+0x3c><== NOT EXECUTED
3000d040: 03a02001 moveq r2, #1 <== NOT EXECUTED
3000d044: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED
3000d048: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
)
{
_Scheduler_simple_Extract(the_thread);
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_simple_Schedule();
3000d04c: eb000045 bl 3000d168 <_Scheduler_simple_Schedule> <== NOT EXECUTED 3000d050: eafffff7 b 3000d034 <_Scheduler_simple_Block+0x1c> <== NOT EXECUTED
3000d05c <_Scheduler_simple_Enqueue>:
void _Scheduler_simple_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_enqueue( the_thread );
3000d05c: ea000022 b 3000d0ec <_Scheduler_simple_Ready_queue_enqueue><== NOT EXECUTED
3000d058 <_Scheduler_simple_Enqueue_first>:
void _Scheduler_simple_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_enqueue_first( the_thread );
3000d058: ea000014 b 3000d0b0 <_Scheduler_simple_Ready_queue_enqueue_first><== NOT EXECUTED
3000d060 <_Scheduler_simple_Extract>:
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000d060: e890000c ldm r0, {r2, r3} <== NOT EXECUTED
next->previous = previous;
3000d064: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000d068: e5832000 str r2, [r3] <== NOT EXECUTED
void _Scheduler_simple_Extract(
Thread_Control *the_thread
)
{
_Chain_Extract_unprotected( &the_thread->Object.Node );
}
3000d06c: e12fff1e bx lr <== NOT EXECUTED
3000d07c <_Scheduler_simple_Free>:
void _Scheduler_simple_Free(
Thread_Control *the_thread
)
{
}
3000d07c: e12fff1e bx lr <== NOT EXECUTED
3000d0ec <_Scheduler_simple_Ready_queue_enqueue>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000d0ec: e59f3070 ldr r3, [pc, #112] ; 3000d164 <_Scheduler_simple_Ready_queue_enqueue+0x78>
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Ready_queue_enqueue(
Thread_Control *the_thread
)
{
3000d0f0: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000d0f4: e5933000 ldr r3, [r3]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000d0f8: e1a0c003 mov ip, r3 3000d0fc: e49c2004 ldr r2, [ip], #4
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
3000d100: e152000c cmp r2, ip 3000d104: 01a02003 moveq r2, r3
3000d108: 0a00000b beq 3000d13c <_Scheduler_simple_Ready_queue_enqueue+0x50>
current = (Thread_Control *) the_node;
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
3000d10c: e5904014 ldr r4, [r0, #20] 3000d110: e5923014 ldr r3, [r2, #20] 3000d114: e1540003 cmp r4, r3
3000d118: 2a000004 bcs 3000d130 <_Scheduler_simple_Ready_queue_enqueue+0x44>
3000d11c: ea00000d b 3000d158 <_Scheduler_simple_Ready_queue_enqueue+0x6c>
3000d120: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED 3000d124: e1a02003 mov r2, r3 <== NOT EXECUTED 3000d128: e1510004 cmp r1, r4 <== NOT EXECUTED 3000d12c: 8a00000a bhi 3000d15c <_Scheduler_simple_Ready_queue_enqueue+0x70><== NOT EXECUTED
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 ) {
3000d130: e5923000 ldr r3, [r2] <== NOT EXECUTED 3000d134: e153000c cmp r3, ip <== NOT EXECUTED 3000d138: 1afffff8 bne 3000d120 <_Scheduler_simple_Ready_queue_enqueue+0x34><== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000d13c: e5923000 ldr r3, [r2]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000d140: e5802004 str r2, [r0, #4]
before_node = after_node->next; after_node->next = the_node;
3000d144: e5820000 str r0, [r2]
the_node->next = before_node; before_node->previous = the_node;
3000d148: e5830004 str r0, [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;
3000d14c: e5803000 str r3, [r0]
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000d150: e8bd0010 pop {r4}
3000d154: e12fff1e bx lr
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
3000d158: e1a03002 mov r3, r2
current = (Thread_Control *)current->Object.Node.previous;
3000d15c: e5932004 ldr r2, [r3, #4]
break;
3000d160: eafffff5 b 3000d13c <_Scheduler_simple_Ready_queue_enqueue+0x50>
3000d0b0 <_Scheduler_simple_Ready_queue_enqueue_first>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000d0b0: e59f3030 ldr r3, [pc, #48] ; 3000d0e8 <_Scheduler_simple_Ready_queue_enqueue_first+0x38><== 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 ) {
3000d0b4: e5901014 ldr r1, [r0, #20] <== NOT EXECUTED 3000d0b8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d0bc: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d0c0: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED 3000d0c4: e1520001 cmp r2, r1 <== NOT EXECUTED 3000d0c8: 3afffffb bcc 3000d0bc <_Scheduler_simple_Ready_queue_enqueue_first+0xc><== NOT EXECUTED
current = (Thread_Control *)current->Object.Node.previous;
3000d0cc: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000d0d0: e5932000 ldr r2, [r3] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000d0d4: e5803004 str r3, [r0, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000d0d8: e5830000 str r0, [r3] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000d0dc: 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;
3000d0e0: e5802000 str r2, [r0] <== NOT EXECUTED
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000d0e4: e12fff1e bx lr <== NOT EXECUTED
3000d168 <_Scheduler_simple_Schedule>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Schedule(void)
{
_Thread_Heir = (Thread_Control *) _Chain_First(
(Chain_Control *) _Scheduler.information
3000d168: e59f3010 ldr r3, [pc, #16] ; 3000d180 <_Scheduler_simple_Schedule+0x18><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000d16c: 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(
3000d170: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d174: e59f3008 ldr r3, [pc, #8] ; 3000d184 <_Scheduler_simple_Schedule+0x1c><== NOT EXECUTED 3000d178: e583200c str r2, [r3, #12] <== NOT EXECUTED
(Chain_Control *) _Scheduler.information
);
}
3000d17c: e12fff1e bx lr <== NOT EXECUTED
3000d188 <_Scheduler_simple_Unblock>:
#include <rtems/score/thread.h>
void _Scheduler_simple_Unblock(
Thread_Control *the_thread
)
{
3000d188: e92d4010 push {r4, lr}
3000d18c: e1a04000 mov r4, r0
_Scheduler_simple_Ready_queue_enqueue(the_thread);
3000d190: ebffffd5 bl 3000d0ec <_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 ) {
3000d194: e59f3040 ldr r3, [pc, #64] ; 3000d1dc <_Scheduler_simple_Unblock+0x54>
3000d198: e5942014 ldr r2, [r4, #20]
3000d19c: e593100c ldr r1, [r3, #12]
3000d1a0: e5911014 ldr r1, [r1, #20]
3000d1a4: e1520001 cmp r2, r1
3000d1a8: 28bd8010 popcs {r4, pc}
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000d1ac: 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;
3000d1b0: e583400c str r4, [r3, #12]
if ( _Thread_Executing->is_preemptible ||
3000d1b4: e5d11070 ldrb r1, [r1, #112] ; 0x70 3000d1b8: e3510000 cmp r1, #0
3000d1bc: 0a000002 beq 3000d1cc <_Scheduler_simple_Unblock+0x44>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000d1c0: e3a02001 mov r2, #1
3000d1c4: e5c32004 strb r2, [r3, #4]
3000d1c8: e8bd8010 pop {r4, pc}
* 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;
if ( _Thread_Executing->is_preemptible ||
3000d1cc: e3520000 cmp r2, #0 <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000d1d0: 03a02001 moveq r2, #1 <== NOT EXECUTED
3000d1d4: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED
3000d1d8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000d1e0 <_Scheduler_simple_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/thread.h>
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Yield( void )
{
3000d1e0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing;
executing = _Thread_Executing;
3000d1e4: e59f5048 ldr r5, [pc, #72] ; 3000d234 <_Scheduler_simple_Yield+0x54><== NOT EXECUTED 3000d1e8: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d1ec: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000d1f0: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000d1f4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000d1f8: e894000c ldm r4, {r2, r3} <== NOT EXECUTED
{
/* extract */
_Chain_Extract_unprotected( &the_thread->Object.Node );
/* enqueue */
_Scheduler_simple_Ready_queue_enqueue( the_thread );
3000d1fc: e1a00004 mov r0, r4 <== NOT EXECUTED
next->previous = previous;
3000d200: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000d204: e5832000 str r2, [r3] <== NOT EXECUTED 3000d208: ebffffb7 bl 3000d0ec <_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 (
3000d20c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000d210: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000d214: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_Scheduler_simple_Ready_queue_requeue(&_Scheduler, executing);
_ISR_Flash( level );
_Scheduler_simple_Schedule();
3000d218: ebffffd2 bl 3000d168 <_Scheduler_simple_Schedule> <== NOT EXECUTED
if ( !_Thread_Is_heir( executing ) )
3000d21c: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000d220: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000d224: 13a03001 movne r3, #1 <== NOT EXECUTED 3000d228: 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 (
3000d22c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
}
3000d230: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3002a9c0 <_TOD_Get_uptime_as_timespec>:
#include <rtems/score/tod.h>
void _TOD_Get_uptime_as_timespec(
struct timespec *uptime
)
{
3002a9c0: e92d40d0 push {r4, r6, r7, lr} <== NOT EXECUTED
3002a9c4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
3002a9c8: e1a04000 mov r4, r0 <== NOT EXECUTED
3002a9cc: e59f1040 ldr r1, [pc, #64] ; 3002aa14 <_TOD_Get_uptime_as_timespec+0x54><== NOT EXECUTED
3002a9d0: e1a0000d mov r0, sp <== NOT EXECUTED
3002a9d4: ebff8582 bl 3000bfe4 <_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 );
3002a9d8: 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);
3002a9dc: e59f2034 ldr r2, [pc, #52] ; 3002aa18 <_TOD_Get_uptime_as_timespec+0x58><== NOT EXECUTED 3002a9e0: e3a03000 mov r3, #0 <== NOT EXECUTED 3002a9e4: e1a00006 mov r0, r6 <== NOT EXECUTED 3002a9e8: e1a01007 mov r1, r7 <== NOT EXECUTED 3002a9ec: eb00a814 bl 30054a44 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3002a9f0: e59f2020 ldr r2, [pc, #32] ; 3002aa18 <_TOD_Get_uptime_as_timespec+0x58><== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
3002a9f4: e5840000 str r0, [r4] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3002a9f8: e3a03000 mov r3, #0 <== NOT EXECUTED 3002a9fc: e1a00006 mov r0, r6 <== NOT EXECUTED 3002aa00: e1a01007 mov r1, r7 <== NOT EXECUTED 3002aa04: eb00a949 bl 30054f30 <__moddi3> <== NOT EXECUTED 3002aa08: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
3002aa0c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3002aa10: e8bd80d0 pop {r4, r6, r7, pc} <== NOT EXECUTED
3000b824 <_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();
3000b824: e59f2080 ldr r2, [pc, #128] ; 3000b8ac <_TOD_Tickle_ticks+0x88>
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
3000b828: e59f3080 ldr r3, [pc, #128] ; 3000b8b0 <_TOD_Tickle_ticks+0x8c> 3000b82c: e5922010 ldr r2, [r2, #16]
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
#include <rtems/config.h>
void _TOD_Tickle_ticks( void )
{
3000b830: e92d03f0 push {r4, r5, r6, r7, r8, r9}
3000b834: e2837008 add r7, r3, #8
3000b838: e89700c0 ldm r7, {r6, r7}
3000b83c: e8930300 ldm r3, {r8, r9}
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 );
3000b840: e1a00002 mov r0, r2 3000b844: e3a01000 mov r1, #0 3000b848: e0966000 adds r6, r6, r0
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000b84c: e59fc060 ldr ip, [pc, #96] ; 3000b8b4 <_TOD_Tickle_ticks+0x90> 3000b850: e0a77001 adc r7, r7, 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;
3000b854: e5935010 ldr r5, [r3, #16] 3000b858: e0988000 adds r8, r8, r0 3000b85c: e0a99001 adc r9, r9, r1
/* 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;
3000b860: e59c4000 ldr r4, [ip]
/* Update the current TOD */
_Timestamp_Add_to( &_TOD.now, &tick );
_TOD.seconds_trigger += nanoseconds_per_tick;
if ( _TOD.seconds_trigger >= 1000000000UL ) {
3000b864: e59f104c ldr r1, [pc, #76] ; 3000b8b8 <_TOD_Tickle_ticks+0x94>
/* 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;
3000b868: e0822005 add r2, r2, r5
/* 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;
3000b86c: e2844001 add r4, r4, #1
/* Update the current TOD */
_Timestamp_Add_to( &_TOD.now, &tick );
_TOD.seconds_trigger += nanoseconds_per_tick;
if ( _TOD.seconds_trigger >= 1000000000UL ) {
3000b870: e1520001 cmp r2, r1
/* 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;
3000b874: e58c4000 str r4, [ip]
3000b878: e5836008 str r6, [r3, #8]
3000b87c: e583700c str r7, [r3, #12]
3000b880: e8830300 stm r3, {r8, r9}
/* 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;
3000b884: e5832010 str r2, [r3, #16]
if ( _TOD.seconds_trigger >= 1000000000UL ) {
3000b888: 8a000001 bhi 3000b894 <_TOD_Tickle_ticks+0x70>
_TOD.seconds_trigger -= 1000000000UL;
_Watchdog_Tickle_seconds();
}
}
3000b88c: e8bd03f0 pop {r4, r5, r6, r7, r8, r9}
3000b890: e12fff1e bx lr
/* Update the current TOD */
_Timestamp_Add_to( &_TOD.now, &tick );
_TOD.seconds_trigger += nanoseconds_per_tick;
if ( _TOD.seconds_trigger >= 1000000000UL ) {
_TOD.seconds_trigger -= 1000000000UL;
3000b894: e59f1020 ldr r1, [pc, #32] ; 3000b8bc <_TOD_Tickle_ticks+0x98><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
3000b898: e59f0020 ldr r0, [pc, #32] ; 3000b8c0 <_TOD_Tickle_ticks+0x9c><== NOT EXECUTED 3000b89c: e0821001 add r1, r2, r1 <== NOT EXECUTED 3000b8a0: e5831010 str r1, [r3, #16] <== NOT EXECUTED
_Watchdog_Tickle_seconds();
}
}
3000b8a4: e8bd03f0 pop {r4, r5, r6, r7, r8, r9} <== NOT EXECUTED
3000b8a8: ea0009cb b 3000dfdc <_Watchdog_Tickle> <== NOT EXECUTED
3000b4f4 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
3000b4f4: 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) ||
3000b4f8: 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;
3000b4fc: 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) ||
3000b500: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
3000b504: e59f3098 ldr r3, [pc, #152] ; 3000b5a4 <_TOD_Validate+0xb0> 3000b508: e59f0098 ldr r0, [pc, #152] ; 3000b5a8 <_TOD_Validate+0xb4> 3000b50c: e593100c ldr r1, [r3, #12] 3000b510: eb0048cf bl 3001d854 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
3000b514: e5943018 ldr r3, [r4, #24] 3000b518: e1500003 cmp r0, r3
3000b51c: 9a00001c bls 3000b594 <_TOD_Validate+0xa0>
(the_tod->ticks >= ticks_per_second) ||
3000b520: e5943014 ldr r3, [r4, #20] 3000b524: e353003b cmp r3, #59 ; 0x3b
3000b528: 8a000019 bhi 3000b594 <_TOD_Validate+0xa0>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
3000b52c: e5943010 ldr r3, [r4, #16] 3000b530: e353003b cmp r3, #59 ; 0x3b
3000b534: 8a000016 bhi 3000b594 <_TOD_Validate+0xa0>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
3000b538: e594300c ldr r3, [r4, #12] 3000b53c: e3530017 cmp r3, #23
3000b540: 8a000013 bhi 3000b594 <_TOD_Validate+0xa0>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
3000b544: e5940004 ldr r0, [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) ||
3000b548: e3500000 cmp r0, #0
3000b54c: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
3000b550: e350000c cmp r0, #12
3000b554: 8a00000e bhi 3000b594 <_TOD_Validate+0xa0>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000b558: e5943000 ldr r3, [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) ||
3000b55c: e59f2048 ldr r2, [pc, #72] ; 3000b5ac <_TOD_Validate+0xb8> 3000b560: e1530002 cmp r3, r2
3000b564: 9a00000a bls 3000b594 <_TOD_Validate+0xa0>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
3000b568: e5944008 ldr r4, [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) ||
3000b56c: e3540000 cmp r4, #0
3000b570: 0a000009 beq 3000b59c <_TOD_Validate+0xa8>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
3000b574: e3130003 tst r3, #3
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000b578: e59f3030 ldr r3, [pc, #48] ; 3000b5b0 <_TOD_Validate+0xbc>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000b57c: 0280000d addeq r0, r0, #13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000b580: e7930100 ldr r0, [r3, r0, 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(
3000b584: e1500004 cmp r0, r4
3000b588: 33a00000 movcc r0, #0
3000b58c: 23a00001 movcs r0, #1
3000b590: 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;
3000b594: e3a00000 mov r0, #0 <== NOT EXECUTED
3000b598: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b59c: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
3000b5a0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cc6c <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
3000cc6c: e92d40f0 push {r4, r5, r6, r7, lr}
3000cc70: e1a04000 mov r4, r0
3000cc74: e1a07001 mov r7, r1
3000cc78: e20260ff and r6, r2, #255 ; 0xff
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
3000cc7c: e5905010 ldr r5, [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 );
3000cc80: eb00036a bl 3000da30 <_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 )
3000cc84: e5943014 ldr r3, [r4, #20] 3000cc88: e1530007 cmp r3, r7
_Thread_Set_priority( the_thread, new_priority );
3000cc8c: 11a00004 movne r0, r4 3000cc90: 11a01007 movne r1, r7 3000cc94: 1b00034c blne 3000d9cc <_Thread_Set_priority>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000cc98: e10f7000 mrs r7, CPSR 3000cc9c: e3873080 orr r3, r7, #128 ; 0x80 3000cca0: 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;
3000cca4: e5943010 ldr r3, [r4, #16]
if ( state != STATES_TRANSIENT ) {
3000cca8: e3530004 cmp r3, #4
3000ccac: 0a00000b beq 3000cce0 <_Thread_Change_priority+0x74>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
3000ccb0: e3150004 tst r5, #4 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
3000ccb4: 03c32004 biceq r2, r3, #4 <== NOT EXECUTED
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000ccb8: 05842010 streq r2, [r4, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ccbc: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3000ccc0: e59f2090 ldr r2, [pc, #144] ; 3000cd58 <_Thread_Change_priority+0xec><== NOT EXECUTED 3000ccc4: e0032002 and r2, r3, r2 <== NOT EXECUTED
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
3000ccc8: e3520000 cmp r2, #0 <== NOT EXECUTED
3000cccc: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000ccd0: e5940044 ldr r0, [r4, #68] ; 0x44 <== NOT EXECUTED 3000ccd4: e1a01004 mov r1, r4 <== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
3000ccd8: 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 );
3000ccdc: ea00030e b 3000d91c <_Thread_queue_Requeue> <== NOT EXECUTED
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
3000cce0: e2155004 ands r5, r5, #4 3000cce4: 159f5070 ldrne r5, [pc, #112] ; 3000cd5c <_Thread_Change_priority+0xf0>
3000cce8: 0a00000f beq 3000cd2c <_Thread_Change_priority+0xc0>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ccec: e10f3000 mrs r3, CPSR 3000ccf0: e129f007 msr CPSR_fc, r7 3000ccf4: 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();
3000ccf8: e1a0e00f mov lr, pc 3000ccfc: e595f008 ldr pc, [r5, #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 );
3000cd00: e59f3058 ldr r3, [pc, #88] ; 3000cd60 <_Thread_Change_priority+0xf4> 3000cd04: 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() &&
3000cd08: e593100c ldr r1, [r3, #12] 3000cd0c: e1520001 cmp r2, r1
3000cd10: 0a000003 beq 3000cd24 <_Thread_Change_priority+0xb8>
3000cd14: e5d22070 ldrb r2, [r2, #112] ; 0x70 3000cd18: e3520000 cmp r2, #0
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
3000cd1c: 13a02001 movne r2, #1 3000cd20: 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 (
3000cd24: e129f007 msr CPSR_fc, r7
3000cd28: e8bd80f0 pop {r4, r5, r6, r7, pc}
* 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 )
3000cd2c: 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 );
3000cd30: e5845010 str r5, [r4, #16]
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
3000cd34: e1a00004 mov r0, r4 3000cd38: e59f501c ldr r5, [pc, #28] ; 3000cd5c <_Thread_Change_priority+0xf0>
if ( prepend_it )
3000cd3c: 0a000002 beq 3000cd4c <_Thread_Change_priority+0xe0>
3000cd40: e1a0e00f mov lr, pc 3000cd44: e595f028 ldr pc, [r5, #40] ; 0x28 3000cd48: eaffffe7 b 3000ccec <_Thread_Change_priority+0x80>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
3000cd4c: e1a0e00f mov lr, pc 3000cd50: e595f024 ldr pc, [r5, #36] ; 0x24 3000cd54: eaffffe4 b 3000ccec <_Thread_Change_priority+0x80>
3000cdb0 <_Thread_Close>:
RTEMS_INLINE_ROUTINE void _Objects_Invalidate_Id(
Objects_Information *information,
Objects_Control *the_object
)
{
_Objects_Set_local_object(
3000cdb0: e1d120b8 ldrh r2, [r1, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000cdb4: e590301c ldr r3, [r0, #28]
void _Thread_Close(
Objects_Information *information,
Thread_Control *the_thread
)
{
3000cdb8: e92d4070 push {r4, r5, r6, lr}
3000cdbc: e1a04001 mov r4, r1
3000cdc0: e3a01000 mov r1, #0
3000cdc4: e7831102 str r1, [r3, r2, lsl #2]
3000cdc8: e1a06000 mov r6, r0
*
* 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;
3000cdcc: e59f5090 ldr r5, [pc, #144] ; 3000ce64 <_Thread_Close+0xb4>
return ctx.ok;
}
static inline void _User_extensions_Thread_delete( Thread_Control *deleted )
{
_User_extensions_Iterate(
3000cdd0: e1a00004 mov r0, r4 3000cdd4: e5953000 ldr r3, [r5] 3000cdd8: e59f1088 ldr r1, [pc, #136] ; 3000ce68 <_Thread_Close+0xb8>
--level;
3000cddc: e2433001 sub r3, r3, #1
_Thread_Dispatch_disable_level = level;
3000cde0: e5853000 str r3, [r5] 3000cde4: eb00039e bl 3000dc64 <_User_extensions_Iterate>
*
* 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;
3000cde8: e5953000 ldr r3, [r5]
++level;
3000cdec: e2833001 add r3, r3, #1
_Thread_Dispatch_disable_level = level;
3000cdf0: e5853000 str r3, [r5]
/* * Now we are in a dispatching critical section again and we * can take the thread OUT of the published set. It is invalid * to use this thread's Id OR name after this call. */ _Objects_Close( information, &the_thread->Object );
3000cdf4: e1a01004 mov r1, r4 3000cdf8: e1a00006 mov r0, r6 3000cdfc: ebfffbf2 bl 3000bdcc <_Objects_Close>
/*
* By setting the dormant state, the thread will not be considered
* for scheduling when we remove any blocking states.
*/
_Thread_Set_state( the_thread, STATES_DORMANT );
3000ce00: e1a00004 mov r0, r4 3000ce04: e3a01001 mov r1, #1 3000ce08: eb0002f6 bl 3000d9e8 <_Thread_Set_state>
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
3000ce0c: e1a00004 mov r0, r4 3000ce10: eb000293 bl 3000d864 <_Thread_queue_Extract_with_proxy> 3000ce14: e3500000 cmp r0, #0
3000ce18: 1a000002 bne 3000ce28 <_Thread_Close+0x78>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
3000ce1c: e5943050 ldr r3, [r4, #80] ; 0x50 3000ce20: e3530002 cmp r3, #2
3000ce24: 0a00000b beq 3000ce58 <_Thread_Close+0xa8>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Free(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.free( the_thread );
3000ce28: e59f303c ldr r3, [pc, #60] ; 3000ce6c <_Thread_Close+0xbc> 3000ce2c: e1a00004 mov r0, r4 3000ce30: e1a0e00f mov lr, pc 3000ce34: e593f01c ldr pc, [r3, #28]
/* * Free the rest of the memory associated with this task * and set the associated pointers to NULL for safety. */ _Thread_Stack_Free( the_thread ); the_thread->Start.stack = NULL;
3000ce38: e3a05000 mov r5, #0
/*
* Free the rest of the memory associated with this task
* and set the associated pointers to NULL for safety.
*/
_Thread_Stack_Free( the_thread );
3000ce3c: e1a00004 mov r0, r4 3000ce40: eb000319 bl 3000daac <_Thread_Stack_Free>
the_thread->Start.stack = NULL;
3000ce44: e58450bc str r5, [r4, #188] ; 0xbc
_Workspace_Free( the_thread->extensions );
3000ce48: e59400f8 ldr r0, [r4, #248] ; 0xf8 3000ce4c: eb0004db bl 3000e1c0 <_Workspace_Free>
the_thread->extensions = NULL;
3000ce50: e58450f8 str r5, [r4, #248] ; 0xf8
}
3000ce54: e8bd8070 pop {r4, r5, r6, pc}
*/
_Thread_Set_state( the_thread, STATES_DORMANT );
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
3000ce58: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000ce5c: eb000433 bl 3000df30 <_Watchdog_Remove> <== NOT EXECUTED 3000ce60: eafffff0 b 3000ce28 <_Thread_Close+0x78> <== NOT EXECUTED
3000cf44 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000cf44: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000cf48: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000cf4c: e1a0100d mov r1, sp <== NOT EXECUTED 3000cf50: eb000080 bl 3000d158 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000cf54: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000cf58: e3530000 cmp r3, #0 <== NOT EXECUTED 3000cf5c: 1a000005 bne 3000cf78 <_Thread_Delay_ended+0x34> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
3000cf60: e59f1018 ldr r1, [pc, #24] ; 3000cf80 <_Thread_Delay_ended+0x3c><== NOT EXECUTED 3000cf64: ebffff7e bl 3000cd64 <_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;
3000cf68: e59f3014 ldr r3, [pc, #20] ; 3000cf84 <_Thread_Delay_ended+0x40><== NOT EXECUTED 3000cf6c: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000cf70: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000cf74: e5832000 str r2, [r3] <== NOT EXECUTED
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
3000cf78: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000cf7c: e8bd8000 pop {pc} <== NOT EXECUTED
3000cf88 <_Thread_Dispatch>:
#if defined(RTEMS_SMP)
#include <rtems/score/smp.h>
#endif
void _Thread_Dispatch( void )
{
3000cf88: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
3000cf8c: e59f7188 ldr r7, [pc, #392] ; 3000d11c <_Thread_Dispatch+0x194>
#if defined(RTEMS_SMP)
#include <rtems/score/smp.h>
#endif
void _Thread_Dispatch( void )
{
3000cf90: e24dd018 sub sp, sp, #24
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
3000cf94: e5975008 ldr r5, [r7, #8]
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000cf98: e10f3000 mrs r3, CPSR 3000cf9c: e3832080 orr r2, r3, #128 ; 0x80 3000cfa0: e129f002 msr CPSR_fc, r2
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
3000cfa4: e5d72004 ldrb r2, [r7, #4] 3000cfa8: e3520000 cmp r2, #0 3000cfac: 059f916c ldreq r9, [pc, #364] ; 3000d120 <_Thread_Dispatch+0x198>
3000cfb0: 0a00004a beq 3000d0e0 <_Thread_Dispatch+0x158>
heir = _Thread_Heir;
3000cfb4: e597400c ldr r4, [r7, #12]
* This routine sets thread dispatch level to the
* value passed in.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_set_disable_level(uint32_t value)
{
_Thread_Dispatch_disable_level = value;
3000cfb8: e59f9160 ldr r9, [pc, #352] ; 3000d120 <_Thread_Dispatch+0x198> 3000cfbc: e3a02001 mov r2, #1
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
3000cfc0: e3a01000 mov r1, #0
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000cfc4: e1550004 cmp r5, r4 3000cfc8: e5892000 str r2, [r9]
heir = _Thread_Heir;
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
_Thread_Executing = heir;
3000cfcc: e5874008 str r4, [r7, #8]
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
3000cfd0: e5c71004 strb r1, [r7, #4]
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000cfd4: 0a000041 beq 3000d0e0 <_Thread_Dispatch+0x158>
3000cfd8: e59f0144 ldr r0, [pc, #324] ; 3000d124 <_Thread_Dispatch+0x19c>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
3000cfdc: e1a08007 mov r8, r7 3000cfe0: e2806004 add r6, r0, #4
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
3000cfe4: e5942078 ldr r2, [r4, #120] ; 0x78 3000cfe8: e3520001 cmp r2, #1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000cfec: 059fa134 ldreq sl, [pc, #308] ; 3000d128 <_Thread_Dispatch+0x1a0> 3000cff0: 059a2000 ldreq r2, [sl] 3000cff4: 05842074 streq r2, [r4, #116] ; 0x74
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000cff8: e129f003 msr CPSR_fc, r3
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
3000cffc: e59f1128 ldr r1, [pc, #296] ; 3000d12c <_Thread_Dispatch+0x1a4>
3000d000: e28d0010 add r0, sp, #16
3000d004: ebfff9e7 bl 3000b7a8 <_TOD_Get_with_nanoseconds>
3000d008: e2851080 add r1, r5, #128 ; 0x80
3000d00c: e8910003 ldm r1, {r0, r1}
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
3000d010: e28db010 add fp, sp, #16
3000d014: e89b0c00 ldm fp, {sl, fp}
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
3000d018: e59f2110 ldr r2, [pc, #272] ; 3000d130 <_Thread_Dispatch+0x1a8>
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
3000d01c: e88d0003 stm sp, {r0, r1}
3000d020: e5921000 ldr r1, [r2]
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
3000d024: e2873014 add r3, r7, #20
3000d028: e893000c ldm r3, {r2, r3}
3000d02c: e05aa002 subs sl, sl, r2
3000d030: e0cbb003 sbc fp, fp, r3
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
3000d034: e89d000c ldm sp, {r2, r3}
3000d038: e092200a adds r2, r2, sl
3000d03c: e0a3300b adc r3, r3, fp
3000d040: e3510000 cmp r1, #0
3000d044: e5852080 str r2, [r5, #128] ; 0x80
3000d048: e5853084 str r3, [r5, #132] ; 0x84
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
3000d04c: e28db010 add fp, sp, #16
3000d050: e89b0c00 ldm fp, {sl, fp}
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
3000d054: 15913000 ldrne r3, [r1]
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
3000d058: e587a014 str sl, [r7, #20] 3000d05c: e587b018 str fp, [r7, #24]
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
3000d060: 158530ec strne r3, [r5, #236] ; 0xec
*_Thread_libc_reent = heir->libc_reent;
3000d064: 159430ec ldrne r3, [r4, #236] ; 0xec
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000d068: e59fb0b4 ldr fp, [pc, #180] ; 3000d124 <_Thread_Dispatch+0x19c> 3000d06c: 15813000 strne r3, [r1] 3000d070: e59ba000 ldr sl, [fp]
{
const Chain_Control *chain = &_User_extensions_Switches_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
3000d074: e15a0006 cmp sl, r6
3000d078: 0a000006 beq 3000d098 <_Thread_Dispatch+0x110>
const User_extensions_Switch_control *extension =
(const User_extensions_Switch_control *) node;
(*extension->thread_switch)( executing, heir );
3000d07c: e1a00005 mov r0, r5 3000d080: e1a01004 mov r1, r4 3000d084: e1a0e00f mov lr, pc 3000d088: e59af008 ldr pc, [sl, #8]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
3000d08c: e59aa000 ldr sl, [sl]
{
const Chain_Control *chain = &_User_extensions_Switches_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
3000d090: e15a0006 cmp sl, r6
3000d094: 1afffff8 bne 3000d07c <_Thread_Dispatch+0xf4>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
3000d098: e28500c0 add r0, r5, #192 ; 0xc0 3000d09c: e28410c0 add r1, r4, #192 ; 0xc0 3000d0a0: eb000526 bl 3000e540 <_CPU_Context_switch>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
3000d0a4: e5975008 ldr r5, [r7, #8]
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d0a8: e10f3000 mrs r3, CPSR 3000d0ac: e3832080 orr r2, r3, #128 ; 0x80 3000d0b0: e129f002 msr CPSR_fc, r2
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
3000d0b4: e5d72004 ldrb r2, [r7, #4] 3000d0b8: e3520000 cmp r2, #0
3000d0bc: 0a000007 beq 3000d0e0 <_Thread_Dispatch+0x158>
heir = _Thread_Heir;
3000d0c0: e598400c ldr r4, [r8, #12] <== NOT EXECUTED 3000d0c4: e3a01001 mov r1, #1 <== NOT EXECUTED
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
3000d0c8: e3a02000 mov r2, #0 <== NOT EXECUTED
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000d0cc: e1540005 cmp r4, r5 <== NOT EXECUTED 3000d0d0: e5891000 str r1, [r9] <== NOT EXECUTED
heir = _Thread_Heir;
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
_Thread_Executing = heir;
3000d0d4: e5884008 str r4, [r8, #8] <== NOT EXECUTED
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
3000d0d8: e5c82004 strb r2, [r8, #4] <== NOT EXECUTED
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000d0dc: 1affffc0 bne 3000cfe4 <_Thread_Dispatch+0x5c> <== NOT EXECUTED
3000d0e0: e3a02000 mov r2, #0 3000d0e4: e5892000 str r2, [r9]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d0e8: 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;
3000d0ec: e59f6040 ldr r6, [pc, #64] ; 3000d134 <_Thread_Dispatch+0x1ac> 3000d0f0: e4964004 ldr r4, [r6], #4
{
const Chain_Control *chain = &_API_extensions_Post_switch_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
3000d0f4: e1540006 cmp r4, r6
3000d0f8: 0a000005 beq 3000d114 <_Thread_Dispatch+0x18c>
const API_extensions_Post_switch_control *post_switch =
(const API_extensions_Post_switch_control *) node;
(*post_switch->hook)( executing );
3000d0fc: e1a00005 mov r0, r5 3000d100: e1a0e00f mov lr, pc 3000d104: e594f008 ldr pc, [r4, #8]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(
const Chain_Node *the_node
)
{
return the_node->next;
3000d108: e5944000 ldr r4, [r4]
{
const Chain_Control *chain = &_API_extensions_Post_switch_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
3000d10c: e1540006 cmp r4, r6
3000d110: 1afffff9 bne 3000d0fc <_Thread_Dispatch+0x174>
#ifdef RTEMS_SMP
_Thread_Unnest_dispatch();
#endif
_API_extensions_Run_post_switch( executing );
}
3000d114: e28dd018 add sp, sp, #24
3000d118: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000d158 <_Thread_Get>:
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 ) ) {
3000d158: e2503000 subs r3, r0, #0
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
3000d15c: 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 ) ) {
3000d160: 0a000014 beq 3000d1b8 <_Thread_Get+0x60>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
3000d164: e1a01c23 lsr r1, r3, #24 3000d168: e2011007 and r1, r1, #7
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000d16c: e2410001 sub r0, r1, #1 3000d170: e3500002 cmp r0, #2
3000d174: 8a00000b bhi 3000d1a8 <_Thread_Get+0x50>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000d178: e1a0cda3 lsr ip, r3, #27
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
3000d17c: e35c0001 cmp ip, #1
3000d180: 1a000008 bne 3000d1a8 <_Thread_Get+0x50>
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
3000d184: e59f0054 ldr r0, [pc, #84] ; 3000d1e0 <_Thread_Get+0x88> 3000d188: e7900101 ldr r0, [r0, r1, 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 ) {
3000d18c: e3500000 cmp r0, #0
3000d190: 0a000010 beq 3000d1d8 <_Thread_Get+0x80>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
3000d194: e5900004 ldr r0, [r0, #4]
if ( !information ) {
3000d198: e3500000 cmp r0, #0
3000d19c: 0a00000d beq 3000d1d8 <_Thread_Get+0x80>
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
3000d1a0: e1a01003 mov r1, r3 3000d1a4: eafffc1a b 3000c214 <_Objects_Get>
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
3000d1a8: e3a03001 mov r3, #1 3000d1ac: 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;
3000d1b0: e3a00000 mov r0, #0
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
3000d1b4: e12fff1e bx 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;
3000d1b8: e59f1024 ldr r1, [pc, #36] ; 3000d1e4 <_Thread_Get+0x8c> 3000d1bc: e5910000 ldr r0, [r1]
++level;
3000d1c0: e2800001 add r0, r0, #1
_Thread_Dispatch_disable_level = level;
3000d1c4: e5810000 str r0, [r1]
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;
3000d1c8: e5823000 str r3, [r2]
tp = _Thread_Executing;
3000d1cc: e59f3014 ldr r3, [pc, #20] ; 3000d1e8 <_Thread_Get+0x90> 3000d1d0: e5930008 ldr r0, [r3, #8]
goto done;
3000d1d4: e12fff1e bx lr
goto done;
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
3000d1d8: e582c000 str ip, [r2] <== NOT EXECUTED
goto done;
3000d1dc: e12fff1e bx lr <== NOT EXECUTED
300117d4 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
300117d4: e92d4030 push {r4, r5, lr}
the_thread->resource_count = 0; the_thread->is_preemptible = the_thread->Start.is_preemptible; the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
300117d8: e590c0a0 ldr ip, [r0, #160] ; 0xa0
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
the_thread->resource_count = 0;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
300117dc: e5d0e09c ldrb lr, [r0, #156] ; 0x9c
the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout;
300117e0: e59030a4 ldr r3, [r0, #164] ; 0xa4
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
the_thread->resource_count = 0;
300117e4: e3a05000 mov r5, #0 300117e8: e580501c str r5, [r0, #28]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
300117ec: e5c0e070 strb lr, [r0, #112] ; 0x70
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
300117f0: e580c078 str ip, [r0, #120] ; 0x78
the_thread->budget_callout = the_thread->Start.budget_callout;
300117f4: e580307c str r3, [r0, #124] ; 0x7c
the_thread->Start.pointer_argument = pointer_argument;
300117f8: e5801094 str r1, [r0, #148] ; 0x94
the_thread->Start.numeric_argument = numeric_argument;
300117fc: e5802098 str r2, [r0, #152] ; 0x98
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
30011800: e1a04000 mov r4, r0
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
30011804: ebfff233 bl 3000e0d8 <_Thread_queue_Extract_with_proxy> 30011808: e1500005 cmp r0, r5
3001180c: 1a000002 bne 3001181c <_Thread_Reset+0x48>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
30011810: e5943050 ldr r3, [r4, #80] ; 0x50 30011814: e3530002 cmp r3, #2
30011818: 0a000007 beq 3001183c <_Thread_Reset+0x68>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
3001181c: e59410ac ldr r1, [r4, #172] ; 0xac
30011820: e5943014 ldr r3, [r4, #20]
30011824: e1530001 cmp r3, r1
30011828: 08bd8030 popeq {r4, r5, pc}
the_thread->real_priority = the_thread->Start.initial_priority;
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
3001182c: e1a00004 mov r0, r4
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
the_thread->real_priority = the_thread->Start.initial_priority;
30011830: e5841018 str r1, [r4, #24]
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
}
}
30011834: e8bd4030 pop {r4, r5, lr}
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
the_thread->real_priority = the_thread->Start.initial_priority;
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
30011838: eafff29e b 3000e2b8 <_Thread_Set_priority>
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
3001183c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30011840: ebfff3f5 bl 3000e81c <_Watchdog_Remove> <== NOT EXECUTED 30011844: eafffff4 b 3001181c <_Thread_Reset+0x48> <== NOT EXECUTED
3000db14 <_Thread_Start>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
3000db14: e590c010 ldr ip, [r0, #16]
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000db18: e92d4010 push {r4, lr}
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000db1c: e21cc001 ands ip, ip, #1
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000db20: e1a04000 mov r4, r0
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000db24: 1a000001 bne 3000db30 <_Thread_Start+0x1c>
_User_extensions_Thread_start( the_thread );
return true;
}
return false;
3000db28: e1a0000c mov r0, ip <== NOT EXECUTED
}
3000db2c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( _States_Is_dormant( the_thread->current_state ) ) {
the_thread->Start.entry_point = (Thread_Entry) entry_point;
the_thread->Start.prototype = the_prototype;
the_thread->Start.pointer_argument = pointer_argument;
3000db30: e5803094 str r3, [r0, #148] ; 0x94
the_thread->Start.numeric_argument = numeric_argument;
3000db34: 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;
3000db38: e580208c str r2, [r0, #140] ; 0x8c
the_thread->Start.prototype = the_prototype;
3000db3c: e5801090 str r1, [r0, #144] ; 0x90
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
3000db40: e5803098 str r3, [r0, #152] ; 0x98
_Thread_Load_environment( the_thread );
3000db44: eb000c3b bl 30010c38 <_Thread_Load_environment>
_Thread_Ready( the_thread );
3000db48: e1a00004 mov r0, r4 3000db4c: eb000cd9 bl 30010eb8 <_Thread_Ready>
);
}
static inline void _User_extensions_Thread_start( Thread_Control *started )
{
_User_extensions_Iterate(
3000db50: e1a00004 mov r0, r4 3000db54: e59f1008 ldr r1, [pc, #8] ; 3000db64 <_Thread_Start+0x50> 3000db58: eb000041 bl 3000dc64 <_User_extensions_Iterate>
_User_extensions_Thread_start( the_thread );
return true;
3000db5c: e3a00001 mov r0, #1
3000db60: e8bd8010 pop {r4, pc}
3000cc14 <_Thread_blocking_operation_Cancel>:
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000cc14: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== 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 ) ) {
3000cc18: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000cc1c: e24dd004 sub sp, sp, #4 <== 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 ) ) {
3000cc20: e3530002 cmp r3, #2 <== NOT EXECUTED
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000cc24: e3a03000 mov r3, #0 <== NOT EXECUTED 3000cc28: 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 ) ) {
3000cc2c: 0a000005 beq 3000cc48 <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED 3000cc30: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000cc34: e1a00001 mov r0, r1 <== NOT EXECUTED 3000cc38: e59f1028 ldr r1, [pc, #40] ; 3000cc68 <_Thread_blocking_operation_Cancel+0x54><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000cc3c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000cc40: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
3000cc44: ea000046 b 3000cd64 <_Thread_Clear_state> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000cc48: e3a03003 mov r3, #3 <== NOT EXECUTED 3000cc4c: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000cc50: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000cc54: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000cc58: e58d1000 str r1, [sp] <== NOT EXECUTED 3000cc5c: eb0004b3 bl 3000df30 <_Watchdog_Remove> <== NOT EXECUTED 3000cc60: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000cc64: eafffff2 b 3000cc34 <_Thread_blocking_operation_Cancel+0x20><== NOT EXECUTED
30010c88 <_Thread_queue_Dequeue_fifo>:
#include <rtems/score/tqdata.h>
Thread_Control *_Thread_queue_Dequeue_fifo(
Thread_queue_Control *the_thread_queue
)
{
30010c88: e92d4010 push {r4, lr}
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30010c8c: e10f2000 mrs r2, CPSR 30010c90: e3823080 orr r3, r2, #128 ; 0x80 30010c94: 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;
30010c98: e1a03000 mov r3, r0 30010c9c: e4934004 ldr r4, [r3], #4
ISR_Level level;
Thread_Control *the_thread;
_ISR_Disable( level );
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
30010ca0: e1540003 cmp r4, r3
30010ca4: 0a000017 beq 30010d08 <_Thread_queue_Dequeue_fifo+0x80>
the_thread = (Thread_Control *)
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30010ca8: e5941050 ldr r1, [r4, #80] ; 0x50
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
30010cac: e5943000 ldr r3, [r4] 30010cb0: e3510002 cmp r1, #2
head->next = new_first;
30010cb4: e5803000 str r3, [r0]
new_first->previous = head;
30010cb8: e5830004 str r0, [r3, #4]
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
the_thread = (Thread_Control *)
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
30010cbc: e3a03000 mov r3, #0 30010cc0: e5843044 str r3, [r4, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30010cc4: 0a000005 beq 30010ce0 <_Thread_queue_Dequeue_fifo+0x58>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30010cc8: e129f002 msr CPSR_fc, r2
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30010ccc: e59f1040 ldr r1, [pc, #64] ; 30010d14 <_Thread_queue_Dequeue_fifo+0x8c> 30010cd0: e1a00004 mov r0, r4 30010cd4: ebfff022 bl 3000cd64 <_Thread_Clear_state>
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
30010cd8: e1a00004 mov r0, r4
30010cdc: e8bd8010 pop {r4, pc}
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
30010ce0: e3a03003 mov r3, #3 <== NOT EXECUTED 30010ce4: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 30010ce8: 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 );
30010cec: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30010cf0: ebfff48e bl 3000df30 <_Watchdog_Remove> <== NOT EXECUTED 30010cf4: e1a00004 mov r0, r4 <== NOT EXECUTED 30010cf8: e59f1014 ldr r1, [pc, #20] ; 30010d14 <_Thread_queue_Dequeue_fifo+0x8c><== NOT EXECUTED 30010cfc: ebfff018 bl 3000cd64 <_Thread_Clear_state> <== NOT EXECUTED
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
30010d00: e1a00004 mov r0, r4 <== NOT EXECUTED
30010d04: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010d08: e129f002 msr CPSR_fc, r2
return the_thread;
}
_ISR_Enable( level );
return NULL;
30010d0c: e3a04000 mov r4, #0 30010d10: eafffff0 b 30010cd8 <_Thread_queue_Dequeue_fifo+0x50>
3000d514 <_Thread_queue_Dequeue_priority>:
#include <rtems/score/tqdata.h>
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
3000d514: e92d4010 push {r4, lr}
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d518: e10fc000 mrs ip, CPSR 3000d51c: e38c3080 orr r3, ip, #128 ; 0x80 3000d520: e129f003 msr CPSR_fc, r3
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000d524: e3a03000 mov r3, #0
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
3000d528: e0832083 add r2, r3, r3, lsl #1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000d52c: e7904102 ldr r4, [r0, r2, lsl #2] 3000d530: e0801102 add r1, r0, r2, lsl #2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000d534: e2812004 add r2, r1, #4 3000d538: e1540002 cmp r4, r2
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000d53c: e2833001 add r3, r3, #1
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
3000d540: 1a000005 bne 3000d55c <_Thread_queue_Dequeue_priority+0x48>
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000d544: e3530004 cmp r3, #4
3000d548: 1afffff6 bne 3000d528 <_Thread_queue_Dequeue_priority+0x14>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d54c: e129f00c msr CPSR_fc, ip
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
return NULL;
3000d550: e3a04000 mov r4, #0
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000d554: e1a00004 mov r0, r4
3000d558: e8bd8010 pop {r4, pc}
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000d55c: 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 );
3000d560: e284203c add r2, 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 ) ) {
3000d564: e1530002 cmp r3, r2
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
3000d568: e3a02000 mov r2, #0 3000d56c: e5842044 str r2, [r4, #68] ; 0x44
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;
3000d570: e5941004 ldr r1, [r4, #4]
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;
3000d574: e5942000 ldr r2, [r4]
previous_node = the_thread->Object.Node.previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000d578: 0a000020 beq 3000d600 <_Thread_queue_Dequeue_priority+0xec>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
3000d57c: e5940040 ldr r0, [r4, #64] ; 0x40 <== NOT EXECUTED
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
3000d580: e593e000 ldr lr, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000d584: e5823004 str r3, [r2, #4] <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
3000d588: e5813000 str r3, [r1] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000d58c: e5831004 str r1, [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;
3000d590: e5832000 str r2, [r3] <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000d594: e5941038 ldr r1, [r4, #56] ; 0x38 <== NOT EXECUTED 3000d598: e5942040 ldr r2, [r4, #64] ; 0x40 <== NOT EXECUTED 3000d59c: e1510002 cmp r1, r2 <== NOT EXECUTED 3000d5a0: 0a000005 beq 3000d5bc <_Thread_queue_Dequeue_priority+0xa8><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000d5a4: e2831038 add r1, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
3000d5a8: e283203c add r2, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
3000d5ac: e58e1004 str r1, [lr, #4] <== NOT EXECUTED
head->next = new_second_node;
3000d5b0: e583e038 str lr, [r3, #56] ; 0x38 <== NOT EXECUTED
tail->previous = last_node;
3000d5b4: e5830040 str r0, [r3, #64] ; 0x40 <== NOT EXECUTED
last_node->next = tail;
3000d5b8: e5802000 str r2, [r0] <== NOT EXECUTED
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000d5bc: e5943050 ldr r3, [r4, #80] ; 0x50 3000d5c0: e3530002 cmp r3, #2
3000d5c4: 0a000004 beq 3000d5dc <_Thread_queue_Dequeue_priority+0xc8>
3000d5c8: e129f00c msr CPSR_fc, ip
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000d5cc: e59f1038 ldr r1, [pc, #56] ; 3000d60c <_Thread_queue_Dequeue_priority+0xf8> 3000d5d0: e1a00004 mov r0, r4 3000d5d4: ebfffde2 bl 3000cd64 <_Thread_Clear_state> 3000d5d8: eaffffdd b 3000d554 <_Thread_queue_Dequeue_priority+0x40>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000d5dc: e3a03003 mov r3, #3 <== NOT EXECUTED 3000d5e0: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000d5e4: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000d5e8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000d5ec: eb00024f bl 3000df30 <_Watchdog_Remove> <== NOT EXECUTED 3000d5f0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d5f4: e59f1010 ldr r1, [pc, #16] ; 3000d60c <_Thread_queue_Dequeue_priority+0xf8><== NOT EXECUTED 3000d5f8: ebfffdd9 bl 3000cd64 <_Thread_Clear_state> <== NOT EXECUTED 3000d5fc: eaffffd4 b 3000d554 <_Thread_queue_Dequeue_priority+0x40> <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
3000d600: e5812000 str r2, [r1]
next_node->previous = previous_node;
3000d604: e5821004 str r1, [r2, #4] 3000d608: eaffffeb b 3000d5bc <_Thread_queue_Dequeue_priority+0xa8>
3000d6bc <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
3000d6bc: e5913014 ldr r3, [r1, #20]
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
3000d6c0: e92d07f0 push {r4, r5, r6, r7, r8, r9, sl}
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
3000d6c4: e1a0c323 lsr ip, r3, #6
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 );
3000d6c8: e281503c add r5, r1, #60 ; 0x3c
_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 ];
3000d6cc: e08cc08c add ip, ip, ip, lsl #1
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
3000d6d0: e3130020 tst r3, #32 3000d6d4: e2814038 add r4, r1, #56 ; 0x38
head->next = tail;
3000d6d8: e5815038 str r5, [r1, #56] ; 0x38
_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 ];
3000d6dc: e080c10c add ip, r0, ip, lsl #2
head->previous = NULL;
3000d6e0: e3a05000 mov r5, #0 3000d6e4: e581503c str r5, [r1, #60] ; 0x3c
tail->previous = head;
3000d6e8: e5814040 str r4, [r1, #64] ; 0x40
block_state = the_thread_queue->state;
3000d6ec: e5906038 ldr r6, [r0, #56] ; 0x38 3000d6f0: 028c9004 addeq r9, ip, #4 3000d6f4: 159f9164 ldrne r9, [pc, #356] ; 3000d860 <_Thread_queue_Enqueue_priority+0x1a4>
if ( _Thread_queue_Is_reverse_search( priority ) )
3000d6f8: 1a00001b bne 3000d76c <_Thread_queue_Enqueue_priority+0xb0>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d6fc: e10fa000 mrs sl, CPSR 3000d700: e38a4080 orr r4, sl, #128 ; 0x80 3000d704: e129f004 msr CPSR_fc, r4 3000d708: e1a0800a mov r8, sl
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000d70c: e59c4000 ldr r4, [ip]
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 ) ) {
3000d710: e1540009 cmp r4, r9
3000d714: 1a000009 bne 3000d740 <_Thread_queue_Enqueue_priority+0x84>
3000d718: ea00004e b 3000d858 <_Thread_queue_Enqueue_priority+0x19c>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d71c: e10f7000 mrs r7, CPSR 3000d720: e129f00a msr CPSR_fc, sl 3000d724: e129f007 msr CPSR_fc, r7
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
3000d728: e5947010 ldr r7, [r4, #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) ) {
3000d72c: e1160007 tst r6, r7
3000d730: 0a000031 beq 3000d7fc <_Thread_queue_Enqueue_priority+0x140>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
3000d734: e5944000 ldr r4, [r4]
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 ) ) {
3000d738: e1540009 cmp r4, r9
3000d73c: 0a000002 beq 3000d74c <_Thread_queue_Enqueue_priority+0x90>
search_priority = search_thread->current_priority;
3000d740: e5945014 ldr r5, [r4, #20]
if ( priority <= search_priority )
3000d744: e1530005 cmp r3, r5
3000d748: 8afffff3 bhi 3000d71c <_Thread_queue_Enqueue_priority+0x60>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
3000d74c: e590c030 ldr ip, [r0, #48] ; 0x30 3000d750: e35c0001 cmp ip, #1
3000d754: 0a00002a beq 3000d804 <_Thread_queue_Enqueue_priority+0x148> * 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;
3000d758: e5828000 str r8, [r2] <== NOT EXECUTED
return the_thread_queue->sync_state; }
3000d75c: e1a0000c mov r0, ip
3000d760: e8bd07f0 pop {r4, r5, r6, r7, r8, r9, sl}
3000d764: e12fff1e bx lr
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d768: e129f00a msr CPSR_fc, sl <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
3000d76c: e5d95000 ldrb r5, [r9] 3000d770: e2855001 add r5, r5, #1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d774: e10fa000 mrs sl, CPSR 3000d778: e38a4080 orr r4, sl, #128 ; 0x80 3000d77c: e129f004 msr CPSR_fc, r4 3000d780: e1a0800a mov r8, sl
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
3000d784: e59c4008 ldr r4, [ip, #8]
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
3000d788: e154000c cmp r4, ip
3000d78c: 1a000009 bne 3000d7b8 <_Thread_queue_Enqueue_priority+0xfc>
3000d790: ea00000b b 3000d7c4 <_Thread_queue_Enqueue_priority+0x108>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d794: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000d798: e129f00a msr CPSR_fc, sl <== NOT EXECUTED 3000d79c: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED 3000d7a0: e5947010 ldr r7, [r4, #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) ) {
3000d7a4: e1160007 tst r6, r7 <== NOT EXECUTED 3000d7a8: 0affffee beq 3000d768 <_Thread_queue_Enqueue_priority+0xac><== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
3000d7ac: e5944004 ldr r4, [r4, #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 ) ) {
3000d7b0: e154000c cmp r4, ip <== NOT EXECUTED 3000d7b4: 0a000002 beq 3000d7c4 <_Thread_queue_Enqueue_priority+0x108><== NOT EXECUTED
search_priority = search_thread->current_priority;
3000d7b8: e5945014 ldr r5, [r4, #20]
if ( priority >= search_priority )
3000d7bc: e1530005 cmp r3, r5
3000d7c0: 3afffff3 bcc 3000d794 <_Thread_queue_Enqueue_priority+0xd8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
3000d7c4: e590c030 ldr ip, [r0, #48] ; 0x30 3000d7c8: e35c0001 cmp ip, #1
3000d7cc: 1affffe1 bne 3000d758 <_Thread_queue_Enqueue_priority+0x9c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
3000d7d0: e1530005 cmp r3, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000d7d4: e3a03000 mov r3, #0 3000d7d8: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
3000d7dc: 0a000014 beq 3000d834 <_Thread_queue_Enqueue_priority+0x178>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
3000d7e0: e5943000 ldr r3, [r4]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
3000d7e4: e8810018 stm r1, {r3, r4}
the_node->previous = search_node; search_node->next = the_node; next_node->previous = the_node;
3000d7e8: e5831004 str r1, [r3, #4]
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
3000d7ec: e5841000 str r1, [r4]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
3000d7f0: e5810044 str r0, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d7f4: e129f00a msr CPSR_fc, sl
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000d7f8: eaffffd7 b 3000d75c <_Thread_queue_Enqueue_priority+0xa0>
3000d7fc: e129f00a msr CPSR_fc, sl <== NOT EXECUTED 3000d800: eaffffbd b 3000d6fc <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
3000d804: e1530005 cmp r3, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000d808: e3a03000 mov r3, #0 3000d80c: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
3000d810: 0a000007 beq 3000d834 <_Thread_queue_Enqueue_priority+0x178>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
3000d814: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000d818: e5814000 str r4, [r1]
the_node->previous = previous_node;
3000d81c: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
3000d820: e5831000 str r1, [r3]
search_node->previous = the_node;
3000d824: e5841004 str r1, [r4, #4]
the_thread->Wait.queue = the_thread_queue;
3000d828: e5810044 str r0, [r1, #68] ; 0x44 3000d82c: e129f00a msr CPSR_fc, sl
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000d830: eaffffc9 b 3000d75c <_Thread_queue_Enqueue_priority+0xa0>
_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;
3000d834: e5943040 ldr r3, [r4, #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 );
3000d838: e284203c add r2, r4, #60 ; 0x3c <== NOT EXECUTED
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
3000d83c: e881000c stm r1, {r2, r3} <== NOT EXECUTED
previous_node->next = the_node;
3000d840: e5831000 str r1, [r3] <== NOT EXECUTED
search_node->previous = the_node;
3000d844: e5841040 str r1, [r4, #64] ; 0x40 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
3000d848: e5810044 str r0, [r1, #68] ; 0x44 <== NOT EXECUTED 3000d84c: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000d850: e3a0c001 mov ip, #1 <== NOT EXECUTED 3000d854: eaffffc0 b 3000d75c <_Thread_queue_Enqueue_priority+0xa0> <== NOT EXECUTED
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
3000d858: e3e05000 mvn r5, #0 3000d85c: eaffffba b 3000d74c <_Thread_queue_Enqueue_priority+0x90>
30012704 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
30012704: e52de004 push {lr} ; (str lr, [sp, #-4]!)
30012708: e24dd004 sub sp, sp, #4
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001270c: e10f0000 mrs r0, CPSR 30012710: e3803080 orr r3, r0, #128 ; 0x80 30012714: e129f003 msr CPSR_fc, r3 30012718: e59f3070 ldr r3, [pc, #112] ; 30012790 <_Thread_queue_Extract_fifo+0x8c> 3001271c: e5912010 ldr r2, [r1, #16] 30012720: e0023003 and r3, r2, r3
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
30012724: e3530000 cmp r3, #0
30012728: 0a00000d beq 30012764 <_Thread_queue_Extract_fifo+0x60>
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3001272c: e591c050 ldr ip, [r1, #80] ; 0x50
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
30012730: e891000c ldm r1, {r2, r3}
30012734: e35c0002 cmp ip, #2
next->previous = previous;
30012738: e5823004 str r3, [r2, #4]
previous->next = next;
3001273c: e5832000 str r2, [r3]
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
30012740: e3a03000 mov r3, #0 30012744: e5813044 str r3, [r1, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30012748: 0a000008 beq 30012770 <_Thread_queue_Extract_fifo+0x6c>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001274c: e129f000 msr CPSR_fc, r0
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30012750: e1a00001 mov r0, r1 30012754: e59f1038 ldr r1, [pc, #56] ; 30012794 <_Thread_queue_Extract_fifo+0x90>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
30012758: e28dd004 add sp, sp, #4
3001275c: e49de004 pop {lr} ; (ldr lr, [sp], #4)
30012760: eaffe97f b 3000cd64 <_Thread_Clear_state>
30012764: e129f000 msr CPSR_fc, r0
30012768: e28dd004 add sp, sp, #4
3001276c: e8bd8000 pop {pc}
30012770: e3a03003 mov r3, #3 <== NOT EXECUTED 30012774: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 30012778: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3001277c: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 30012780: e58d1000 str r1, [sp] <== NOT EXECUTED 30012784: ebffede9 bl 3000df30 <_Watchdog_Remove> <== NOT EXECUTED 30012788: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3001278c: eaffffef b 30012750 <_Thread_queue_Extract_fifo+0x4c> <== NOT EXECUTED
30010d88 <_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
)
{
30010d88: e92d4070 push {r4, r5, r6, lr}
30010d8c: e20220ff and r2, r2, #255 ; 0xff
30010d90: e24dd004 sub sp, sp, #4
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30010d94: e10fc000 mrs ip, CPSR 30010d98: e38c3080 orr r3, ip, #128 ; 0x80 30010d9c: 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);
30010da0: e59f30bc ldr r3, [pc, #188] ; 30010e64 <_Thread_queue_Extract_priority_helper+0xdc> 30010da4: e5910010 ldr r0, [r1, #16] 30010da8: 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 ) ) {
30010dac: e3530000 cmp r3, #0
30010db0: 0a000020 beq 30010e38 <_Thread_queue_Extract_priority_helper+0xb0>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
30010db4: e5913038 ldr r3, [r1, #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 );
30010db8: e281003c add r0, r1, #60 ; 0x3c <== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
30010dbc: e1530000 cmp r3, r0 <== 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;
30010dc0: e8910011 ldm r1, {r0, r4} <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
30010dc4: 05840000 streq r0, [r4] <== NOT EXECUTED
next_node->previous = previous_node;
30010dc8: 05804004 streq r4, [r0, #4] <== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
30010dcc: 0a00000e beq 30010e0c <_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;
30010dd0: e5915040 ldr r5, [r1, #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;
30010dd4: e5936000 ldr r6, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
30010dd8: 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;
30010ddc: e5843000 str r3, [r4] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
30010de0: e8830011 stm r3, {r0, r4} <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
30010de4: e5914038 ldr r4, [r1, #56] ; 0x38 <== NOT EXECUTED 30010de8: e5910040 ldr r0, [r1, #64] ; 0x40 <== NOT EXECUTED 30010dec: e1540000 cmp r4, r0 <== NOT EXECUTED 30010df0: 0a000005 beq 30010e0c <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
30010df4: e2834038 add r4, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
30010df8: e283003c add r0, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
30010dfc: e5864004 str r4, [r6, #4] <== NOT EXECUTED
head->next = new_second_node;
30010e00: e5836038 str r6, [r3, #56] ; 0x38 <== NOT EXECUTED
tail->previous = last_node;
30010e04: e5835040 str r5, [r3, #64] ; 0x40 <== NOT EXECUTED
last_node->next = tail;
30010e08: e5850000 str r0, [r5] <== NOT EXECUTED
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
30010e0c: e3520000 cmp r2, #0 <== NOT EXECUTED 30010e10: 1a000008 bne 30010e38 <_Thread_queue_Extract_priority_helper+0xb0><== NOT EXECUTED
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30010e14: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED 30010e18: e3530002 cmp r3, #2 <== NOT EXECUTED 30010e1c: 0a000008 beq 30010e44 <_Thread_queue_Extract_priority_helper+0xbc><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30010e20: e129f00c msr CPSR_fc, ip <== NOT EXECUTED 30010e24: e1a00001 mov r0, r1 <== NOT EXECUTED 30010e28: e59f1038 ldr r1, [pc, #56] ; 30010e68 <_Thread_queue_Extract_priority_helper+0xe0><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
30010e2c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30010e30: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
30010e34: eaffefca b 3000cd64 <_Thread_Clear_state> <== NOT EXECUTED
30010e38: e129f00c msr CPSR_fc, ip
30010e3c: e28dd004 add sp, sp, #4
30010e40: e8bd8070 pop {r4, r5, r6, pc}
30010e44: e3a03003 mov r3, #3 <== NOT EXECUTED 30010e48: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 30010e4c: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
30010e50: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 30010e54: e58d1000 str r1, [sp] <== NOT EXECUTED 30010e58: ebfff434 bl 3000df30 <_Watchdog_Remove> <== NOT EXECUTED 30010e5c: e59d1000 ldr r1, [sp] <== NOT EXECUTED 30010e60: eaffffef b 30010e24 <_Thread_queue_Extract_priority_helper+0x9c><== NOT EXECUTED
3000f910 <_Thread_queue_First_priority>:
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3000f910: 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 ] ) )
3000f914: e0832083 add r2, r3, r3, lsl #1 <== NOT EXECUTED 3000f918: e0801102 add r1, r0, r2, lsl #2 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000f91c: e7902102 ldr r2, [r0, r2, lsl #2] <== 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 );
3000f920: e2811004 add r1, r1, #4 <== NOT EXECUTED 3000f924: e1520001 cmp r2, r1 <== NOT EXECUTED
{
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000f928: e2833001 add r3, r3, #1 <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
3000f92c: 1a000002 bne 3000f93c <_Thread_queue_First_priority+0x2c> <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3000f930: e3530004 cmp r3, #4 <== NOT EXECUTED 3000f934: 1afffff6 bne 3000f914 <_Thread_queue_First_priority+0x4> <== 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;
3000f938: e3a02000 mov r2, #0 <== NOT EXECUTED
}
3000f93c: e1a00002 mov r0, r2 <== NOT EXECUTED 3000f940: e12fff1e bx lr <== NOT EXECUTED
30010e6c <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
30010e6c: e1a01000 mov r1, r0 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
30010e70: 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 &&
30010e74: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 30010e78: e3530000 cmp r3, #0 <== NOT EXECUTED 30010e7c: 0a000003 beq 30010e90 <_Thread_queue_Process_timeout+0x24> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
30010e80: e59f202c ldr r2, [pc, #44] ; 30010eb4 <_Thread_queue_Process_timeout+0x48><== NOT EXECUTED 30010e84: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 30010e88: e1510002 cmp r1, r2 <== NOT EXECUTED 30010e8c: 0a000002 beq 30010e9c <_Thread_queue_Process_timeout+0x30> <== NOT EXECUTED
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
30010e90: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 30010e94: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
30010e98: eaffffb4 b 30010d70 <_Thread_queue_Extract> <== NOT EXECUTED
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
30010e9c: e3530003 cmp r3, #3 <== NOT EXECUTED
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
30010ea0: 1590303c ldrne r3, [r0, #60] ; 0x3c <== NOT EXECUTED 30010ea4: 15813034 strne r3, [r1, #52] ; 0x34 <== NOT EXECUTED
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
30010ea8: 13a03002 movne r3, #2 <== NOT EXECUTED 30010eac: 15803030 strne r3, [r0, #48] ; 0x30 <== NOT EXECUTED 30010eb0: e12fff1e bx lr <== NOT EXECUTED
3000d91c <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000d91c: e92d4070 push {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 )
3000d920: e2504000 subs r4, r0, #0 <== NOT EXECUTED
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000d924: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000d928: 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 )
3000d92c: 0a000002 beq 3000d93c <_Thread_queue_Requeue+0x20> <== 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 ) {
3000d930: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000d934: e3530001 cmp r3, #1 <== NOT EXECUTED 3000d938: 0a000001 beq 3000d944 <_Thread_queue_Requeue+0x28> <== NOT EXECUTED
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
3000d93c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000d940: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d944: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000d948: e3862080 orr r2, r6, #128 ; 0x80 <== NOT EXECUTED 3000d94c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000d950: e59f2034 ldr r2, [pc, #52] ; 3000d98c <_Thread_queue_Requeue+0x70><== NOT EXECUTED 3000d954: e591c010 ldr ip, [r1, #16] <== NOT EXECUTED 3000d958: e00c2002 and r2, ip, r2 <== 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 ) ) {
3000d95c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000d960: 1a000001 bne 3000d96c <_Thread_queue_Requeue+0x50> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d964: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000d968: eafffff3 b 3000d93c <_Thread_queue_Requeue+0x20> <== NOT EXECUTED
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
3000d96c: e1a02003 mov r2, r3 <== 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;
3000d970: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED 3000d974: eb000d03 bl 30010d88 <_Thread_queue_Extract_priority_helper><== NOT EXECUTED
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
3000d978: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d97c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000d980: e1a0200d mov r2, sp <== NOT EXECUTED 3000d984: ebffff4c bl 3000d6bc <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 3000d988: eafffff5 b 3000d964 <_Thread_queue_Requeue+0x48> <== NOT EXECUTED
3000d990 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000d990: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000d994: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d998: e1a0100d mov r1, sp <== NOT EXECUTED 3000d99c: ebfffded bl 3000d158 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000d9a0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000d9a4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d9a8: 1a000004 bne 3000d9c0 <_Thread_queue_Timeout+0x30> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
3000d9ac: eb000d2e bl 30010e6c <_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;
3000d9b0: e59f3010 ldr r3, [pc, #16] ; 3000d9c8 <_Thread_queue_Timeout+0x38><== NOT EXECUTED 3000d9b4: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000d9b8: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000d9bc: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000d9c0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000d9c4: e8bd8000 pop {pc} <== NOT EXECUTED
3001afac <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
3001afac: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3001afb0: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001afb4: e28d6018 add r6, sp, #24 <== NOT EXECUTED 3001afb8: e28d1010 add r1, sp, #16 <== NOT EXECUTED 3001afbc: e2862004 add r2, r6, #4 <== NOT EXECUTED 3001afc0: e58d100c str r1, [sp, #12] <== NOT EXECUTED 3001afc4: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001afc8: e28d100c add r1, sp, #12 <== NOT EXECUTED 3001afcc: e28d201c add r2, sp, #28 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3001afd0: e3a03000 mov r3, #0 <== NOT EXECUTED 3001afd4: e2807068 add r7, r0, #104 ; 0x68 <== NOT EXECUTED
tail->previous = head;
3001afd8: e58d1014 str r1, [sp, #20] <== NOT EXECUTED 3001afdc: e2805030 add r5, r0, #48 ; 0x30 <== NOT EXECUTED 3001afe0: e58d2000 str r2, [sp] <== NOT EXECUTED 3001afe4: e2801008 add r1, r0, #8 <== NOT EXECUTED 3001afe8: e2802040 add r2, r0, #64 ; 0x40 <== NOT EXECUTED 3001afec: e59f81c4 ldr r8, [pc, #452] ; 3001b1b8 <_Timer_server_Body+0x20c><== NOT EXECUTED 3001aff0: e59f91c4 ldr r9, [pc, #452] ; 3001b1bc <_Timer_server_Body+0x210><== 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;
3001aff4: e1a0a007 mov sl, r7 <== NOT EXECUTED
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
3001aff8: e1a04000 mov r4, r0 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3001affc: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 3001b000: e58d301c str r3, [sp, #28] <== NOT EXECUTED
tail->previous = head;
3001b004: e58d6020 str r6, [sp, #32] <== NOT EXECUTED 3001b008: e28db010 add fp, sp, #16 <== NOT EXECUTED 3001b00c: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3001b010: e58d2008 str r2, [sp, #8] <== 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;
3001b014: e1a07005 mov r7, r5 <== 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;
3001b018: e28d300c add r3, sp, #12 <== NOT EXECUTED 3001b01c: e5843078 str r3, [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;
3001b020: e5983000 ldr r3, [r8] <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
3001b024: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
3001b028: e1a00007 mov r0, r7 <== NOT EXECUTED 3001b02c: e0611003 rsb r1, r1, r3 <== NOT EXECUTED 3001b030: e1a02006 mov r2, r6 <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
3001b034: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
3001b038: eb00119f bl 3001f6bc <_Watchdog_Adjust_to_chain> <== NOT EXECUTED
3001b03c: e8990003 ldm r9, {r0, r1} <== NOT EXECUTED
3001b040: e59f2178 ldr r2, [pc, #376] ; 3001b1c0 <_Timer_server_Body+0x214><== NOT EXECUTED
3001b044: e3a03000 mov r3, #0 <== NOT EXECUTED
3001b048: eb00512f bl 3002f50c <__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;
3001b04c: e5942074 ldr r2, [r4, #116] ; 0x74 <== NOT EXECUTED 3001b050: e1a05000 mov r5, 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 ) {
3001b054: e1500002 cmp r0, r2 <== NOT EXECUTED 3001b058: 8a000022 bhi 3001b0e8 <_Timer_server_Body+0x13c> <== NOT EXECUTED
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
3001b05c: 3a000018 bcc 3001b0c4 <_Timer_server_Body+0x118> <== NOT EXECUTED
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
3001b060: e5845074 str r5, [r4, #116] ; 0x74 <== NOT EXECUTED
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
3001b064: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 3001b068: eb0002e5 bl 3001bc04 <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
3001b06c: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3001b070: 0a00000b beq 3001b0a4 <_Timer_server_Body+0xf8> <== NOT EXECUTED
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001b074: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED 3001b078: e3530001 cmp r3, #1 <== NOT EXECUTED 3001b07c: 0a000015 beq 3001b0d8 <_Timer_server_Body+0x12c> <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
3001b080: e3530003 cmp r3, #3 <== NOT EXECUTED 3001b084: 1afffff6 bne 3001b064 <_Timer_server_Body+0xb8> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
3001b088: e2811010 add r1, r1, #16 <== NOT EXECUTED 3001b08c: e1a0000a mov r0, sl <== NOT EXECUTED 3001b090: eb0011b2 bl 3001f760 <_Watchdog_Insert> <== NOT EXECUTED
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
3001b094: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 3001b098: eb0002d9 bl 3001bc04 <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
3001b09c: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3001b0a0: 1afffff3 bne 3001b074 <_Timer_server_Body+0xc8> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001b0a4: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3001b0a8: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3001b0ac: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
3001b0b0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3001b0b4: e153000b cmp r3, fp <== NOT EXECUTED 3001b0b8: 0a00000f beq 3001b0fc <_Timer_server_Body+0x150> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001b0bc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3001b0c0: eaffffd6 b 3001b020 <_Timer_server_Body+0x74> <== 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 );
3001b0c4: e1a0000a mov r0, sl <== NOT EXECUTED 3001b0c8: e3a01001 mov r1, #1 <== NOT EXECUTED 3001b0cc: e0652002 rsb r2, r5, r2 <== NOT EXECUTED 3001b0d0: eb00114b bl 3001f604 <_Watchdog_Adjust> <== NOT EXECUTED 3001b0d4: eaffffe1 b 3001b060 <_Timer_server_Body+0xb4> <== 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 );
3001b0d8: e1a00007 mov r0, r7 <== NOT EXECUTED 3001b0dc: e2811010 add r1, r1, #16 <== NOT EXECUTED 3001b0e0: eb00119e bl 3001f760 <_Watchdog_Insert> <== NOT EXECUTED 3001b0e4: eaffffde b 3001b064 <_Timer_server_Body+0xb8> <== 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 );
3001b0e8: e0621005 rsb r1, r2, r5 <== NOT EXECUTED 3001b0ec: e1a0000a mov r0, sl <== NOT EXECUTED 3001b0f0: e1a02006 mov r2, r6 <== NOT EXECUTED 3001b0f4: eb001170 bl 3001f6bc <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 3001b0f8: eaffffd8 b 3001b060 <_Timer_server_Body+0xb4> <== NOT EXECUTED
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
3001b0fc: e5841078 str r1, [r4, #120] ; 0x78 <== NOT EXECUTED 3001b100: e129f002 msr CPSR_fc, r2 <== 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 ) ) {
3001b104: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3001b108: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3001b10c: e1530001 cmp r3, r1 <== NOT EXECUTED 3001b110: 1a00000a bne 3001b140 <_Timer_server_Body+0x194> <== NOT EXECUTED 3001b114: ea000012 b 3001b164 <_Timer_server_Body+0x1b8> <== 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;
3001b118: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
3001b11c: e5826004 str r6, [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;
3001b120: e58d2018 str r2, [sp, #24] <== 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;
3001b124: e3a02000 mov r2, #0 <== NOT EXECUTED 3001b128: e5832008 str r2, [r3, #8] <== NOT EXECUTED 3001b12c: e129f001 msr CPSR_fc, r1 <== 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 );
3001b130: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3001b134: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 3001b138: e1a0e00f mov lr, pc <== NOT EXECUTED 3001b13c: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001b140: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001b144: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001b148: 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;
3001b14c: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
3001b150: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3001b154: e1530002 cmp r3, r2 <== NOT EXECUTED 3001b158: 1affffee bne 3001b118 <_Timer_server_Body+0x16c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001b15c: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 3001b160: eaffffac b 3001b018 <_Timer_server_Body+0x6c> <== 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;
3001b164: e59f1058 ldr r1, [pc, #88] ; 3001b1c4 <_Timer_server_Body+0x218><== NOT EXECUTED
}
} else {
ts->active = false;
3001b168: e3a03000 mov r3, #0 <== NOT EXECUTED 3001b16c: e5c4307c strb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3001b170: e5913000 ldr r3, [r1] <== NOT EXECUTED
++level;
3001b174: e2833001 add r3, r3, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3001b178: e5813000 str r3, [r1] <== NOT EXECUTED
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
3001b17c: e3a01008 mov r1, #8 <== NOT EXECUTED 3001b180: e5940000 ldr r0, [r4] <== NOT EXECUTED 3001b184: eb001039 bl 3001f270 <_Thread_Set_state> <== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
3001b188: e1a00004 mov r0, r4 <== NOT EXECUTED 3001b18c: ebffff5a bl 3001aefc <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
3001b190: e1a00004 mov r0, r4 <== NOT EXECUTED 3001b194: ebffff6e bl 3001af54 <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED
_Thread_Enable_dispatch();
3001b198: eb000dea bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
ts->active = true;
3001b19c: e3a03001 mov r3, #1 <== NOT EXECUTED 3001b1a0: 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 );
3001b1a4: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3001b1a8: eb0011d9 bl 3001f914 <_Watchdog_Remove> <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
3001b1ac: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3001b1b0: eb0011d7 bl 3001f914 <_Watchdog_Remove> <== NOT EXECUTED 3001b1b4: eaffff97 b 3001b018 <_Timer_server_Body+0x6c> <== NOT EXECUTED
3001aefc <_Timer_server_Reset_interval_system_watchdog>:
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
3001aefc: 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 );
3001af00: e2805008 add r5, r0, #8 <== NOT EXECUTED
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
3001af04: 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 );
3001af08: e1a00005 mov r0, r5 <== NOT EXECUTED 3001af0c: eb001280 bl 3001f914 <_Watchdog_Remove> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001af10: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001af14: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001af18: 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;
3001af1c: 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 );
3001af20: e2842034 add r2, r4, #52 ; 0x34 <== NOT EXECUTED
ISR_Level level;
_Timer_server_Stop_interval_system_watchdog( ts );
_ISR_Disable( level );
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
3001af24: e1530002 cmp r3, r2 <== NOT EXECUTED 3001af28: 0a000006 beq 3001af48 <_Timer_server_Reset_interval_system_watchdog+0x4c><== NOT EXECUTED
Watchdog_Interval delta_interval =
3001af2c: 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 (
3001af30: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3001af34: e59f0014 ldr r0, [pc, #20] ; 3001af50 <_Timer_server_Reset_interval_system_watchdog+0x54><== NOT EXECUTED 3001af38: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001af3c: e5843014 str r3, [r4, #20] <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
3001af40: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3001af44: ea001205 b 3001f760 <_Watchdog_Insert> <== NOT EXECUTED
3001af48: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
3001af4c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001af54 <_Timer_server_Reset_tod_system_watchdog>:
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
3001af54: 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 );
3001af58: e2805040 add r5, r0, #64 ; 0x40 <== NOT EXECUTED
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
3001af5c: 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 );
3001af60: e1a00005 mov r0, r5 <== NOT EXECUTED 3001af64: eb00126a bl 3001f914 <_Watchdog_Remove> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001af68: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001af6c: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001af70: 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;
3001af74: 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 );
3001af78: e284206c add r2, r4, #108 ; 0x6c <== NOT EXECUTED
ISR_Level level;
_Timer_server_Stop_tod_system_watchdog( ts );
_ISR_Disable( level );
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001af7c: e1530002 cmp r3, r2 <== NOT EXECUTED 3001af80: 0a000006 beq 3001afa0 <_Timer_server_Reset_tod_system_watchdog+0x4c><== NOT EXECUTED
Watchdog_Interval delta_interval =
3001af84: 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 (
3001af88: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001af8c: e59f0014 ldr r0, [pc, #20] ; 3001afa8 <_Timer_server_Reset_tod_system_watchdog+0x54><== NOT EXECUTED 3001af90: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001af94: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
3001af98: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001af9c: ea0011ef b 3001f760 <_Watchdog_Insert> <== NOT EXECUTED
3001afa0: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
3001afa4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001b1c8 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
3001b1c8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
3001b1cc: e5905078 ldr r5, [r0, #120] ; 0x78 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
3001b1d0: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
3001b1d4: e3550000 cmp r5, #0 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
3001b1d8: e1a06001 mov r6, r1 <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
3001b1dc: 0a000002 beq 3001b1ec <_Timer_server_Schedule_operation_method+0x24><== 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 );
3001b1e0: e5900078 ldr r0, [r0, #120] ; 0x78 <== NOT EXECUTED
} }
3001b1e4: 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 );
3001b1e8: ea00027a b 3001bbd8 <_Chain_Append> <== 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;
3001b1ec: e59f3110 ldr r3, [pc, #272] ; 3001b304 <_Timer_server_Schedule_operation_method+0x13c><== NOT EXECUTED 3001b1f0: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3001b1f4: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3001b1f8: 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 ) {
3001b1fc: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED 3001b200: e3530001 cmp r3, #1 <== NOT EXECUTED 3001b204: 0a000024 beq 3001b29c <_Timer_server_Schedule_operation_method+0xd4><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
if ( !ts->active ) {
_Timer_server_Reset_interval_system_watchdog( ts );
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
3001b208: e3530003 cmp r3, #3 <== NOT EXECUTED 3001b20c: 0a000001 beq 3001b218 <_Timer_server_Schedule_operation_method+0x50><== 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 );
}
}
3001b210: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
3001b214: ea000dcb b 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001b218: e10f7000 mrs r7, CPSR <== NOT EXECUTED
3001b21c: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED
3001b220: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3001b224: e59f10dc ldr r1, [pc, #220] ; 3001b308 <_Timer_server_Schedule_operation_method+0x140><== NOT EXECUTED
3001b228: e59f20dc ldr r2, [pc, #220] ; 3001b30c <_Timer_server_Schedule_operation_method+0x144><== NOT EXECUTED
3001b22c: e3a03000 mov r3, #0 <== NOT EXECUTED
3001b230: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3001b234: eb0050b4 bl 3002f50c <__divdi3> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3001b238: 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 );
3001b23c: e284206c add r2, r4, #108 ; 0x6c <== NOT EXECUTED
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001b240: e1530002 cmp r3, r2 <== 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;
3001b244: e5942074 ldr r2, [r4, #116] ; 0x74 <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001b248: 0a000008 beq 3001b270 <_Timer_server_Schedule_operation_method+0xa8><== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
3001b24c: e5931010 ldr r1, [r3, #16] <== NOT EXECUTED
if ( snapshot > last_snapshot ) {
3001b250: e1500002 cmp r0, r2 <== NOT EXECUTED
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
3001b254: 90812002 addls r2, r1, r2 <== NOT EXECUTED
delta_interval += delta;
3001b258: 90605002 rsbls r5, r0, r2 <== 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 ) {
3001b25c: 9a000002 bls 3001b26c <_Timer_server_Schedule_operation_method+0xa4><== NOT EXECUTED
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
3001b260: e0622000 rsb r2, r2, r0 <== NOT EXECUTED
if (delta_interval > delta) {
3001b264: e1510002 cmp r1, r2 <== NOT EXECUTED
delta_interval -= delta;
3001b268: 80625001 rsbhi r5, r2, r1 <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
3001b26c: e5835010 str r5, [r3, #16] <== NOT EXECUTED
}
ts->TOD_watchdogs.last_snapshot = snapshot;
3001b270: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001b274: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
3001b278: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED 3001b27c: e2861010 add r1, r6, #16 <== NOT EXECUTED 3001b280: eb001136 bl 3001f760 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
3001b284: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3001b288: e3530000 cmp r3, #0 <== NOT EXECUTED 3001b28c: 1affffdf bne 3001b210 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
3001b290: e1a00004 mov r0, r4 <== NOT EXECUTED 3001b294: ebffff2e bl 3001af54 <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED 3001b298: eaffffdc b 3001b210 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001b29c: e10fc000 mrs ip, CPSR <== NOT EXECUTED 3001b2a0: e38c3080 orr r3, ip, #128 ; 0x80 <== NOT EXECUTED 3001b2a4: 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;
3001b2a8: e5903030 ldr r3, [r0, #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 );
3001b2ac: e2802034 add r2, r0, #52 ; 0x34 <== NOT EXECUTED
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
3001b2b0: e1530002 cmp r3, r2 <== NOT EXECUTED
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
3001b2b4: e59f2054 ldr r2, [pc, #84] ; 3001b310 <_Timer_server_Schedule_operation_method+0x148><== NOT EXECUTED 3001b2b8: e5922000 ldr r2, [r2] <== NOT EXECUTED
last_snapshot = ts->Interval_watchdogs.last_snapshot;
3001b2bc: e590103c ldr r1, [r0, #60] ; 0x3c <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
3001b2c0: 0a000004 beq 3001b2d8 <_Timer_server_Schedule_operation_method+0x110><== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
3001b2c4: e5930010 ldr r0, [r3, #16] <== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
3001b2c8: e0611002 rsb r1, r1, r2 <== NOT EXECUTED
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
3001b2cc: e1510000 cmp r1, r0 <== NOT EXECUTED
delta_interval -= delta;
3001b2d0: 30615000 rsbcc r5, r1, r0 <== NOT EXECUTED
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
3001b2d4: e5835010 str r5, [r3, #16] <== NOT EXECUTED
}
ts->Interval_watchdogs.last_snapshot = snapshot;
3001b2d8: e584203c str r2, [r4, #60] ; 0x3c <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001b2dc: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
3001b2e0: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 3001b2e4: e2861010 add r1, r6, #16 <== NOT EXECUTED 3001b2e8: eb00111c bl 3001f760 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
3001b2ec: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3001b2f0: e3530000 cmp r3, #0 <== NOT EXECUTED 3001b2f4: 1affffc5 bne 3001b210 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
3001b2f8: e1a00004 mov r0, r4 <== NOT EXECUTED 3001b2fc: ebfffefe bl 3001aefc <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED 3001b300: eaffffc2 b 3001b210 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
3000f554 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
3000f554: e1a03000 mov r3, r0 <== NOT EXECUTED
3000f558: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000f55c: e5904004 ldr r4, [r0, #4] <== NOT EXECUTED
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000f560: e59fc044 ldr ip, [pc, #68] ; 3000f5ac <_Timespec_Add_to+0x58><== NOT EXECUTED
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
uint32_t seconds = add->tv_sec;
3000f564: e8910005 ldm r1, {r0, r2} <== NOT EXECUTED
/* Add the basics */
time->tv_sec += add->tv_sec;
3000f568: e5931000 ldr r1, [r3] <== NOT EXECUTED
time->tv_nsec += add->tv_nsec;
3000f56c: e0844002 add r4, r4, r2 <== NOT EXECUTED
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000f570: e0811000 add r1, r1, r0 <== NOT EXECUTED
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000f574: e154000c cmp r4, ip <== NOT EXECUTED 3000f578: e1a02004 mov r2, r4 <== NOT EXECUTED
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000f57c: e8830012 stm r3, {r1, r4} <== NOT EXECUTED
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000f580: 9a000007 bls 3000f5a4 <_Timespec_Add_to+0x50> <== NOT EXECUTED
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000f584: e2822331 add r2, r2, #-1006632960 ; 0xc4000000 <== NOT EXECUTED 3000f588: e2822865 add r2, r2, #6619136 ; 0x650000 <== NOT EXECUTED 3000f58c: e2822c36 add r2, r2, #13824 ; 0x3600 <== 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 ) {
3000f590: e152000c cmp r2, ip <== NOT EXECUTED
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
time->tv_sec++;
3000f594: e2811001 add r1, r1, #1 <== NOT EXECUTED
seconds++;
3000f598: e2800001 add r0, r0, #1 <== 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 ) {
3000f59c: 8afffff8 bhi 3000f584 <_Timespec_Add_to+0x30> <== NOT EXECUTED
3000f5a0: e8830006 stm r3, {r1, r2} <== NOT EXECUTED
time->tv_sec++;
seconds++;
}
return seconds;
}
3000f5a4: e8bd0010 pop {r4} <== NOT EXECUTED
3000f5a8: e12fff1e bx lr <== NOT EXECUTED
3000d92c <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000d92c: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr}
* 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;
3000d930: e5916004 ldr r6, [r1, #4]
* For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000d934: e591c000 ldr ip, [r1]
right += rhs->tv_nsec;
3000d938: e59f108c ldr r1, [pc, #140] ; 3000d9cc <_Timespec_Divide+0xa0> 3000d93c: e1a04006 mov r4, r6 3000d940: e1a05fc6 asr r5, r6, #31 3000d944: e0e54c91 smlal r4, r5, r1, ip
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000d948: e1a07003 mov r7, r3
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 ) {
3000d94c: e194c005 orrs ip, r4, r5
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000d950: e5903000 ldr r3, [r0]
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000d954: e1a06002 mov r6, r2
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
*ival_percentage = 0;
3000d958: 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;
3000d95c: e5902004 ldr r2, [r0, #4]
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
*ival_percentage = 0;
3000d960: 05863000 streq r3, [r6]
*fval_percentage = 0;
3000d964: 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 ) {
3000d968: 08bd83f0 popeq {r4, r5, r6, r7, r8, r9, 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;
3000d96c: e1a08002 mov r8, r2 <== NOT EXECUTED 3000d970: e1a09fc2 asr r9, r2, #31 <== NOT EXECUTED 3000d974: e0e98391 smlal r8, r9, r1, r3 <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
3000d978: e59f1050 ldr r1, [pc, #80] ; 3000d9d0 <_Timespec_Divide+0xa4><== NOT EXECUTED 3000d97c: e1a02004 mov r2, r4 <== NOT EXECUTED 3000d980: e1a03005 mov r3, r5 <== NOT EXECUTED 3000d984: e0854198 umull r4, r5, r8, r1 <== NOT EXECUTED 3000d988: e0255991 mla r5, r1, r9, r5 <== NOT EXECUTED 3000d98c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d990: e1a01005 mov r1, r5 <== NOT EXECUTED 3000d994: eb003c9e bl 3001cc14 <__udivdi3> <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000d998: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000d99c: 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;
3000d9a0: e1a04000 mov r4, r0 <== NOT EXECUTED 3000d9a4: e1a05001 mov r5, r1 <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000d9a8: eb003c99 bl 3001cc14 <__udivdi3> <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000d9ac: e1a01005 mov r1, r5 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
3000d9b0: e5860000 str r0, [r6] <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000d9b4: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000d9b8: e3a03000 mov r3, #0 <== NOT EXECUTED
3000d9bc: e1a00004 mov r0, r4 <== NOT EXECUTED
3000d9c0: eb003db7 bl 3001d0a4 <__umoddi3> <== NOT EXECUTED
3000d9c4: e5870000 str r0, [r7] <== NOT EXECUTED
3000d9c8: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
3002adf8 <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3002adf8: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr} <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
3002adfc: e8900009 ldm r0, {r0, r3} <== NOT EXECUTED
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3002ae00: 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;
3002ae04: e1a06003 mov r6, r3 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3002ae08: e1a02001 mov r2, 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;
3002ae0c: e1a07fc3 asr r7, r3, #31 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3002ae10: e59f104c ldr r1, [pc, #76] ; 3002ae64 <_Timespec_Divide_by_integer+0x6c><== NOT EXECUTED 3002ae14: e1a08006 mov r8, r6 <== NOT EXECUTED 3002ae18: e1a09007 mov r9, r7 <== NOT EXECUTED 3002ae1c: e0e98091 smlal r8, r9, r1, r0 <== NOT EXECUTED 3002ae20: e3a03000 mov r3, #0 <== NOT EXECUTED 3002ae24: e1a00008 mov r0, r8 <== NOT EXECUTED 3002ae28: e1a01009 mov r1, r9 <== NOT EXECUTED 3002ae2c: eb00a94d bl 30055368 <__udivdi3> <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3002ae30: e59f202c ldr r2, [pc, #44] ; 3002ae64 <_Timespec_Divide_by_integer+0x6c><== NOT EXECUTED 3002ae34: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3002ae38: e1a05000 mov r5, r0 <== NOT EXECUTED 3002ae3c: e1a06001 mov r6, r1 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3002ae40: eb00a948 bl 30055368 <__udivdi3> <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3002ae44: e59f2018 ldr r2, [pc, #24] ; 3002ae64 <_Timespec_Divide_by_integer+0x6c><== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3002ae48: e5840000 str r0, [r4] <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3002ae4c: e3a03000 mov r3, #0 <== NOT EXECUTED 3002ae50: e1a01006 mov r1, r6 <== NOT EXECUTED 3002ae54: e1a00005 mov r0, r5 <== NOT EXECUTED 3002ae58: eb00aa66 bl 300557f8 <__umoddi3> <== NOT EXECUTED 3002ae5c: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
3002ae60: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
3002d14c <_Timespec_From_ticks>:
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
3002d14c: e59f3034 ldr r3, [pc, #52] ; 3002d188 <_Timespec_From_ticks+0x3c><== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
3002d150: e59f2034 ldr r2, [pc, #52] ; 3002d18c <_Timespec_From_ticks+0x40><== NOT EXECUTED
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
3002d154: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 3002d158: e0000093 mul r0, r3, r0 <== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
3002d15c: e0823290 umull r3, r2, r0, r2 <== NOT EXECUTED 3002d160: e1a02922 lsr r2, r2, #18 <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
3002d164: e0623282 rsb r3, r2, r2, lsl #5 <== NOT EXECUTED
3002d168: e0633303 rsb r3, r3, r3, lsl #6 <== NOT EXECUTED
3002d16c: e0823183 add r3, r2, r3, lsl #3 <== NOT EXECUTED
3002d170: e0403303 sub r3, r0, r3, lsl #6 <== NOT EXECUTED
3002d174: e0630283 rsb r0, r3, r3, lsl #5 <== NOT EXECUTED
3002d178: e0833100 add r3, r3, r0, lsl #2 <== NOT EXECUTED
3002d17c: e1a03183 lsl r3, r3, #3 <== NOT EXECUTED
3002d180: e881000c stm r1, {r2, r3} <== NOT EXECUTED
TOD_NANOSECONDS_PER_MICROSECOND;
}
3002d184: e12fff1e bx lr <== NOT EXECUTED
3002d190 <_Timespec_Is_valid>:
bool _Timespec_Is_valid(
const struct timespec *time
)
{
if ( !time )
3002d190: e3500000 cmp r0, #0 3002d194: 012fff1e bxeq lr
return false;
if ( time->tv_sec < 0 )
3002d198: e5903000 ldr r3, [r0] 3002d19c: e3530000 cmp r3, #0
return false;
3002d1a0: b3a00000 movlt r0, #0
)
{
if ( !time )
return false;
if ( time->tv_sec < 0 )
3002d1a4: b12fff1e bxlt lr
return false;
if ( time->tv_nsec < 0 )
3002d1a8: e5903004 ldr r3, [r0, #4] 3002d1ac: e3530000 cmp r3, #0
3002d1b0: ba000004 blt 3002d1c8 <_Timespec_Is_valid+0x38>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
3002d1b4: e59f0014 ldr r0, [pc, #20] ; 3002d1d0 <_Timespec_Is_valid+0x40> 3002d1b8: e1530000 cmp r3, r0 3002d1bc: 83a00000 movhi r0, #0 3002d1c0: 93a00001 movls r0, #1 3002d1c4: e12fff1e bx lr
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
3002d1c8: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
3002d1cc: e12fff1e bx lr <== NOT EXECUTED
300110c8 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
300110c8: e5902000 ldr r2, [r0] 300110cc: e5913000 ldr r3, [r1] 300110d0: e1520003 cmp r2, r3
return true;
300110d4: b3a00001 movlt r0, #1
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
300110d8: b12fff1e bxlt lr
return true;
if ( lhs->tv_sec > rhs->tv_sec )
300110dc: ca000005 bgt 300110f8 <_Timespec_Less_than+0x30>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Less_than(
300110e0: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED 300110e4: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 300110e8: e1500003 cmp r0, r3 <== NOT EXECUTED 300110ec: a3a00000 movge r0, #0 <== NOT EXECUTED 300110f0: b3a00001 movlt r0, #1 <== NOT EXECUTED 300110f4: e12fff1e bx lr <== NOT EXECUTED
{
if ( lhs->tv_sec < rhs->tv_sec )
return true;
if ( lhs->tv_sec > rhs->tv_sec )
return false;
300110f8: e3a00000 mov r0, #0
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
return true;
return false;
}
300110fc: e12fff1e bx lr
3000e9c0 <_Timespec_Subtract>:
const struct timespec *end,
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
3000e9c0: e591c004 ldr ip, [r1, #4] 3000e9c4: e5903004 ldr r3, [r0, #4]
void _Timespec_Subtract(
const struct timespec *start,
const struct timespec *end,
struct timespec *result
)
{
3000e9c8: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
if (end->tv_nsec < start->tv_nsec) {
3000e9cc: e15c0003 cmp ip, r3
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000e9d0: e5914000 ldr r4, [r1]
const struct timespec *end,
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
3000e9d4: ba000005 blt 3000e9f0 <_Timespec_Subtract+0x30>
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
3000e9d8: e5901000 ldr r1, [r0]
result->tv_nsec = end->tv_nsec - start->tv_nsec;
3000e9dc: e063300c rsb r3, r3, ip
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
3000e9e0: e0611004 rsb r1, r1, r4
result->tv_nsec = end->tv_nsec - start->tv_nsec;
3000e9e4: e882000a stm r2, {r1, r3}
} }
3000e9e8: e8bd0010 pop {r4}
3000e9ec: e12fff1e bx lr
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000e9f0: e5900000 ldr r0, [r0] <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000e9f4: e59f1014 ldr r1, [pc, #20] ; 3000ea10 <_Timespec_Subtract+0x50><== NOT EXECUTED
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000e9f8: e0600004 rsb r0, r0, r4 <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000e9fc: e08c1001 add r1, ip, r1 <== NOT EXECUTED
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000ea00: e2400001 sub r0, r0, #1 <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000ea04: e0633001 rsb r3, r3, r1 <== NOT EXECUTED
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
3000ea08: e8820009 stm r2, {r0, r3} <== NOT EXECUTED
3000ea0c: eafffff5 b 3000e9e8 <_Timespec_Subtract+0x28> <== NOT EXECUTED
3000f2cc <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
3000f2cc: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
3000f2d0: e89100c0 ldm r1, {r6, r7} <== NOT EXECUTED
3000f2d4: e1961007 orrs r1, r6, r7 <== NOT EXECUTED
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
3000f2d8: e1a05003 mov r5, r3 <== NOT EXECUTED
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
*_ival_percentage = 0;
3000f2dc: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000f2e0: 05823000 streq r3, [r2] <== NOT EXECUTED
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
3000f2e4: e1a04002 mov r4, r2 <== NOT EXECUTED
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
*_ival_percentage = 0;
*_fval_percentage = 0;
3000f2e8: 05853000 streq r3, [r5] <== NOT EXECUTED
uint32_t *_fval_percentage
)
{
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
3000f2ec: 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;
3000f2f0: e590c000 ldr ip, [r0] <== NOT EXECUTED 3000f2f4: e59f3048 ldr r3, [pc, #72] ; 3000f344 <_Timestamp64_Divide+0x78><== NOT EXECUTED 3000f2f8: e5902004 ldr r2, [r0, #4] <== NOT EXECUTED 3000f2fc: e081039c umull r0, r1, ip, r3 <== NOT EXECUTED 3000f300: e0211293 mla r1, r3, r2, r1 <== NOT EXECUTED 3000f304: e1a02006 mov r2, r6 <== NOT EXECUTED 3000f308: e1a03007 mov r3, r7 <== NOT EXECUTED 3000f30c: eb003c58 bl 3001e474 <__divdi3> <== NOT EXECUTED
*_ival_percentage = answer / 1000;
3000f310: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000f314: 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;
3000f318: e1a06000 mov r6, r0 <== NOT EXECUTED 3000f31c: e1a07001 mov r7, r1 <== NOT EXECUTED
*_ival_percentage = answer / 1000;
3000f320: eb003c53 bl 3001e474 <__divdi3> <== NOT EXECUTED
*_fval_percentage = answer % 1000;
3000f324: e1a01007 mov r1, r7 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
3000f328: e5840000 str r0, [r4] <== NOT EXECUTED
*_fval_percentage = answer % 1000;
3000f32c: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000f330: e3a03000 mov r3, #0 <== NOT EXECUTED
3000f334: e1a00006 mov r0, r6 <== NOT EXECUTED
3000f338: eb003d88 bl 3001e960 <__moddi3> <== NOT EXECUTED
3000f33c: e5850000 str r0, [r5] <== NOT EXECUTED
3000f340: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
300138e8 <_User_extensions_Remove_set>:
#include <rtems/score/userextimpl.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
300138e8: e92d4010 push {r4, lr}
300138ec: e1a04000 mov r4, r0
_Chain_Extract( &the_extension->Node );
300138f0: eb0014ee bl 30018cb0 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
300138f4: e5943024 ldr r3, [r4, #36] ; 0x24
300138f8: e3530000 cmp r3, #0
300138fc: 08bd8010 popeq {r4, pc}
_Chain_Extract( &the_extension->Switch.Node );
30013900: e2840008 add r0, r4, #8 <== NOT EXECUTED
}
30013904: 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 );
30013908: ea0014e8 b 30018cb0 <_Chain_Extract> <== NOT EXECUTED
3000f598 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
3000f598: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000f59c: e1a04000 mov r4, r0
3000f5a0: e1a05002 mov r5, r2
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000f5a4: e10f2000 mrs r2, CPSR 3000f5a8: e3823080 orr r3, r2, #128 ; 0x80 3000f5ac: 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;
3000f5b0: e1a07000 mov r7, r0 3000f5b4: e4973004 ldr r3, [r7], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
3000f5b8: e1530007 cmp r3, r7
3000f5bc: 0a000017 beq 3000f620 <_Watchdog_Adjust+0x88>
switch ( direction ) {
3000f5c0: e3510000 cmp r1, #0 <== NOT EXECUTED 3000f5c4: 1a000017 bne 3000f628 <_Watchdog_Adjust+0x90> <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000f5c8: e3550000 cmp r5, #0 <== NOT EXECUTED 3000f5cc: 0a000013 beq 3000f620 <_Watchdog_Adjust+0x88> <== NOT EXECUTED
if ( units < _Watchdog_First( header )->delta_interval ) {
3000f5d0: e5936010 ldr r6, [r3, #16] <== NOT EXECUTED 3000f5d4: e1550006 cmp r5, r6 <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000f5d8: 23a08001 movcs r8, #1 <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
3000f5dc: 2a000005 bcs 3000f5f8 <_Watchdog_Adjust+0x60> <== NOT EXECUTED 3000f5e0: ea000017 b 3000f644 <_Watchdog_Adjust+0xac> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000f5e4: e0555006 subs r5, r5, r6 <== NOT EXECUTED 3000f5e8: 0a00000c beq 3000f620 <_Watchdog_Adjust+0x88> <== NOT EXECUTED
if ( units < _Watchdog_First( header )->delta_interval ) {
3000f5ec: e5936010 ldr r6, [r3, #16] <== NOT EXECUTED 3000f5f0: e1560005 cmp r6, r5 <== NOT EXECUTED 3000f5f4: 8a000012 bhi 3000f644 <_Watchdog_Adjust+0xac> <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000f5f8: e5838010 str r8, [r3, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f5fc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Tickle( header );
3000f600: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f604: eb0000a9 bl 3000f8b0 <_Watchdog_Tickle> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000f608: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000f60c: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000f610: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3000f614: e5943000 ldr r3, [r4] <== NOT EXECUTED
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000f618: e1570003 cmp r7, r3 <== NOT EXECUTED 3000f61c: 1afffff0 bne 3000f5e4 <_Watchdog_Adjust+0x4c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f620: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
3000f624: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000f628: e3510001 cmp r1, #1 <== NOT EXECUTED 3000f62c: 1afffffb bne 3000f620 <_Watchdog_Adjust+0x88> <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
3000f630: e5931010 ldr r1, [r3, #16] <== NOT EXECUTED 3000f634: e0815005 add r5, r1, r5 <== NOT EXECUTED 3000f638: e5835010 str r5, [r3, #16] <== NOT EXECUTED 3000f63c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
}
_ISR_Enable( level );
}
3000f640: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
3000f644: e0655006 rsb r5, r5, r6 <== NOT EXECUTED 3000f648: e5835010 str r5, [r3, #16] <== NOT EXECUTED
break;
3000f64c: eafffff3 b 3000f620 <_Watchdog_Adjust+0x88> <== NOT EXECUTED
3001f6bc <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
3001f6bc: e92d05f0 push {r4, r5, r6, r7, r8, sl} <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001f6c0: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3001f6c4: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3001f6c8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
_ISR_Disable( level );
3001f6cc: e1a06000 mov r6, r0 <== NOT EXECUTED 3001f6d0: e4963004 ldr r3, [r6], #4 <== 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;
3001f6d4: e3a0a000 mov sl, #0 <== NOT EXECUTED 3001f6d8: e2828004 add r8, r2, #4 <== NOT EXECUTED
Watchdog_Control *first;
_ISR_Disable( level );
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
3001f6dc: e1560003 cmp r6, r3 <== NOT EXECUTED 3001f6e0: 0a000018 beq 3001f748 <_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 ) {
3001f6e4: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001f6e8: e151000c cmp r1, ip <== NOT EXECUTED 3001f6ec: 3a000018 bcc 3001f754 <_Watchdog_Adjust_to_chain+0x98> <== 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;
3001f6f0: e06c1001 rsb r1, ip, r1 <== NOT EXECUTED
first->delta_interval = 0;
3001f6f4: e583a010 str sl, [r3, #16] <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3001f6f8: e5935000 ldr r5, [r3] <== NOT EXECUTED
previous = the_node->previous;
3001f6fc: e5934004 ldr r4, [r3, #4] <== NOT EXECUTED
next->previous = previous;
3001f700: e5854004 str r4, [r5, #4] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3001f704: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
previous->next = next;
3001f708: e5845000 str r5, [r4] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3001f70c: e5838000 str r8, [r3] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
3001f710: 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;
3001f714: e5823008 str r3, [r2, #8] <== NOT EXECUTED
old_last->next = the_node; the_node->previous = old_last;
3001f718: 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 (
3001f71c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001f720: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED 3001f724: 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;
3001f728: 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 ) )
3001f72c: e1560003 cmp r6, r3 <== NOT EXECUTED 3001f730: 0affffe9 beq 3001f6dc <_Watchdog_Adjust_to_chain+0x20> <== NOT EXECUTED
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
3001f734: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001f738: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001f73c: 0affffed beq 3001f6f8 <_Watchdog_Adjust_to_chain+0x3c> <== NOT EXECUTED
Watchdog_Control *first;
_ISR_Disable( level );
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
3001f740: e1560003 cmp r6, r3 <== NOT EXECUTED 3001f744: 1affffe6 bne 3001f6e4 <_Watchdog_Adjust_to_chain+0x28> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001f748: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001f74c: e8bd05f0 pop {r4, r5, r6, r7, r8, sl} <== NOT EXECUTED
3001f750: e12fff1e bx lr <== 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 ) {
first->delta_interval -= units;
3001f754: e061100c rsb r1, r1, ip <== NOT EXECUTED 3001f758: e5831010 str r1, [r3, #16] <== NOT EXECUTED
break;
3001f75c: eafffff9 b 3001f748 <_Watchdog_Adjust_to_chain+0x8c> <== NOT EXECUTED
3000dd7c <_Watchdog_Insert>:
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
3000dd7c: e59f3138 ldr r3, [pc, #312] ; 3000debc <_Watchdog_Insert+0x140>
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
3000dd80: e92d01f0 push {r4, r5, r6, r7, r8}
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
3000dd84: e5933000 ldr r3, [r3]
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000dd88: e10f5000 mrs r5, CPSR 3000dd8c: e3852080 orr r2, r5, #128 ; 0x80 3000dd90: e129f002 msr CPSR_fc, r2
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
3000dd94: e5912008 ldr r2, [r1, #8] 3000dd98: e3520000 cmp r2, #0
3000dd9c: 1a00003e bne 3000de9c <_Watchdog_Insert+0x120>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
3000dda0: e59f7118 ldr r7, [pc, #280] ; 3000dec0 <_Watchdog_Insert+0x144>
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
3000dda4: e3a0c001 mov ip, #1
_Watchdog_Sync_count++;
3000dda8: e5972000 ldr r2, [r7] 3000ddac: e59f6110 ldr r6, [pc, #272] ; 3000dec4 <_Watchdog_Insert+0x148> 3000ddb0: e2822001 add r2, r2, #1
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
3000ddb4: e581c008 str ip, [r1, #8]
_Watchdog_Sync_count++;
3000ddb8: e5872000 str r2, [r7]
restart:
delta_interval = the_watchdog->initial;
3000ddbc: e591200c ldr r2, [r1, #12]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000ddc0: e590c000 ldr ip, [r0]
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000ddc4: e3520000 cmp r2, #0
3000ddc8: 0a000023 beq 3000de5c <_Watchdog_Insert+0xe0>
3000ddcc: e59c4000 ldr r4, [ip] 3000ddd0: e3540000 cmp r4, #0
3000ddd4: 0a000020 beq 3000de5c <_Watchdog_Insert+0xe0>
break;
if ( delta_interval < after->delta_interval ) {
3000ddd8: e59c4010 ldr r4, [ip, #16] 3000dddc: e1520004 cmp r2, r4
3000dde0: 3a000030 bcc 3000dea8 <_Watchdog_Insert+0x12c>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000dde4: e10f8000 mrs r8, CPSR 3000dde8: e129f005 msr CPSR_fc, r5 3000ddec: e129f008 msr CPSR_fc, r8
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000ddf0: e5918008 ldr r8, [r1, #8] 3000ddf4: e3580001 cmp r8, #1
3000ddf8: 1a000023 bne 3000de8c <_Watchdog_Insert+0x110>
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000ddfc: e5968000 ldr r8, [r6] 3000de00: e1530008 cmp r3, r8
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
3000de04: 20642002 rsbcs r2, r4, r2
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000de08: 2a000010 bcs 3000de50 <_Watchdog_Insert+0xd4>
3000de0c: ea000028 b 3000deb4 <_Watchdog_Insert+0x138> <== NOT EXECUTED
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000de10: e59c4000 ldr r4, [ip] <== NOT EXECUTED 3000de14: e3540000 cmp r4, #0 <== NOT EXECUTED 3000de18: 0a00000f beq 3000de5c <_Watchdog_Insert+0xe0> <== NOT EXECUTED
break;
if ( delta_interval < after->delta_interval ) {
3000de1c: e59c4010 ldr r4, [ip, #16] <== NOT EXECUTED 3000de20: e1540002 cmp r4, r2 <== NOT EXECUTED 3000de24: 8a00001f bhi 3000dea8 <_Watchdog_Insert+0x12c> <== NOT EXECUTED
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
3000de28: e0642002 rsb r2, r4, r2 <== NOT EXECUTED 3000de2c: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000de30: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED 3000de34: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000de38: e5914008 ldr r4, [r1, #8] <== NOT EXECUTED 3000de3c: e3540001 cmp r4, #1 <== NOT EXECUTED 3000de40: 1a000011 bne 3000de8c <_Watchdog_Insert+0x110> <== NOT EXECUTED
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000de44: e5964000 ldr r4, [r6] <== NOT EXECUTED 3000de48: e1530004 cmp r3, r4 <== NOT EXECUTED 3000de4c: 3a000018 bcc 3000deb4 <_Watchdog_Insert+0x138> <== NOT EXECUTED
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000de50: e3520000 cmp r2, #0
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
3000de54: e59cc000 ldr ip, [ip]
3000de58: 1affffec bne 3000de10 <_Watchdog_Insert+0x94>
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
3000de5c: e59c0004 ldr r0, [ip, #4]
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
3000de60: e59f4060 ldr r4, [pc, #96] ; 3000dec8 <_Watchdog_Insert+0x14c>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000de64: e590c000 ldr ip, [r0] 3000de68: e5944000 ldr r4, [r4]
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
3000de6c: e3a08002 mov r8, #2 3000de70: e5818008 str r8, [r1, #8]
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
3000de74: e5812010 str r2, [r1, #16]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000de78: e5810004 str r0, [r1, #4]
before_node = after_node->next; after_node->next = the_node;
3000de7c: e5801000 str r1, [r0]
the_node->next = before_node; before_node->previous = the_node;
3000de80: e58c1004 str r1, [ip, #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;
3000de84: e581c000 str ip, [r1]
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
3000de88: e5814014 str r4, [r1, #20]
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
3000de8c: e5863000 str r3, [r6]
_Watchdog_Sync_count--;
3000de90: e5973000 ldr r3, [r7] 3000de94: e2433001 sub r3, r3, #1 3000de98: e5873000 str r3, [r7]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000de9c: e129f005 msr CPSR_fc, r5
_ISR_Enable( level ); }
3000dea0: e8bd01f0 pop {r4, r5, r6, r7, r8}
3000dea4: e12fff1e bx lr
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
break;
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
3000dea8: e0624004 rsb r4, r2, r4 <== NOT EXECUTED 3000deac: e58c4010 str r4, [ip, #16] <== NOT EXECUTED
break;
3000deb0: eaffffe9 b 3000de5c <_Watchdog_Insert+0xe0> <== NOT EXECUTED
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
3000deb4: e5863000 str r3, [r6] <== NOT EXECUTED
goto restart;
3000deb8: eaffffbf b 3000ddbc <_Watchdog_Insert+0x40> <== NOT EXECUTED
3000f07c <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000f07c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
printk(
3000f080: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000f084: 059f7044 ldreq r7, [pc, #68] ; 3000f0d0 <_Watchdog_Report+0x54><== NOT EXECUTED 3000f088: e591600c ldr r6, [r1, #12] <== NOT EXECUTED 3000f08c: e591501c ldr r5, [r1, #28] <== NOT EXECUTED 3000f090: e5914020 ldr r4, [r1, #32] <== NOT EXECUTED 3000f094: e591e024 ldr lr, [r1, #36] ; 0x24 <== NOT EXECUTED 3000f098: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000f09c: e24dd014 sub sp, sp, #20 <== NOT EXECUTED 3000f0a0: e1a0c001 mov ip, r1 <== NOT EXECUTED
printk(
3000f0a4: 01a02007 moveq r2, r7 <== NOT EXECUTED
3000f0a8: 159f2024 ldrne r2, [pc, #36] ; 3000f0d4 <_Watchdog_Report+0x58><== NOT EXECUTED
3000f0ac: e59f0024 ldr r0, [pc, #36] ; 3000f0d8 <_Watchdog_Report+0x5c><== NOT EXECUTED
3000f0b0: e1a01007 mov r1, r7 <== NOT EXECUTED
3000f0b4: e88d1040 stm sp, {r6, ip} <== NOT EXECUTED
3000f0b8: e58d5008 str r5, [sp, #8] <== NOT EXECUTED
3000f0bc: e58d400c str r4, [sp, #12] <== NOT EXECUTED
3000f0c0: e58de010 str lr, [sp, #16] <== NOT EXECUTED
3000f0c4: ebffe356 bl 30007e24 <printk> <== NOT EXECUTED
watch,
watch->routine,
watch->id,
watch->user_data
);
}
3000f0c8: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000f0cc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f004 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
3000f004: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000f008: e1a02001 mov r2, r1 <== NOT EXECUTED
3000f00c: e1a05000 mov r5, r0 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000f010: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000f014: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000f018: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
3000f01c: e59f004c ldr r0, [pc, #76] ; 3000f070 <_Watchdog_Report_chain+0x6c><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000f020: e1a04001 mov r4, r1 <== NOT EXECUTED 3000f024: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f028: ebffe37d bl 30007e24 <printk> <== NOT EXECUTED 3000f02c: e4947004 ldr r7, [r4], #4 <== NOT EXECUTED
if ( !_Chain_Is_empty( header ) ) {
3000f030: e1570004 cmp r7, r4 <== NOT EXECUTED 3000f034: 0a00000a beq 3000f064 <_Watchdog_Report_chain+0x60> <== NOT EXECUTED
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
3000f038: e1a01007 mov r1, r7 <== NOT EXECUTED 3000f03c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000f040: eb00000d bl 3000f07c <_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 )
3000f044: 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 ) ;
3000f048: e1570004 cmp r7, r4 <== NOT EXECUTED 3000f04c: 1afffff9 bne 3000f038 <_Watchdog_Report_chain+0x34> <== NOT EXECUTED
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
3000f050: e59f001c ldr r0, [pc, #28] ; 3000f074 <_Watchdog_Report_chain+0x70><== NOT EXECUTED 3000f054: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f058: ebffe371 bl 30007e24 <printk> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f05c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
3000f060: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
3000f064: e59f000c ldr r0, [pc, #12] ; 3000f078 <_Watchdog_Report_chain+0x74><== NOT EXECUTED 3000f068: ebffe36d bl 30007e24 <printk> <== NOT EXECUTED 3000f06c: eafffffa b 3000f05c <_Watchdog_Report_chain+0x58> <== NOT EXECUTED
3000dfdc <_Watchdog_Tickle>:
#include <rtems/score/watchdog.h>
void _Watchdog_Tickle(
Chain_Control *header
)
{
3000dfdc: e92d40f0 push {r4, r5, r6, r7, lr}
3000dfe0: e1a06000 mov r6, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000dfe4: e10f7000 mrs r7, CPSR 3000dfe8: e3873080 orr r3, r7, #128 ; 0x80 3000dfec: 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;
3000dff0: e1a05000 mov r5, r0 3000dff4: e4954004 ldr r4, [r5], #4
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000dff8: e1540005 cmp r4, r5
3000dffc: 0a000006 beq 3000e01c <_Watchdog_Tickle+0x40>
* 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) {
3000e000: e5943010 ldr r3, [r4, #16] 3000e004: e3530000 cmp r3, #0
3000e008: 0a000012 beq 3000e058 <_Watchdog_Tickle+0x7c>
the_watchdog->delta_interval--;
3000e00c: e2433001 sub r3, r3, #1
if ( the_watchdog->delta_interval != 0 )
3000e010: e3530000 cmp r3, #0
* 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) {
the_watchdog->delta_interval--;
3000e014: e5843010 str r3, [r4, #16]
if ( the_watchdog->delta_interval != 0 )
3000e018: 0a00000e beq 3000e058 <_Watchdog_Tickle+0x7c>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e01c: e129f007 msr CPSR_fc, r7
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000e020: e8bd80f0 pop {r4, r5, r6, r7, pc}
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
3000e024: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED 3000e028: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000e02c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000e030: e594f01c ldr pc, [r4, #28] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000e034: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000e038: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3000e03c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000e040: e5964000 ldr r4, [r6] <== NOT EXECUTED
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
3000e044: e1550004 cmp r5, r4 <== NOT EXECUTED 3000e048: 0afffff3 beq 3000e01c <_Watchdog_Tickle+0x40> <== NOT EXECUTED
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
3000e04c: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 3000e050: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e054: 1afffff0 bne 3000e01c <_Watchdog_Tickle+0x40> <== NOT EXECUTED
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
3000e058: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e05c: ebffffb3 bl 3000df30 <_Watchdog_Remove> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e060: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
switch( watchdog_state ) {
3000e064: e3500002 cmp r0, #2 <== NOT EXECUTED 3000e068: 1afffff1 bne 3000e034 <_Watchdog_Tickle+0x58> <== NOT EXECUTED 3000e06c: eaffffec b 3000e024 <_Watchdog_Tickle+0x48> <== NOT EXECUTED
3000e1d0 <_Workspace_Allocate_or_fatal_error>:
3000e1d0: e3a02000 mov r2, #0
}
void *_Workspace_Allocate_or_fatal_error(
size_t size
)
{
3000e1d4: e1a01000 mov r1, r0
3000e1d8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3000e1dc: e59f0018 ldr r0, [pc, #24] ; 3000e1fc <_Workspace_Allocate_or_fatal_error+0x2c>
3000e1e0: e1a03002 mov r3, r2
3000e1e4: eb000917 bl 30010648 <_Heap_Allocate_aligned_with_boundary>
__builtin_return_address( 1 ),
memory
);
#endif
if ( memory == NULL )
3000e1e8: e3500000 cmp r0, #0
3000e1ec: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
_Internal_error_Occurred(
3000e1f0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000e1f4: e3a02003 mov r2, #3 <== NOT EXECUTED 3000e1f8: ebfff6b1 bl 3000bcc4 <_Internal_error_Occurred> <== NOT EXECUTED
3000e070 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
3000e070: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size();
3000e074: e59f3120 ldr r3, [pc, #288] ; 3000e19c <_Workspace_Handler_initialization+0x12c>
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
3000e078: e24dd004 sub sp, sp, #4
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size();
3000e07c: e5d3c032 ldrb ip, [r3, #50] ; 0x32
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
3000e080: e58d2000 str r2, [sp]
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size();
3000e084: e35c0000 cmp ip, #0 3000e088: 05937004 ldreq r7, [r3, #4] 3000e08c: e5932000 ldr r2, [r3] 3000e090: 13a07000 movne r7, #0
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
3000e094: e3510000 cmp r1, #0
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
3000e098: e1a08001 mov r8, r1
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size();
3000e09c: e0877002 add r7, r7, r2
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
3000e0a0: e5d3a030 ldrb sl, [r3, #48] ; 0x30
bool unified = rtems_configuration_get_unified_work_area();
3000e0a4: e5d3b031 ldrb fp, [r3, #49] ; 0x31
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
3000e0a8: 0a000033 beq 3000e17c <_Workspace_Handler_initialization+0x10c>
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
3000e0ac: e59f90ec ldr r9, [pc, #236] ; 3000e1a0 <_Workspace_Handler_initialization+0x130>
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
3000e0b0: e1a04000 mov r4, r0 3000e0b4: e3a06000 mov r6, #0 3000e0b8: ea00001d b 3000e134 <_Workspace_Handler_initialization+0xc4>
if ( do_zero ) {
memset( area->begin, 0, area->size );
}
if ( area->size > overhead ) {
3000e0bc: e5945004 ldr r5, [r4, #4] 3000e0c0: e3550016 cmp r5, #22
3000e0c4: 9a000016 bls 3000e124 <_Workspace_Handler_initialization+0xb4>
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
3000e0c8: e35b0000 cmp fp, #0
3000e0cc: 1a000004 bne 3000e0e4 <_Workspace_Handler_initialization+0x74>
size = area->size;
} else {
if ( remaining > 0 ) {
3000e0d0: e3570000 cmp r7, #0
3000e0d4: 0a00001d beq 3000e150 <_Workspace_Handler_initialization+0xe0>
size = remaining < area->size - overhead ?
3000e0d8: e2453016 sub r3, r5, #22
remaining + overhead : area->size;
3000e0dc: e1530007 cmp r3, r7 3000e0e0: 82875016 addhi r5, r7, #22
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
3000e0e4: e1a02005 mov r2, r5 3000e0e8: e3a03008 mov r3, #8 3000e0ec: e59f00b0 ldr r0, [pc, #176] ; 3000e1a4 <_Workspace_Handler_initialization+0x134> 3000e0f0: e5941000 ldr r1, [r4] 3000e0f4: e1a0e00f mov lr, pc 3000e0f8: e12fff19 bx r9
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
3000e0fc: e5943000 ldr r3, [r4]
area->size -= size;
3000e100: e5942004 ldr r2, [r4, #4]
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
3000e104: e0833005 add r3, r3, r5
area->size -= size;
3000e108: e0655002 rsb r5, r5, r2
if ( space_available < remaining ) {
3000e10c: e1500007 cmp r0, r7
size,
page_size
);
area->begin = (char *) area->begin + size;
area->size -= size;
3000e110: e8840028 stm r4, {r3, r5}
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
3000e114: 359d9000 ldrcc r9, [sp] 3000e118: 259d9000 ldrcs r9, [sp]
area->begin = (char *) area->begin + size;
area->size -= size;
if ( space_available < remaining ) {
remaining -= space_available;
3000e11c: 30607007 rsbcc r7, r0, r7
} else {
remaining = 0;
3000e120: 23a07000 movcs r7, #0
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
3000e124: e2866001 add r6, r6, #1 3000e128: e1560008 cmp r6, r8 3000e12c: e2844008 add r4, r4, #8
3000e130: 0a000011 beq 3000e17c <_Workspace_Handler_initialization+0x10c>
Heap_Area *area = &areas [i];
if ( do_zero ) {
3000e134: e35a0000 cmp sl, #0
3000e138: 0affffdf beq 3000e0bc <_Workspace_Handler_initialization+0x4c>
memset( area->begin, 0, area->size );
3000e13c: e5940000 ldr r0, [r4] 3000e140: e3a01000 mov r1, #0 3000e144: e5942004 ldr r2, [r4, #4] 3000e148: eb001436 bl 30013228 <memset> 3000e14c: eaffffda b 3000e0bc <_Workspace_Handler_initialization+0x4c>
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
3000e150: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000e154: e59f0048 ldr r0, [pc, #72] ; 3000e1a4 <_Workspace_Handler_initialization+0x134><== NOT EXECUTED 3000e158: e1a02007 mov r2, r7 <== NOT EXECUTED 3000e15c: e3a03008 mov r3, #8 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
3000e160: e2866001 add r6, r6, #1 <== NOT EXECUTED
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
3000e164: e1a0e00f mov lr, pc <== NOT EXECUTED 3000e168: e12fff19 bx r9 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
3000e16c: e1560008 cmp r6, r8 <== NOT EXECUTED
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
3000e170: e59d9000 ldr r9, [sp] <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
3000e174: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000e178: 1affffed bne 3000e134 <_Workspace_Handler_initialization+0xc4><== NOT EXECUTED
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
3000e17c: e3570000 cmp r7, #0
3000e180: 1a000001 bne 3000e18c <_Workspace_Handler_initialization+0x11c>
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
}
3000e184: e28dd004 add sp, sp, #4
3000e188: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
_Internal_error_Occurred(
3000e18c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e190: e3a01001 mov r1, #1 <== NOT EXECUTED 3000e194: e3a02002 mov r2, #2 <== NOT EXECUTED 3000e198: ebfff6c9 bl 3000bcc4 <_Internal_error_Occurred> <== NOT EXECUTED
3001e8bc <_execve>:
int _execve(
const char *path __attribute__((unused)),
char *const argv[] __attribute__((unused)),
char *const envp[] __attribute__((unused))
)
{
3001e8bc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3001e8c0: ebffd196 bl 30012f20 <__errno> <== NOT EXECUTED 3001e8c4: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3001e8c8: e5803000 str r3, [r0] <== NOT EXECUTED
}
3001e8cc: e3e00000 mvn r0, #0 <== NOT EXECUTED
3001e8d0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3001dbdc <_kill_r>:
struct _reent *ptr,
pid_t pid,
int sig
)
{
return killinfo( pid, sig, NULL );
3001dbdc: e1a00001 mov r0, r1 <== NOT EXECUTED 3001dbe0: e1a01002 mov r1, r2 <== NOT EXECUTED 3001dbe4: e3a02000 mov r2, #0 <== NOT EXECUTED 3001dbe8: ea000023 b 3001dc7c <killinfo> <== NOT EXECUTED
3000a728 <adjtime>:
*/
int adjtime(
const struct timeval *delta,
struct timeval *olddelta
)
{
3000a728: e92d4370 push {r4, r5, r6, r8, r9, lr} <== NOT EXECUTED
long adjustment;
/*
* Simple validations
*/
if ( !delta )
3000a72c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
*/
int adjtime(
const struct timeval *delta,
struct timeval *olddelta
)
{
3000a730: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 3000a734: e1a06001 mov r6, r1 <== NOT EXECUTED
long adjustment;
/*
* Simple validations
*/
if ( !delta )
3000a738: 0a00004f beq 3000a87c <adjtime+0x154> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
3000a73c: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED 3000a740: e59f3148 ldr r3, [pc, #328] ; 3000a890 <adjtime+0x168> <== NOT EXECUTED 3000a744: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a748: 8a00004b bhi 3000a87c <adjtime+0x154> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
3000a74c: e3510000 cmp r1, #0 <== NOT EXECUTED
olddelta->tv_sec = 0;
3000a750: 13a03000 movne r3, #0 <== NOT EXECUTED 3000a754: 15813000 strne r3, [r1] <== NOT EXECUTED
olddelta->tv_usec = 0;
3000a758: 15813004 strne r3, [r1, #4] <== NOT EXECUTED
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
3000a75c: e5953000 ldr r3, [r5] <== NOT EXECUTED
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
3000a760: 15952004 ldrne r2, [r5, #4] <== NOT EXECUTED
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
3000a764: e0631283 rsb r1, r3, r3, lsl #5 <== NOT EXECUTED 3000a768: e0611301 rsb r1, r1, r1, lsl #6 <== NOT EXECUTED 3000a76c: e0833181 add r3, r3, r1, lsl #3 <== NOT EXECUTED
adjustment += delta->tv_usec;
3000a770: e0822303 add r2, r2, r3, lsl #6 <== NOT EXECUTED
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
3000a774: e59f3118 ldr r3, [pc, #280] ; 3000a894 <adjtime+0x16c> <== NOT EXECUTED 3000a778: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000a77c: e1520000 cmp r2, r0 <== NOT EXECUTED
return 0;
3000a780: 33a00000 movcc r0, #0 <== NOT EXECUTED
/* convert delta to microseconds */
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() )
3000a784: 2a000001 bcs 3000a790 <adjtime+0x68> <== NOT EXECUTED
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
3000a788: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000a78c: e8bd8370 pop {r4, r5, r6, r8, r9, 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;
3000a790: e59f3100 ldr r3, [pc, #256] ; 3000a898 <adjtime+0x170> <== NOT EXECUTED 3000a794: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3000a798: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000a79c: e5832000 str r2, [r3] <== NOT EXECUTED
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
3000a7a0: e59f10f4 ldr r1, [pc, #244] ; 3000a89c <adjtime+0x174> <== NOT EXECUTED 3000a7a4: e1a0000d mov r0, sp <== NOT EXECUTED 3000a7a8: eb000655 bl 3000c104 <_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);
3000a7ac: e59f20ec ldr r2, [pc, #236] ; 3000a8a0 <adjtime+0x178> <== NOT EXECUTED
3000a7b0: e8900300 ldm r0, {r8, r9} <== NOT EXECUTED
3000a7b4: e3a03000 mov r3, #0 <== NOT EXECUTED
3000a7b8: e1a00008 mov r0, r8 <== NOT EXECUTED
3000a7bc: e1a01009 mov r1, r9 <== NOT EXECUTED
3000a7c0: eb0050c5 bl 3001eadc <__divdi3> <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
3000a7c4: e5954000 ldr r4, [r5] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a7c8: e59f20d0 ldr r2, [pc, #208] ; 3000a8a0 <adjtime+0x178> <== NOT EXECUTED 3000a7cc: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a7d0: e0844000 add r4, r4, r0 <== NOT EXECUTED 3000a7d4: e1a01009 mov r1, r9 <== NOT EXECUTED 3000a7d8: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a7dc: eb0051f9 bl 3001efc8 <__moddi3> <== NOT EXECUTED
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
3000a7e0: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000a7e4: e59f20b8 ldr r2, [pc, #184] ; 3000a8a4 <adjtime+0x17c> <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
3000a7e8: e0631283 rsb r1, r3, r3, lsl #5 <== NOT EXECUTED 3000a7ec: e0833101 add r3, r3, r1, lsl #2 <== NOT EXECUTED 3000a7f0: e0803183 add r3, r0, r3, lsl #3 <== NOT EXECUTED
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000a7f4: e1530002 cmp r3, r2 <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
3000a7f8: 91a01003 movls r1, r3 <== NOT EXECUTED
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000a7fc: 9a000006 bls 3000a81c <adjtime+0xf4> <== NOT EXECUTED
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000a800: e2833331 add r3, r3, #-1006632960 ; 0xc4000000 <== NOT EXECUTED 3000a804: e2833865 add r3, r3, #6619136 ; 0x650000 <== NOT EXECUTED 3000a808: e2833c36 add r3, r3, #13824 ; 0x3600 <== NOT EXECUTED
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000a80c: e1530002 cmp r3, r2 <== NOT EXECUTED
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000a810: e1a01003 mov r1, r3 <== NOT EXECUTED
ts.tv_sec++;
3000a814: e2844001 add r4, r4, #1 <== NOT EXECUTED
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000a818: 8afffff8 bhi 3000a800 <adjtime+0xd8> <== 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) ) {
3000a81c: e59f2084 ldr r2, [pc, #132] ; 3000a8a8 <adjtime+0x180> <== NOT EXECUTED 3000a820: e1530002 cmp r3, r2 <== NOT EXECUTED 3000a824: 8a000006 bhi 3000a844 <adjtime+0x11c> <== NOT EXECUTED
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
3000a828: e28335ee add r3, r3, #998244352 ; 0x3b800000 <== NOT EXECUTED 3000a82c: e283396b add r3, r3, #1753088 ; 0x1ac000 <== NOT EXECUTED 3000a830: e2833c0a add r3, r3, #2560 ; 0xa00 <== 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) ) {
3000a834: e1530002 cmp r3, r2 <== NOT EXECUTED
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
3000a838: e1a01003 mov r1, r3 <== NOT EXECUTED
ts.tv_sec--;
3000a83c: e2444001 sub r4, r4, #1 <== 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) ) {
3000a840: 9afffff8 bls 3000a828 <adjtime+0x100> <== NOT EXECUTED
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
3000a844: e1a02001 mov r2, r1 <== NOT EXECUTED 3000a848: e1a03fc1 asr r3, r1, #31 <== NOT EXECUTED
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
3000a84c: e59f104c ldr r1, [pc, #76] ; 3000a8a0 <adjtime+0x178> <== NOT EXECUTED
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
3000a850: e1a0000d mov r0, sp <== NOT EXECUTED
3000a854: e0e32491 smlal r2, r3, r1, r4 <== NOT EXECUTED
3000a858: e88d000c stm sp, {r2, r3} <== NOT EXECUTED
3000a85c: eb000647 bl 3000c180 <_TOD_Set_with_timestamp> <== NOT EXECUTED
ts.tv_sec--;
}
_TOD_Set( &ts );
_Thread_Enable_dispatch();
3000a860: eb000c95 bl 3000dabc <_Thread_Enable_dispatch> <== NOT EXECUTED
/* set the user's output */
if ( olddelta )
3000a864: e3560000 cmp r6, #0 <== NOT EXECUTED
*olddelta = *delta;
return 0;
3000a868: 01a00006 moveq r0, r6 <== NOT EXECUTED
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
3000a86c: 1895000c ldmne r5, {r2, r3} <== NOT EXECUTED
return 0;
3000a870: 13a00000 movne r0, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
3000a874: 1886000c stmne r6, {r2, r3} <== NOT EXECUTED
3000a878: eaffffc2 b 3000a788 <adjtime+0x60> <== NOT EXECUTED
*/
if ( !delta )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
3000a87c: eb0022ae bl 3001333c <__errno> <== NOT EXECUTED 3000a880: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a884: e5803000 str r3, [r0] <== NOT EXECUTED 3000a888: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000a88c: eaffffbd b 3000a788 <adjtime+0x60> <== NOT EXECUTED
3000aaf0 <aio_cancel>:
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
3000aaf0: 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);
3000aaf4: e59f41b8 ldr r4, [pc, #440] ; 3000acb4 <aio_cancel+0x1c4> <== NOT EXECUTED
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
3000aaf8: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
3000aafc: 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)
{
3000ab00: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
3000ab04: eb000457 bl 3000bc68 <pthread_mutex_lock> <== NOT EXECUTED
if (fcntl (fildes, F_GETFD) < 0) {
3000ab08: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ab0c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000ab10: eb001abb bl 30011604 <fcntl> <== NOT EXECUTED 3000ab14: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ab18: ba00005e blt 3000ac98 <aio_cancel+0x1a8> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
3000ab1c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000ab20: 0a000032 beq 3000abf0 <aio_cancel+0x100> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
3000ab24: e5957000 ldr r7, [r5] <== NOT EXECUTED 3000ab28: e1570006 cmp r7, r6 <== NOT EXECUTED 3000ab2c: 1a000028 bne 3000abd4 <aio_cancel+0xe4> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
3000ab30: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000ab34: e1a01007 mov r1, r7 <== NOT EXECUTED 3000ab38: e3a02000 mov r2, #0 <== NOT EXECUTED 3000ab3c: eb000179 bl 3000b128 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000ab40: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000ab44: 0a00000c beq 3000ab7c <aio_cancel+0x8c> <== NOT EXECUTED
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
3000ab48: e286801c add r8, r6, #28 <== NOT EXECUTED 3000ab4c: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ab50: eb000444 bl 3000bc68 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
3000ab54: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ab58: e2860008 add r0, r6, #8 <== NOT EXECUTED 3000ab5c: eb0001bd bl 3000b258 <rtems_aio_remove_req> <== NOT EXECUTED 3000ab60: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000ab64: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ab68: eb00045f bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000ab6c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ab70: eb00045d bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
3000ab74: e1a00005 mov r0, r5 <== NOT EXECUTED
3000ab78: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
3000ab7c: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 3000ab80: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 3000ab84: e1520003 cmp r2, r3 <== NOT EXECUTED 3000ab88: 0a00000d beq 3000abc4 <aio_cancel+0xd4> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
3000ab8c: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 3000ab90: e1a01007 mov r1, r7 <== NOT EXECUTED 3000ab94: e1a02006 mov r2, r6 <== NOT EXECUTED 3000ab98: eb000162 bl 3000b128 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000ab9c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aba0: 0a00000b beq 3000abd4 <aio_cancel+0xe4> <== 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);
3000aba4: e1a01005 mov r1, r5 <== NOT EXECUTED 3000aba8: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000abac: eb0001a9 bl 3000b258 <rtems_aio_remove_req> <== NOT EXECUTED 3000abb0: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000abb4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000abb8: eb00044b bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
return AIO_ALLDONE;
}
3000abbc: e1a00005 mov r0, r5 <== NOT EXECUTED
3000abc0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
3000abc4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000abc8: eb000447 bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
3000abcc: e3a05002 mov r5, #2 <== NOT EXECUTED 3000abd0: eaffffe7 b 3000ab74 <aio_cancel+0x84> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock (&aio_request_queue.mutex);
3000abd4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000abd8: eb000443 bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EINVAL);
3000abdc: eb002847 bl 30014d00 <__errno> <== NOT EXECUTED 3000abe0: e3a03016 mov r3, #22 <== NOT EXECUTED 3000abe4: e5803000 str r3, [r0] <== NOT EXECUTED 3000abe8: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000abec: eaffffe0 b 3000ab74 <aio_cancel+0x84> <== NOT EXECUTED
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
3000abf0: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000abf4: e1a01006 mov r1, r6 <== NOT EXECUTED 3000abf8: e1a02005 mov r2, r5 <== NOT EXECUTED 3000abfc: eb000149 bl 3000b128 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000ac00: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000ac04: 0a00000b beq 3000ac38 <aio_cancel+0x148> <== NOT EXECUTED
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
3000ac08: e287601c add r6, r7, #28 <== NOT EXECUTED 3000ac0c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ac10: eb000414 bl 3000bc68 <pthread_mutex_lock> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000ac14: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ac18: eb000aab bl 3000d6cc <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
3000ac1c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ac20: eb000178 bl 3000b208 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000ac24: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ac28: eb00042f bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000ac2c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac30: eb00042d bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
3000ac34: eaffffce b 3000ab74 <aio_cancel+0x84> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
3000ac38: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 3000ac3c: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 3000ac40: e1520003 cmp r2, r3 <== NOT EXECUTED 3000ac44: 0affffde beq 3000abc4 <aio_cancel+0xd4> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
3000ac48: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 3000ac4c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000ac50: e1a02007 mov r2, r7 <== NOT EXECUTED 3000ac54: eb000133 bl 3000b128 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000ac58: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000ac5c: 0affffd8 beq 3000abc4 <aio_cancel+0xd4> <== 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);
3000ac60: e285601c add r6, r5, #28 <== NOT EXECUTED 3000ac64: eb000a98 bl 3000d6cc <_Chain_Extract> <== NOT EXECUTED
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
3000ac68: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ac6c: eb000165 bl 3000b208 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
3000ac70: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ac74: eb000359 bl 3000b9e0 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
3000ac78: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ac7c: eb00027f bl 3000b680 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
3000ac80: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ac84: ebfff075 bl 30006e60 <free> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000ac88: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac8c: eb000416 bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
3000ac90: e1a05007 mov r5, r7 <== NOT EXECUTED 3000ac94: eaffffb6 b 3000ab74 <aio_cancel+0x84> <== NOT EXECUTED
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
if (fcntl (fildes, F_GETFD) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
3000ac98: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac9c: eb000412 bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EBADF);
3000aca0: eb002816 bl 30014d00 <__errno> <== NOT EXECUTED 3000aca4: e3a03009 mov r3, #9 <== NOT EXECUTED 3000aca8: e5803000 str r3, [r0] <== NOT EXECUTED 3000acac: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000acb0: eaffffaf b 3000ab74 <aio_cancel+0x84> <== NOT EXECUTED
3000acb8 <aio_error>:
int
aio_error (const struct aiocb *aiocbp)
{
return aiocbp->error_code;
}
3000acb8: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED 3000acbc: e12fff1e bx lr <== NOT EXECUTED
3000acc0 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
3000acc0: e3500a02 cmp r0, #8192 ; 0x2000 <== NOT EXECUTED
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
3000acc4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000acc8: 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);
3000accc: 13a05016 movne r5, #22 <== NOT EXECUTED
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
3000acd0: 1a000011 bne 3000ad1c <aio_fsync+0x5c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000acd4: e5910000 ldr r0, [r1] <== NOT EXECUTED 3000acd8: e3a01003 mov r1, #3 <== NOT EXECUTED 3000acdc: eb001a48 bl 30011604 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000ace0: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000ace4: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000ace8: e3500001 cmp r0, #1 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000acec: 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)))
3000acf0: 8a000009 bhi 3000ad1c <aio_fsync+0x5c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
3000acf4: e3a00018 mov r0, #24 <== NOT EXECUTED 3000acf8: ebfff174 bl 300072d0 <malloc> <== NOT EXECUTED
if (req == NULL)
3000acfc: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000ad00: 0a000004 beq 3000ad18 <aio_fsync+0x58> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000ad04: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
3000ad08: e3a03003 mov r3, #3 <== NOT EXECUTED 3000ad0c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000ad10: 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);
3000ad14: ea000168 b 3000b2bc <rtems_aio_enqueue> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000ad18: e3a0500b mov r5, #11 <== NOT EXECUTED 3000ad1c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000ad20: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000ad24: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000ad28: eb0027f4 bl 30014d00 <__errno> <== NOT EXECUTED 3000ad2c: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
3000ad30: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000ad34: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b498 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
3000b498: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000b49c: e3a01003 mov r1, #3 <== NOT EXECUTED
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
3000b4a0: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000b4a4: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000b4a8: eb001855 bl 30011604 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000b4ac: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000b4b0: e3500002 cmp r0, #2 <== NOT EXECUTED 3000b4b4: 13500000 cmpne r0, #0 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000b4b8: 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)))
3000b4bc: 1a000010 bne 3000b504 <aio_read+0x6c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
3000b4c0: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000b4c4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b4c8: 1a000014 bne 3000b520 <aio_read+0x88> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
3000b4cc: e994000c ldmib r4, {r2, r3} <== NOT EXECUTED
3000b4d0: e3520000 cmp r2, #0 <== NOT EXECUTED
3000b4d4: e2d31000 sbcs r1, r3, #0 <== NOT EXECUTED
3000b4d8: ba000010 blt 3000b520 <aio_read+0x88> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
3000b4dc: e3a00018 mov r0, #24 <== NOT EXECUTED 3000b4e0: ebffef7a bl 300072d0 <malloc> <== NOT EXECUTED
if (req == NULL)
3000b4e4: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000b4e8: 0a000004 beq 3000b500 <aio_read+0x68> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000b4ec: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_READ;
3000b4f0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b4f4: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000b4f8: 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);
3000b4fc: eaffff6e b 3000b2bc <rtems_aio_enqueue> <== NOT EXECUTED
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000b500: e3a0500b mov r5, #11 <== NOT EXECUTED 3000b504: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000b508: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000b50c: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000b510: eb0025fa bl 30014d00 <__errno> <== NOT EXECUTED 3000b514: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
3000b518: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b51c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
3000b520: e3a05016 mov r5, #22 <== NOT EXECUTED 3000b524: eafffff6 b 3000b504 <aio_read+0x6c> <== NOT EXECUTED
3000b528 <aio_return>:
ssize_t
aio_return (const struct aiocb *aiocbp)
{
return aiocbp->return_value;
}
3000b528: e5900034 ldr r0, [r0, #52] ; 0x34 <== NOT EXECUTED 3000b52c: e12fff1e bx lr <== NOT EXECUTED
3000a3d8 <aio_suspend>:
int aio_suspend(
const struct aiocb * const list[] __attribute__((unused)),
int nent __attribute__((unused)),
const struct timespec *timeout __attribute__((unused))
)
{
3000a3d8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a3dc: eb0022cf bl 30012f20 <__errno> <== NOT EXECUTED 3000a3e0: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a3e4: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a3e8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a3ec: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b530 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
3000b530: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000b534: e3a01003 mov r1, #3 <== NOT EXECUTED
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
3000b538: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000b53c: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000b540: eb00182f bl 30011604 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000b544: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000b548: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000b54c: e3500001 cmp r0, #1 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000b550: 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)))
3000b554: 8a000010 bhi 3000b59c <aio_write+0x6c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
3000b558: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000b55c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b560: 1a000014 bne 3000b5b8 <aio_write+0x88> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
3000b564: e994000c ldmib r4, {r2, r3} <== NOT EXECUTED
3000b568: e3520000 cmp r2, #0 <== NOT EXECUTED
3000b56c: e2d31000 sbcs r1, r3, #0 <== NOT EXECUTED
3000b570: ba000010 blt 3000b5b8 <aio_write+0x88> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
3000b574: e3a00018 mov r0, #24 <== NOT EXECUTED 3000b578: ebffef54 bl 300072d0 <malloc> <== NOT EXECUTED
if (req == NULL)
3000b57c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000b580: 0a000004 beq 3000b598 <aio_write+0x68> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000b584: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_WRITE;
3000b588: e3a03002 mov r3, #2 <== NOT EXECUTED 3000b58c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000b590: 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);
3000b594: eaffff48 b 3000b2bc <rtems_aio_enqueue> <== NOT EXECUTED
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000b598: e3a0500b mov r5, #11 <== NOT EXECUTED 3000b59c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000b5a0: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000b5a4: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000b5a8: eb0025d4 bl 30014d00 <__errno> <== NOT EXECUTED 3000b5ac: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
3000b5b0: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b5b4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
3000b5b8: e3a05016 mov r5, #22 <== NOT EXECUTED 3000b5bc: eafffff6 b 3000b59c <aio_write+0x6c> <== NOT EXECUTED
3000c500 <alarm>:
}
unsigned int alarm(
unsigned int seconds
)
{
3000c500: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000c504: e59f4080 ldr r4, [pc, #128] ; 3000c58c <alarm+0x8c> <== NOT EXECUTED
}
unsigned int alarm(
unsigned int seconds
)
{
3000c508: e1a05000 mov r5, r0 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000c50c: e594601c ldr r6, [r4, #28] <== NOT EXECUTED 3000c510: e3560000 cmp r6, #0 <== NOT EXECUTED 3000c514: 0a00000c beq 3000c54c <alarm+0x4c> <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
3000c518: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c51c: eb0013e3 bl 300114b0 <_Watchdog_Remove> <== NOT EXECUTED
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
3000c520: e2400002 sub r0, r0, #2 <== NOT EXECUTED 3000c524: e3500001 cmp r0, #1 <== NOT EXECUTED
unsigned int alarm(
unsigned int seconds
)
{
unsigned int remaining = 0;
3000c528: 83a06000 movhi r6, #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) ) {
3000c52c: 9a00000c bls 3000c564 <alarm+0x64> <== NOT EXECUTED
remaining = the_timer->initial -
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
}
}
if ( seconds )
3000c530: e3550000 cmp r5, #0 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000c534: 159f0054 ldrne r0, [pc, #84] ; 3000c590 <alarm+0x90> <== NOT EXECUTED 3000c538: 159f104c ldrne r1, [pc, #76] ; 3000c58c <alarm+0x8c> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000c53c: 1584500c strne r5, [r4, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000c540: 1b00136d blne 300112fc <_Watchdog_Insert> <== NOT EXECUTED
_Watchdog_Insert_seconds( the_timer, seconds );
return remaining;
}
3000c544: e1a00006 mov r0, r6 <== NOT EXECUTED
3000c548: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000c54c: e59f3040 ldr r3, [pc, #64] ; 3000c594 <alarm+0x94> <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000c550: e5846008 str r6, [r4, #8] <== NOT EXECUTED
the_watchdog->routine = routine;
3000c554: e584301c str r3, [r4, #28] <== NOT EXECUTED
the_watchdog->id = id;
3000c558: e5846020 str r6, [r4, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000c55c: e5846024 str r6, [r4, #36] ; 0x24 <== NOT EXECUTED 3000c560: eafffff2 b 3000c530 <alarm+0x30> <== 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);
3000c564: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000c568: e5947018 ldr r7, [r4, #24] <== 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 -
3000c56c: e594600c ldr r6, [r4, #12] <== NOT EXECUTED
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
3000c570: e0637007 rsb r7, r3, r7 <== NOT EXECUTED 3000c574: eb0009e4 bl 3000ed0c <TOD_TICKS_PER_SECOND_method> <== NOT EXECUTED 3000c578: e1a01000 mov r1, r0 <== NOT EXECUTED 3000c57c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c580: eb004df0 bl 3001fd48 <__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 -
3000c584: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000c588: eaffffe8 b 3000c530 <alarm+0x30> <== NOT EXECUTED
3000b8d0 <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) {
3000b8d0: 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(
3000b8d4: e92d0070 push {r4, r5, r6} <== 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) {
3000b8d8: e5934018 ldr r4, [r3, #24] <== NOT EXECUTED 3000b8dc: e154000c cmp r4, ip <== NOT EXECUTED 3000b8e0: 31a0c002 movcc ip, r2 <== NOT EXECUTED 3000b8e4: 31a02003 movcc r2, r3 <== NOT EXECUTED 3000b8e8: 31a0300c movcc r3, ip <== NOT EXECUTED
a = b;
b = t;
}
a->size += b->size;
3000b8ec: e592601c ldr r6, [r2, #28] <== NOT EXECUTED 3000b8f0: e593501c ldr r5, [r3, #28] <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3000b8f4: e593c000 ldr ip, [r3] <== NOT EXECUTED
previous = the_node->previous;
3000b8f8: e5934004 ldr r4, [r3, #4] <== NOT EXECUTED 3000b8fc: e0865005 add r5, r6, r5 <== NOT EXECUTED 3000b900: e582501c str r5, [r2, #28] <== NOT EXECUTED
next->previous = previous; previous->next = next;
3000b904: e584c000 str ip, [r4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b908: e5902000 ldr r2, [r0] <== NOT EXECUTED
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
3000b90c: e58c4004 str r4, [ip, #4] <== NOT EXECUTED
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
3000b910: e5803000 str r3, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b914: e5830004 str r0, [r3, #4] <== NOT EXECUTED
rtems_chain_extract_unprotected(&b->chain_node);
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
3000b918: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b91c: e2831008 add r1, r3, #8 <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node; the_node->next = before_node;
3000b920: e5832000 str r2, [r3] <== NOT EXECUTED
before_node->previous = the_node;
3000b924: e5823004 str r3, [r2, #4] <== NOT EXECUTED
} }
3000b928: e8bd0070 pop {r4, r5, r6} <== 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);
3000b92c: ea0006d1 b 3000d478 <_RBTree_Extract_unprotected> <== NOT EXECUTED
3000b8c0 <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);
3000b8c0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 3000b8c4: e5910010 ldr r0, [r1, #16] <== NOT EXECUTED
}
3000b8c8: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 3000b8cc: e12fff1e bx lr <== NOT EXECUTED
3000a3f0 <clock_getcpuclockid>:
int clock_getcpuclockid(
pid_t pid,
clockid_t *clock_id
)
{
3000a3f0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a3f4: eb0022c9 bl 30012f20 <__errno> <== NOT EXECUTED 3000a3f8: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a3fc: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a400: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a404: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a408 <clock_getenable_attr>:
int clock_getenable_attr(
clockid_t clock_id,
int *attr
)
{
3000a408: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a40c: eb0022c3 bl 30012f20 <__errno> <== NOT EXECUTED 3000a410: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a414: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a418: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a41c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000acec <clock_getres>:
int clock_getres(
clockid_t clock_id,
struct timespec *res
)
{
if ( !res )
3000acec: e3510000 cmp r1, #0 <== NOT EXECUTED
int clock_getres(
clockid_t clock_id,
struct timespec *res
)
{
3000acf0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !res )
3000acf4: 0a000010 beq 3000ad3c <clock_getres+0x50> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
switch ( clock_id ) {
3000acf8: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000acfc: e3500002 cmp r0, #2 <== NOT EXECUTED 3000ad00: 9a000004 bls 3000ad18 <clock_getres+0x2c> <== NOT EXECUTED
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
}
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000ad04: eb0022d7 bl 30013868 <__errno> <== NOT EXECUTED 3000ad08: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ad0c: e5803000 str r3, [r0] <== NOT EXECUTED 3000ad10: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
3000ad14: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== 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() /
3000ad18: e59f3030 ldr r3, [pc, #48] ; 3000ad50 <clock_getres+0x64> <== NOT EXECUTED 3000ad1c: e59f2030 ldr r2, [pc, #48] ; 3000ad54 <clock_getres+0x68> <== NOT EXECUTED 3000ad20: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND;
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
3000ad24: e5933010 ldr r3, [r3, #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() /
3000ad28: e082c290 umull ip, r2, r0, r2 <== NOT EXECUTED 3000ad2c: e1a02922 lsr r2, r2, #18 <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND;
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
3000ad30: e881000c stm r1, {r2, r3} <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return 0;
3000ad34: e3a00000 mov r0, #0 <== NOT EXECUTED
3000ad38: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
clockid_t clock_id,
struct timespec *res
)
{
if ( !res )
rtems_set_errno_and_return_minus_one( EINVAL );
3000ad3c: eb0022c9 bl 30013868 <__errno> <== NOT EXECUTED
3000ad40: e3a03016 mov r3, #22 <== NOT EXECUTED
3000ad44: e5803000 str r3, [r0] <== NOT EXECUTED
3000ad48: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000ad4c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a5f4 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
3000a5f4: e92d40d0 push {r4, r6, r7, lr}
if ( !tp )
3000a5f8: e2514000 subs r4, r1, #0
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
3000a5fc: e24dd008 sub sp, sp, #8
if ( !tp )
3000a600: 0a000007 beq 3000a624 <clock_gettime+0x30>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
3000a604: e3500001 cmp r0, #1
3000a608: 0a000015 beq 3000a664 <clock_gettime+0x70>
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
3000a60c: e3500004 cmp r0, #4 <== NOT EXECUTED 3000a610: 0a00000f beq 3000a654 <clock_gettime+0x60> <== NOT EXECUTED
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
3000a614: e3500002 cmp r0, #2 <== NOT EXECUTED 3000a618: 0a00000d beq 3000a654 <clock_gettime+0x60> <== NOT EXECUTED
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
3000a61c: e3500003 cmp r0, #3 <== NOT EXECUTED 3000a620: 0a000006 beq 3000a640 <clock_gettime+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
3000a624: eb0024c3 bl 30013938 <__errno> <== NOT EXECUTED 3000a628: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a62c: e5803000 str r3, [r0] <== NOT EXECUTED 3000a630: e3e03000 mvn r3, #0 <== NOT EXECUTED
return 0;
}
3000a634: e1a00003 mov r0, r3
3000a638: e28dd008 add sp, sp, #8
3000a63c: e8bd80d0 pop {r4, r6, r7, pc}
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a640: eb0024bc bl 30013938 <__errno> <== NOT EXECUTED 3000a644: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a648: e5803000 str r3, [r0] <== NOT EXECUTED 3000a64c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000a650: eafffff7 b 3000a634 <clock_gettime+0x40> <== NOT EXECUTED
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
_TOD_Get_uptime_as_timespec( tp );
3000a654: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a658: eb0007ed bl 3000c614 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return 0;
3000a65c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a660: eafffff3 b 3000a634 <clock_gettime+0x40> <== NOT EXECUTED
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
3000a664: e59f1040 ldr r1, [pc, #64] ; 3000a6ac <clock_gettime+0xb8> 3000a668: e1a0000d mov r0, sp 3000a66c: eb0007d7 bl 3000c5d0 <_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);
3000a670: e59f2038 ldr r2, [pc, #56] ; 3000a6b0 <clock_gettime+0xbc>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
3000a674: e89000c0 ldm r0, {r6, r7}
3000a678: e3a03000 mov r3, #0
3000a67c: e1a00006 mov r0, r6
3000a680: e1a01007 mov r1, r7
3000a684: eb005559 bl 3001fbf0 <__divdi3>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a688: e3a03000 mov r3, #0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
3000a68c: e5840000 str r0, [r4]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a690: e59f2018 ldr r2, [pc, #24] ; 3000a6b0 <clock_gettime+0xbc> 3000a694: e1a00006 mov r0, r6 3000a698: e1a01007 mov r1, r7 3000a69c: eb00568e bl 300200dc <__moddi3>
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
return 0;
3000a6a0: e3a03000 mov r3, #0 3000a6a4: e5840004 str r0, [r4, #4] 3000a6a8: eaffffe1 b 3000a634 <clock_gettime+0x40>
3000a420 <clock_setenable_attr>:
int clock_setenable_attr(
clockid_t clock_id,
int attr
)
{
3000a420: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a424: eb0022bd bl 30012f20 <__errno> <== NOT EXECUTED 3000a428: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a42c: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a430: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a434: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30029964 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
30029964: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !tp )
30029968: e3510000 cmp r1, #0 <== NOT EXECUTED
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
3002996c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
if ( !tp )
30029970: 0a000005 beq 3002998c <clock_settime+0x28> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
30029974: e3500001 cmp r0, #1 <== NOT EXECUTED 30029978: 0a000009 beq 300299a4 <clock_settime+0x40> <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
3002997c: e3500002 cmp r0, #2 <== NOT EXECUTED 30029980: 0a00001b beq 300299f4 <clock_settime+0x90> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
30029984: e3500003 cmp r0, #3 <== NOT EXECUTED 30029988: 0a000019 beq 300299f4 <clock_settime+0x90> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
3002998c: eb00449b bl 3003ac00 <__errno> <== NOT EXECUTED 30029990: e3a03016 mov r3, #22 <== NOT EXECUTED 30029994: e5803000 str r3, [r0] <== NOT EXECUTED 30029998: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
3002999c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
300299a0: e8bd8000 pop {pc} <== NOT EXECUTED
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
300299a4: e5912000 ldr r2, [r1] <== NOT EXECUTED 300299a8: e59f3058 ldr r3, [pc, #88] ; 30029a08 <clock_settime+0xa4> <== NOT EXECUTED 300299ac: e1520003 cmp r2, r3 <== NOT EXECUTED 300299b0: 9afffff5 bls 3002998c <clock_settime+0x28> <== 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;
300299b4: e59f3050 ldr r3, [pc, #80] ; 30029a0c <clock_settime+0xa8> <== NOT EXECUTED 300299b8: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
300299bc: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
300299c0: e5832000 str r2, [r3] <== NOT EXECUTED
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
300299c4: e8911001 ldm r1, {r0, ip} <== NOT EXECUTED
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
300299c8: e59f1040 ldr r1, [pc, #64] ; 30029a10 <clock_settime+0xac> <== NOT EXECUTED
300299cc: e1a0200c mov r2, ip <== NOT EXECUTED
300299d0: e1a03fcc asr r3, ip, #31 <== NOT EXECUTED
300299d4: e0e32091 smlal r2, r3, r1, r0 <== NOT EXECUTED
300299d8: e28d0008 add r0, sp, #8 <== NOT EXECUTED
300299dc: 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 );
300299e0: e1a0000d mov r0, sp <== NOT EXECUTED 300299e4: eb00040c bl 3002aa1c <_TOD_Set_with_timestamp> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
300299e8: ebff8fc0 bl 3000d8f0 <_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;
300299ec: e3a00000 mov r0, #0 <== NOT EXECUTED 300299f0: eaffffe9 b 3002999c <clock_settime+0x38> <== NOT EXECUTED
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
300299f4: eb004481 bl 3003ac00 <__errno> <== NOT EXECUTED 300299f8: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300299fc: e5803000 str r3, [r0] <== NOT EXECUTED 30029a00: e3e00000 mvn r0, #0 <== NOT EXECUTED 30029a04: eaffffe4 b 3002999c <clock_settime+0x38> <== NOT EXECUTED
3000a438 <fork>:
#include <errno.h>
#include <rtems/seterr.h>
int fork( void )
{
3000a438: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a43c: eb0022b7 bl 30012f20 <__errno> <== NOT EXECUTED 3000a440: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a444: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a448: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a44c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a380 <getitimer>:
int getitimer(
int which,
struct itimerval *value
)
{
if ( !value )
3000a380: e3510000 cmp r1, #0 <== NOT EXECUTED
int getitimer(
int which,
struct itimerval *value
)
{
3000a384: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !value )
3000a388: 0a00000b beq 3000a3bc <getitimer+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
3000a38c: e3500002 cmp r0, #2 <== NOT EXECUTED 3000a390: 9a000004 bls 3000a3a8 <getitimer+0x28> <== NOT EXECUTED
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000a394: eb00229b bl 30012e08 <__errno> <== NOT EXECUTED 3000a398: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a39c: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a3a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a3a4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
switch ( which ) {
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a3a8: eb002296 bl 30012e08 <__errno> <== NOT EXECUTED 3000a3ac: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a3b0: e5803000 str r3, [r0] <== NOT EXECUTED
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
3000a3b4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a3b8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int which,
struct itimerval *value
)
{
if ( !value )
rtems_set_errno_and_return_minus_one( EFAULT );
3000a3bc: eb002291 bl 30012e08 <__errno> <== NOT EXECUTED 3000a3c0: e3a0300e mov r3, #14 <== NOT EXECUTED 3000a3c4: e5803000 str r3, [r0] <== NOT EXECUTED 3000a3c8: eafffff4 b 3000a3a0 <getitimer+0x20> <== NOT EXECUTED
3001dc7c <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
3001dc7c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3001dc80: e24dd00c sub sp, sp, #12
3001dc84: e1a04000 mov r4, r0
3001dc88: e1a05001 mov r5, r1
3001dc8c: e1a08002 mov r8, r2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
3001dc90: ebffff7d bl 3001da8c <getpid> 3001dc94: e1500004 cmp r0, r4
3001dc98: 1a000091 bne 3001dee4 <killinfo+0x268>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
3001dc9c: e3550000 cmp r5, #0
3001dca0: 0a000094 beq 3001def8 <killinfo+0x27c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3001dca4: e2454001 sub r4, r5, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
3001dca8: e354001f cmp r4, #31
3001dcac: 8a000091 bhi 3001def8 <killinfo+0x27c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
3001dcb0: e59f626c ldr r6, [pc, #620] ; 3001df24 <killinfo+0x2a8> 3001dcb4: e1a07085 lsl r7, r5, #1 3001dcb8: e0873005 add r3, r7, r5 3001dcbc: e0863103 add r3, r6, r3, lsl #2 3001dcc0: e5933008 ldr r3, [r3, #8] 3001dcc4: e3530001 cmp r3, #1
return 0;
3001dcc8: 03a00000 moveq r0, #0
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
3001dccc: 0a000035 beq 3001dda8 <killinfo+0x12c>
/*
* 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 ) )
3001dcd0: e3550008 cmp r5, #8 3001dcd4: 13550004 cmpne r5, #4
3001dcd8: 0a000034 beq 3001ddb0 <killinfo+0x134>
3001dcdc: e355000b cmp r5, #11
3001dce0: 0a000032 beq 3001ddb0 <killinfo+0x134>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3001dce4: e3a03001 mov r3, #1
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
3001dce8: e3580000 cmp r8, #0
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
3001dcec: e58d3004 str r3, [sp, #4] 3001dcf0: e1a04413 lsl r4, r3, r4
if ( !value ) {
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
3001dcf4: 15983000 ldrne r3, [r8]
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
3001dcf8: e58d5000 str r5, [sp]
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
3001dcfc: 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;
3001dd00: e59f3220 ldr r3, [pc, #544] ; 3001df28 <killinfo+0x2ac>
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
3001dd04: 058d8008 streq r8, [sp, #8] 3001dd08: e5932000 ldr r2, [r3]
++level;
3001dd0c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3001dd10: 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 );
3001dd14: e59f0210 ldr r0, [pc, #528] ; 3001df2c <killinfo+0x2b0> 3001dd18: ebffb523 bl 3000b1ac <_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;
3001dd1c: e59f320c ldr r3, [pc, #524] ; 3001df30 <killinfo+0x2b4> 3001dd20: e5930008 ldr r0, [r3, #8]
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
3001dd24: e59030f4 ldr r3, [r0, #244] ; 0xf4 3001dd28: e59330d0 ldr r3, [r3, #208] ; 0xd0 3001dd2c: e1d43003 bics r3, r4, r3
3001dd30: 1a00000e bne 3001dd70 <killinfo+0xf4>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3001dd34: e59f11f8 ldr r1, [pc, #504] ; 3001df34 <killinfo+0x2b8> 3001dd38: e4910004 ldr r0, [r1], #4
/* 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 );
3001dd3c: e1500001 cmp r0, r1
3001dd40: 1a000006 bne 3001dd60 <killinfo+0xe4>
3001dd44: ea00002a b 3001ddf4 <killinfo+0x178>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
3001dd48: e59230d0 ldr r3, [r2, #208] ; 0xd0 <== NOT EXECUTED 3001dd4c: e1d43003 bics r3, r4, r3 <== NOT EXECUTED 3001dd50: 1a000006 bne 3001dd70 <killinfo+0xf4> <== 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 ) {
3001dd54: 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 );
3001dd58: e1500001 cmp r0, r1 <== NOT EXECUTED 3001dd5c: 0a000024 beq 3001ddf4 <killinfo+0x178> <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
3001dd60: e5903030 ldr r3, [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 ];
3001dd64: 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)
3001dd68: e1140003 tst r4, r3 <== NOT EXECUTED 3001dd6c: 0afffff5 beq 3001dd48 <killinfo+0xcc> <== NOT EXECUTED
/*
* 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 ) ) {
3001dd70: e1a01005 mov r1, r5 <== NOT EXECUTED 3001dd74: e1a0200d mov r2, sp <== NOT EXECUTED 3001dd78: eb00007d bl 3001df74 <_POSIX_signals_Unblock_thread> <== NOT EXECUTED 3001dd7c: e3500000 cmp r0, #0 <== NOT EXECUTED 3001dd80: 1a000006 bne 3001dda0 <killinfo+0x124> <== 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 );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
3001dd84: e0875005 add r5, r7, r5
/*
* 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 );
3001dd88: e1a00004 mov r0, r4
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
3001dd8c: e1a05105 lsl r5, r5, #2
/*
* 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 );
3001dd90: eb00006d bl 3001df4c <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
3001dd94: e7963005 ldr r3, [r6, r5] 3001dd98: e3530002 cmp r3, #2
3001dd9c: 0a000007 beq 3001ddc0 <killinfo+0x144>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
3001dda0: ebffbce4 bl 3000d138 <_Thread_Enable_dispatch>
return 0;
3001dda4: e3a00000 mov r0, #0
}
3001dda8: e28dd00c add sp, sp, #12
3001ddac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* 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 ) )
return pthread_kill( pthread_self(), sig );
3001ddb0: eb0000f2 bl 3001e180 <pthread_self> <== NOT EXECUTED 3001ddb4: e1a01005 mov r1, r5 <== NOT EXECUTED 3001ddb8: eb0000b7 bl 3001e09c <pthread_kill> <== NOT EXECUTED 3001ddbc: eafffff9 b 3001dda8 <killinfo+0x12c> <== NOT EXECUTED
*/
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
3001ddc0: e59f0170 ldr r0, [pc, #368] ; 3001df38 <killinfo+0x2bc> <== NOT EXECUTED 3001ddc4: ebffb560 bl 3000b34c <_Chain_Get> <== NOT EXECUTED
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
3001ddc8: e250c000 subs ip, r0, #0 <== NOT EXECUTED 3001ddcc: 0a00004e beq 3001df0c <killinfo+0x290> <== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
3001ddd0: e28c3008 add r3, ip, #8 <== NOT EXECUTED
3001ddd4: e28de00c add lr, sp, #12 <== NOT EXECUTED
3001ddd8: e91e0007 ldmdb lr, {r0, r1, r2} <== NOT EXECUTED
3001dddc: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
3001dde0: e59f0154 ldr r0, [pc, #340] ; 3001df3c <killinfo+0x2c0> <== NOT EXECUTED 3001dde4: e1a0100c mov r1, ip <== NOT EXECUTED 3001dde8: e0800005 add r0, r0, r5 <== NOT EXECUTED 3001ddec: ebffb54b bl 3000b320 <_Chain_Append> <== NOT EXECUTED 3001ddf0: eaffffea b 3001dda0 <killinfo+0x124> <== NOT EXECUTED
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
3001ddf4: e59f3144 ldr r3, [pc, #324] ; 3001df40 <killinfo+0x2c4> 3001ddf8: e59fa144 ldr sl, [pc, #324] ; 3001df44 <killinfo+0x2c8> 3001ddfc: e5d3e000 ldrb lr, [r3]
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
3001de00: e3a00000 mov r0, #0
interested_priority = PRIORITY_MAXIMUM + 1;
3001de04: e28ee001 add lr, lr, #1
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 ] )
3001de08: e5ba3004 ldr r3, [sl, #4]! 3001de0c: e3530000 cmp r3, #0
3001de10: 0a000022 beq 3001dea0 <killinfo+0x224>
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
3001de14: e5933004 ldr r3, [r3, #4]
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
3001de18: e1d381b0 ldrh r8, [r3, #16]
object_table = the_info->local_table;
3001de1c: e593101c ldr r1, [r3, #28]
for ( index = 1 ; index <= maximum ; index++ ) {
3001de20: e3580000 cmp r8, #0
3001de24: 0a00001d beq 3001dea0 <killinfo+0x224>
3001de28: e3a02001 mov r2, #1
the_thread = (Thread_Control *) object_table[ index ];
3001de2c: e5b13004 ldr r3, [r1, #4]!
if ( !the_thread )
3001de30: e3530000 cmp r3, #0
3001de34: 0a000016 beq 3001de94 <killinfo+0x218>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
3001de38: e593c014 ldr ip, [r3, #20] 3001de3c: e15c000e cmp ip, lr
3001de40: 8a000013 bhi 3001de94 <killinfo+0x218>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
3001de44: e59390f4 ldr r9, [r3, #244] ; 0xf4 3001de48: e59990d0 ldr r9, [r9, #208] ; 0xd0 3001de4c: e1d49009 bics r9, r4, r9
3001de50: 0a00000f beq 3001de94 <killinfo+0x218>
*
* 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 ) {
3001de54: e15c000e cmp ip, lr <== NOT EXECUTED 3001de58: 3a00001b bcc 3001decc <killinfo+0x250> <== 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 ) ) {
3001de5c: e3500000 cmp r0, #0 <== NOT EXECUTED 3001de60: 0a00000b beq 3001de94 <killinfo+0x218> <== NOT EXECUTED 3001de64: e5909010 ldr r9, [r0, #16] <== NOT EXECUTED 3001de68: e3590000 cmp r9, #0 <== NOT EXECUTED 3001de6c: 0a000008 beq 3001de94 <killinfo+0x218> <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
3001de70: e593b010 ldr fp, [r3, #16] <== NOT EXECUTED 3001de74: e35b0000 cmp fp, #0 <== NOT EXECUTED 3001de78: 0a000013 beq 3001decc <killinfo+0x250> <== NOT EXECUTED
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
3001de7c: e3190201 tst r9, #268435456 ; 0x10000000 <== NOT EXECUTED 3001de80: 1a000003 bne 3001de94 <killinfo+0x218> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
3001de84: e20bb201 and fp, fp, #268435456 ; 0x10000000 <== NOT EXECUTED
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
3001de88: e35b0000 cmp fp, #0 <== NOT EXECUTED 3001de8c: 11a0e00c movne lr, ip <== NOT EXECUTED 3001de90: 11a00003 movne r0, r3 <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
3001de94: e2822001 add r2, r2, #1 3001de98: e1580002 cmp r8, r2
3001de9c: 2affffe2 bcs 3001de2c <killinfo+0x1b0>
* + 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++) {
3001dea0: e59f30a0 ldr r3, [pc, #160] ; 3001df48 <killinfo+0x2cc> 3001dea4: e15a0003 cmp sl, r3
3001dea8: 1affffd6 bne 3001de08 <killinfo+0x18c>
}
}
}
}
if ( interested ) {
3001deac: e3500000 cmp r0, #0
3001deb0: 0affffb3 beq 3001dd84 <killinfo+0x108>
/*
* 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 ) ) {
3001deb4: e1a01005 mov r1, r5 <== NOT EXECUTED 3001deb8: e1a0200d mov r2, sp <== NOT EXECUTED 3001debc: eb00002c bl 3001df74 <_POSIX_signals_Unblock_thread> <== NOT EXECUTED 3001dec0: e3500000 cmp r0, #0 <== NOT EXECUTED 3001dec4: 0affffae beq 3001dd84 <killinfo+0x108> <== NOT EXECUTED 3001dec8: eaffffb4 b 3001dda0 <killinfo+0x124> <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
3001decc: e2822001 add r2, r2, #1 <== NOT EXECUTED 3001ded0: e1580002 cmp r8, r2 <== 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 ) ) {
3001ded4: e1a0e00c mov lr, ip <== NOT EXECUTED 3001ded8: e1a00003 mov r0, r3 <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
3001dedc: 2affffd2 bcs 3001de2c <killinfo+0x1b0> <== NOT EXECUTED 3001dee0: eaffffee b 3001dea0 <killinfo+0x224> <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
3001dee4: ebffd25f bl 30012868 <__errno> <== NOT EXECUTED 3001dee8: e3a03003 mov r3, #3 <== NOT EXECUTED 3001deec: e5803000 str r3, [r0] <== NOT EXECUTED 3001def0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3001def4: eaffffab b 3001dda8 <killinfo+0x12c> <== NOT EXECUTED
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
3001def8: ebffd25a bl 30012868 <__errno> <== NOT EXECUTED 3001defc: e3a03016 mov r3, #22 <== NOT EXECUTED 3001df00: e5803000 str r3, [r0] <== NOT EXECUTED 3001df04: e3e00000 mvn r0, #0 <== NOT EXECUTED 3001df08: eaffffa6 b 3001dda8 <killinfo+0x12c> <== NOT EXECUTED
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
_Thread_Enable_dispatch();
3001df0c: ebffbc89 bl 3000d138 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
3001df10: ebffd254 bl 30012868 <__errno> <== NOT EXECUTED 3001df14: e3a0300b mov r3, #11 <== NOT EXECUTED 3001df18: e5803000 str r3, [r0] <== NOT EXECUTED 3001df1c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3001df20: eaffffa0 b 3001dda8 <killinfo+0x12c> <== NOT EXECUTED
3000a450 <lio_listio>:
int mode __attribute__((unused)),
struct aiocb * const list[] __attribute__((unused)),
int nent __attribute__((unused)),
struct sigevent *sig __attribute__((unused))
)
{
3000a450: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a454: eb0022b1 bl 30012f20 <__errno> <== NOT EXECUTED 3000a458: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a45c: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a460: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a464: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a468 <mprotect>:
const void *addr __attribute__((unused)),
size_t len __attribute__((unused)),
int prot __attribute__((unused)) )
{
return 0;
}
3000a468: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a46c: e12fff1e bx lr <== NOT EXECUTED
3000fb3c <mq_close>:
*/
int mq_close(
mqd_t mqdes
)
{
3000fb3c: e92d4030 push {r4, r5, lr}
3000fb40: e24dd004 sub sp, sp, #4
3000fb44: 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(
3000fb48: e1a0200d mov r2, sp 3000fb4c: e59f0064 ldr r0, [pc, #100] ; 3000fbb8 <mq_close+0x7c> 3000fb50: eb000ddf bl 300132d4 <_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 ) {
3000fb54: e59d5000 ldr r5, [sp] 3000fb58: e1a04000 mov r4, r0 3000fb5c: e3550000 cmp r5, #0
3000fb60: 1a00000f bne 3000fba4 <mq_close+0x68>
* 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;
3000fb64: e5903010 ldr r3, [r0, #16]
the_mq->open_count -= 1;
3000fb68: e5932018 ldr r2, [r3, #24]
_POSIX_Message_queue_Delete( the_mq );
3000fb6c: e1a00003 mov r0, r3
* being disassociated. This may result in the queue being really
* deleted.
*/
the_mq = the_mq_fd->Queue;
the_mq->open_count -= 1;
3000fb70: e2422001 sub r2, r2, #1 3000fb74: e5832018 str r2, [r3, #24]
_POSIX_Message_queue_Delete( the_mq );
3000fb78: eb00000f bl 3000fbbc <_POSIX_Message_queue_Delete>
/*
* Now close this file descriptor.
*/
_Objects_Close(
3000fb7c: e59f0034 ldr r0, [pc, #52] ; 3000fbb8 <mq_close+0x7c> 3000fb80: e1a01004 mov r1, r4 3000fb84: eb000cc0 bl 30012e8c <_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 );
3000fb88: e59f0028 ldr r0, [pc, #40] ; 3000fbb8 <mq_close+0x7c> 3000fb8c: e1a01004 mov r1, r4 3000fb90: eb000d78 bl 30013178 <_Objects_Free>
&_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000fb94: eb001198 bl 300141fc <_Thread_Enable_dispatch>
return 0;
3000fb98: e1a00005 mov r0, r5
/*
* OBJECTS_REMOTE:
* OBJECTS_ERROR:
*/
rtems_set_errno_and_return_minus_one( EBADF );
}
3000fb9c: e28dd004 add sp, sp, #4
3000fba0: e8bd8030 pop {r4, r5, pc}
/*
* OBJECTS_REMOTE:
* OBJECTS_ERROR:
*/
rtems_set_errno_and_return_minus_one( EBADF );
3000fba4: eb002945 bl 3001a0c0 <__errno> <== NOT EXECUTED 3000fba8: e3a03009 mov r3, #9 <== NOT EXECUTED 3000fbac: e5803000 str r3, [r0] <== NOT EXECUTED 3000fbb0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000fbb4: eafffff8 b 3000fb9c <mq_close+0x60> <== NOT EXECUTED
3000fc0c <mq_getattr>:
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
3000fc0c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
if ( !mqstat )
3000fc10: e2514000 subs r4, r1, #0 <== NOT EXECUTED
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
3000fc14: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000fc18: e1a01000 mov r1, r0 <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
if ( !mqstat )
3000fc1c: 0a000017 beq 3000fc80 <mq_getattr+0x74> <== 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(
3000fc20: e59f006c ldr r0, [pc, #108] ; 3000fc94 <mq_getattr+0x88> <== NOT EXECUTED 3000fc24: e1a0200d mov r2, sp <== NOT EXECUTED 3000fc28: eb000da9 bl 300132d4 <_Objects_Get> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000fc2c: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000fc30: e3550000 cmp r5, #0 <== NOT EXECUTED 3000fc34: 1a00000c bne 3000fc6c <mq_getattr+0x60> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
3000fc38: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
/*
* Return the old values.
*/
mqstat->mq_flags = the_mq_fd->oflag;
3000fc3c: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
3000fc40: e5931068 ldr r1, [r3, #104] ; 0x68 <== NOT EXECUTED
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
3000fc44: e5932060 ldr r2, [r3, #96] ; 0x60 <== NOT EXECUTED
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
3000fc48: e5933064 ldr r3, [r3, #100] ; 0x64 <== NOT EXECUTED
the_mq = the_mq_fd->Queue;
/*
* Return the old values.
*/
mqstat->mq_flags = the_mq_fd->oflag;
3000fc4c: e5840000 str r0, [r4] <== NOT EXECUTED
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
3000fc50: e5841008 str r1, [r4, #8] <== NOT EXECUTED
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
3000fc54: e5842004 str r2, [r4, #4] <== NOT EXECUTED
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
3000fc58: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000fc5c: eb001166 bl 300141fc <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000fc60: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
3000fc64: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000fc68: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000fc6c: eb002913 bl 3001a0c0 <__errno> <== NOT EXECUTED 3000fc70: e3a03009 mov r3, #9 <== NOT EXECUTED 3000fc74: e5803000 str r3, [r0] <== NOT EXECUTED 3000fc78: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000fc7c: eafffff8 b 3000fc64 <mq_getattr+0x58> <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
if ( !mqstat )
rtems_set_errno_and_return_minus_one( EINVAL );
3000fc80: eb00290e bl 3001a0c0 <__errno> <== NOT EXECUTED 3000fc84: e3a03016 mov r3, #22 <== NOT EXECUTED 3000fc88: e5803000 str r3, [r0] <== NOT EXECUTED 3000fc8c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000fc90: eafffff3 b 3000fc64 <mq_getattr+0x58> <== NOT EXECUTED
3000fcbc <mq_notify>:
int mq_notify(
mqd_t mqdes,
const struct sigevent *notification
)
{
3000fcbc: e92d4030 push {r4, r5, lr}
3000fcc0: e1a03000 mov r3, r0
3000fcc4: e24dd004 sub sp, sp, #4
3000fcc8: e1a05001 mov r5, r1
3000fccc: e59f0098 ldr r0, [pc, #152] ; 3000fd6c <mq_notify+0xb0>
3000fcd0: e1a01003 mov r1, r3
3000fcd4: e1a0200d mov r2, sp
3000fcd8: eb000d7d bl 300132d4 <_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 ) {
3000fcdc: e59d3000 ldr r3, [sp] 3000fce0: e3530000 cmp r3, #0
3000fce4: 0a000005 beq 3000fd00 <mq_notify+0x44>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000fce8: eb0028f4 bl 3001a0c0 <__errno> <== NOT EXECUTED 3000fcec: e3a03009 mov r3, #9 <== NOT EXECUTED 3000fcf0: e5803000 str r3, [r0] <== NOT EXECUTED 3000fcf4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000fcf8: e28dd004 add sp, sp, #4
3000fcfc: e8bd8030 pop {r4, r5, pc}
switch ( location ) {
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
if ( notification ) {
3000fd00: e3550000 cmp r5, #0
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
3000fd04: e5904010 ldr r4, [r0, #16]
if ( notification ) {
3000fd08: 0a00000e beq 3000fd48 <mq_notify+0x8c>
if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {
3000fd0c: e594307c ldr r3, [r4, #124] ; 0x7c 3000fd10: e3530000 cmp r3, #0
3000fd14: 1a00000e bne 3000fd54 <mq_notify+0x98>
rtems_set_errno_and_return_minus_one( EBUSY );
}
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
the_mq->notification = *notification;
3000fd18: e284c090 add ip, r4, #144 ; 0x90
3000fd1c: e1a0e005 mov lr, r5
3000fd20: e8be000f ldm lr!, {r0, r1, r2, r3}
3000fd24: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000fd28: e59e3000 ldr r3, [lr]
3000fd2c: e58c3000 str r3, [ip]
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
3000fd30: e59f3038 ldr r3, [pc, #56] ; 3000fd70 <mq_notify+0xb4>
the_message_queue->notify_argument = the_argument;
3000fd34: e5844080 str r4, [r4, #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;
3000fd38: e584307c str r3, [r4, #124] ; 0x7c
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
}
_Thread_Enable_dispatch();
3000fd3c: eb00112e bl 300141fc <_Thread_Enable_dispatch>
return 0;
3000fd40: e3a00000 mov r0, #0 3000fd44: eaffffeb b 3000fcf8 <mq_notify+0x3c>
3000fd48: e584507c str r5, [r4, #124] ; 0x7c <== NOT EXECUTED
the_message_queue->notify_argument = the_argument;
3000fd4c: e5845080 str r5, [r4, #128] ; 0x80 <== NOT EXECUTED 3000fd50: eafffff9 b 3000fd3c <mq_notify+0x80> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
if ( notification ) {
if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {
_Thread_Enable_dispatch();
3000fd54: eb001128 bl 300141fc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
3000fd58: eb0028d8 bl 3001a0c0 <__errno> <== NOT EXECUTED 3000fd5c: e3a03010 mov r3, #16 <== NOT EXECUTED 3000fd60: e5803000 str r3, [r0] <== NOT EXECUTED 3000fd64: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000fd68: eaffffe2 b 3000fcf8 <mq_notify+0x3c> <== NOT EXECUTED
3000ab74 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
3000ab74: e92d000e push {r1, r2, r3}
3000ab78: 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;
3000ab7c: e59f318c ldr r3, [pc, #396] ; 3000ad10 <mq_open+0x19c> 3000ab80: e24dd018 sub sp, sp, #24 3000ab84: e5932000 ldr r2, [r3] 3000ab88: e59d4038 ldr r4, [sp, #56] ; 0x38
++level;
3000ab8c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000ab90: e5832000 str r2, [r3] 3000ab94: e1a08000 mov r8, r0
*/
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
3000ab98: e59f6174 ldr r6, [pc, #372] ; 3000ad14 <mq_open+0x1a0>
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
3000ab9c: e2147c02 ands r7, r4, #512 ; 0x200
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
attr = va_arg( arg, struct mq_attr * );
3000aba0: 128d3044 addne r3, sp, #68 ; 0x44 3000aba4: e1a00006 mov r0, r6 3000aba8: 158d3004 strne r3, [sp, #4] 3000abac: 159d9040 ldrne r9, [sp, #64] ; 0x40
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
3000abb0: 01a09007 moveq r9, r7 3000abb4: eb000b80 bl 3000d9bc <_Objects_Allocate>
attr = va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
3000abb8: e2505000 subs r5, r0, #0
3000abbc: 0a000029 beq 3000ac68 <mq_open+0xf4>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
3000abc0: e5854014 str r4, [r5, #20]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Message_queue_Information, name, id, len );
3000abc4: e59f014c ldr r0, [pc, #332] ; 3000ad18 <mq_open+0x1a4> 3000abc8: e1a01008 mov r1, r8 3000abcc: e28d2008 add r2, sp, #8 3000abd0: e28d3014 add r3, sp, #20 3000abd4: eb000129 bl 3000b080 <_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 ) {
3000abd8: e250a000 subs sl, r0, #0
3000abdc: 1a000017 bne 3000ac40 <mq_open+0xcc>
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
3000abe0: e2044c0a and r4, r4, #2560 ; 0xa00 3000abe4: e3540c0a cmp r4, #2560 ; 0xa00
3000abe8: 0a000024 beq 3000ac80 <mq_open+0x10c>
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
3000abec: e59d1008 ldr r1, [sp, #8] 3000abf0: e28d2010 add r2, sp, #16 3000abf4: e59f011c ldr r0, [pc, #284] ; 3000ad18 <mq_open+0x1a4> 3000abf8: eb000ca4 bl 3000de90 <_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;
3000abfc: e5901018 ldr r1, [r0, #24]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ac00: e596301c ldr r3, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
3000ac04: e1d520b8 ldrh r2, [r5, #8] 3000ac08: e2811001 add r1, r1, #1 3000ac0c: e5801018 str r1, [r0, #24]
/*
* 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 );
3000ac10: e58d000c str r0, [sp, #12]
the_mq->open_count += 1;
the_mq_fd->Queue = the_mq;
3000ac14: e5850010 str r0, [r5, #16]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ac18: e7835102 str r5, [r3, r2, lsl #2]
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
3000ac1c: e585a00c str sl, [r5, #12]
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
3000ac20: eb001078 bl 3000ee08 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
3000ac24: eb001077 bl 3000ee08 <_Thread_Enable_dispatch>
return (mqd_t)the_mq_fd->Object.id;
3000ac28: e5954008 ldr r4, [r5, #8]
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
3000ac2c: e1a00004 mov r0, r4
3000ac30: e28dd018 add sp, sp, #24
3000ac34: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
3000ac38: e28dd00c add sp, sp, #12
3000ac3c: e12fff1e bx lr
if ( status ) {
/*
* 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) ) ) {
3000ac40: e35a0002 cmp sl, #2
3000ac44: 0a000016 beq 3000aca4 <mq_open+0x130>
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 );
3000ac48: e59f00c4 ldr r0, [pc, #196] ; 3000ad14 <mq_open+0x1a0> <== NOT EXECUTED 3000ac4c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ac50: eb000c37 bl 3000dd34 <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000ac54: eb00106b bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
3000ac58: eb0026cc bl 30014790 <__errno> <== NOT EXECUTED 3000ac5c: e3e04000 mvn r4, #0 <== NOT EXECUTED 3000ac60: e580a000 str sl, [r0] <== NOT EXECUTED 3000ac64: eafffff0 b 3000ac2c <mq_open+0xb8> <== NOT EXECUTED
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
_Thread_Enable_dispatch();
3000ac68: eb001066 bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
3000ac6c: eb0026c7 bl 30014790 <__errno> <== NOT EXECUTED 3000ac70: e3a03017 mov r3, #23 <== NOT EXECUTED 3000ac74: e5803000 str r3, [r0] <== NOT EXECUTED 3000ac78: e3e04000 mvn r4, #0 <== NOT EXECUTED 3000ac7c: eaffffea b 3000ac2c <mq_open+0xb8> <== NOT EXECUTED 3000ac80: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ac84: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ac88: eb000c29 bl 3000dd34 <_Objects_Free> <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000ac8c: eb00105d bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
3000ac90: eb0026be bl 30014790 <__errno> <== NOT EXECUTED 3000ac94: e3a03011 mov r3, #17 <== NOT EXECUTED 3000ac98: e5803000 str r3, [r0] <== NOT EXECUTED 3000ac9c: e3e04000 mvn r4, #0 <== NOT EXECUTED 3000aca0: eaffffe1 b 3000ac2c <mq_open+0xb8> <== NOT EXECUTED
if ( status ) {
/*
* 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) ) ) {
3000aca4: e3570000 cmp r7, #0
3000aca8: 0affffe6 beq 3000ac48 <mq_open+0xd4>
/*
* 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(
3000acac: e28dc00c add ip, sp, #12 3000acb0: e1a00008 mov r0, r8 3000acb4: e59d1014 ldr r1, [sp, #20] 3000acb8: e3a02001 mov r2, #1 3000acbc: e1a03009 mov r3, r9 3000acc0: e58dc000 str ip, [sp] 3000acc4: eb001a9a bl 30011734 <_POSIX_Message_queue_Create_support>
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
3000acc8: 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(
3000accc: e1a04000 mov r4, r0
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
3000acd0: 0a000009 beq 3000acfc <mq_open+0x188>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000acd4: e596301c ldr r3, [r6, #28]
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
return (mqd_t) -1;
}
the_mq_fd->Queue = the_mq;
3000acd8: e59d100c ldr r1, [sp, #12]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
3000acdc: e1d520b8 ldrh r2, [r5, #8] 3000ace0: e5851010 str r1, [r5, #16]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ace4: e7835102 str r5, [r3, r2, lsl #2]
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
3000ace8: e3a03000 mov r3, #0 3000acec: e585300c str r3, [r5, #12]
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
3000acf0: eb001044 bl 3000ee08 <_Thread_Enable_dispatch>
return (mqd_t) the_mq_fd->Object.id;
3000acf4: e5954008 ldr r4, [r5, #8] 3000acf8: eaffffcb b 3000ac2c <mq_open+0xb8>
3000acfc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ad00: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ad04: eb000c0a bl 3000dd34 <_Objects_Free> <== NOT EXECUTED
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000ad08: eb00103e bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
return (mqd_t) -1;
3000ad0c: eaffffc6 b 3000ac2c <mq_open+0xb8> <== NOT EXECUTED
300101c0 <mq_setattr>:
int mq_setattr(
mqd_t mqdes,
const struct mq_attr *mqstat,
struct mq_attr *omqstat
)
{
300101c0: e92d4030 push {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 )
300101c4: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int mq_setattr(
mqd_t mqdes,
const struct mq_attr *mqstat,
struct mq_attr *omqstat
)
{
300101c8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 300101cc: e1a01000 mov r1, r0 <== NOT EXECUTED 300101d0: 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 )
300101d4: 0a00001b beq 30010248 <mq_setattr+0x88> <== 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(
300101d8: e59f007c ldr r0, [pc, #124] ; 3001025c <mq_setattr+0x9c> <== NOT EXECUTED 300101dc: e1a0200d mov r2, sp <== NOT EXECUTED 300101e0: eb000c3b bl 300132d4 <_Objects_Get> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
300101e4: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300101e8: e3530000 cmp r3, #0 <== NOT EXECUTED 300101ec: 1a000010 bne 30010234 <mq_setattr+0x74> <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
300101f0: 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;
300101f4: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
300101f8: 0a000007 beq 3001021c <mq_setattr+0x5c> <== NOT EXECUTED
omqstat->mq_flags = the_mq_fd->oflag;
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
300101fc: e5931068 ldr r1, [r3, #104] ; 0x68 <== NOT EXECUTED
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
30010200: e5932060 ldr r2, [r3, #96] ; 0x60 <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
omqstat->mq_flags = the_mq_fd->oflag;
30010204: e590c014 ldr ip, [r0, #20] <== NOT EXECUTED
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages;
30010208: e5933064 ldr r3, [r3, #100] ; 0x64 <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
omqstat->mq_flags = the_mq_fd->oflag;
3001020c: e584c000 str ip, [r4] <== NOT EXECUTED
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
30010210: e5841008 str r1, [r4, #8] <== NOT EXECUTED
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
30010214: e5842004 str r2, [r4, #4] <== NOT EXECUTED
omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages;
30010218: e584300c str r3, [r4, #12] <== NOT EXECUTED
}
the_mq_fd->oflag = mqstat->mq_flags;
3001021c: e5953000 ldr r3, [r5] <== NOT EXECUTED 30010220: e5803014 str r3, [r0, #20] <== NOT EXECUTED
_Thread_Enable_dispatch();
30010224: eb000ff4 bl 300141fc <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30010228: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
3001022c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30010230: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
30010234: eb0027a1 bl 3001a0c0 <__errno> <== NOT EXECUTED 30010238: e3a03009 mov r3, #9 <== NOT EXECUTED 3001023c: e5803000 str r3, [r0] <== NOT EXECUTED 30010240: e3e00000 mvn r0, #0 <== NOT EXECUTED 30010244: eafffff8 b 3001022c <mq_setattr+0x6c> <== NOT EXECUTED
POSIX_Message_queue_Control_fd *the_mq_fd;
CORE_message_queue_Control *the_core_mq;
Objects_Locations location;
if ( !mqstat )
rtems_set_errno_and_return_minus_one( EINVAL );
30010248: eb00279c bl 3001a0c0 <__errno> <== NOT EXECUTED 3001024c: e3a03016 mov r3, #22 <== NOT EXECUTED 30010250: e5803000 str r3, [r0] <== NOT EXECUTED 30010254: e3e00000 mvn r0, #0 <== NOT EXECUTED 30010258: eafffff3 b 3001022c <mq_setattr+0x6c> <== NOT EXECUTED
30010320 <mq_unlink>:
*/
int mq_unlink(
const char *name
)
{
30010320: e92d4030 push {r4, r5, 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;
30010324: e59f3078 ldr r3, [pc, #120] ; 300103a4 <mq_unlink+0x84> 30010328: e24dd008 sub sp, sp, #8 3001032c: e5932000 ldr r2, [r3] 30010330: e1a01000 mov r1, r0
++level;
30010334: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
30010338: 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 );
3001033c: e59f4064 ldr r4, [pc, #100] ; 300103a8 <mq_unlink+0x88> 30010340: e1a0200d mov r2, sp 30010344: e1a00004 mov r0, r4 30010348: e28d3004 add r3, sp, #4 3001034c: eb000044 bl 30010464 <_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 ) {
30010350: e2505000 subs r5, r0, #0
30010354: 1a00000d bne 30010390 <mq_unlink+0x70>
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
30010358: e594301c ldr r3, [r4, #28] 3001035c: e1dd20b0 ldrh r2, [sp]
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Namespace_remove (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Namespace_remove(
30010360: e1a00004 mov r0, r4 30010364: e7934102 ldr r4, [r3, r2, lsl #2] 30010368: e1a01004 mov r1, r4
the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object(
&_POSIX_Message_queue_Information,
_Objects_Get_index( the_mq_id )
);
the_mq->linked = false;
3001036c: e5c45015 strb r5, [r4, #21] 30010370: eb000c2b bl 30013424 <_Objects_Namespace_remove>
_POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq );
30010374: e1a00004 mov r0, r4 30010378: ebfffe0f bl 3000fbbc <_POSIX_Message_queue_Delete>
_Thread_Enable_dispatch();
3001037c: eb000f9e bl 300141fc <_Thread_Enable_dispatch>
return 0;
30010380: e1a03005 mov r3, r5
}
30010384: e1a00003 mov r0, r3
30010388: e28dd008 add sp, sp, #8
3001038c: e8bd8030 pop {r4, r5, pc}
_Thread_Disable_dispatch();
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id, &name_len );
if ( status != 0 ) {
_Thread_Enable_dispatch();
30010390: eb000f99 bl 300141fc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( status );
30010394: eb002749 bl 3001a0c0 <__errno> <== NOT EXECUTED 30010398: e3e03000 mvn r3, #0 <== NOT EXECUTED 3001039c: e5805000 str r5, [r0] <== NOT EXECUTED 300103a0: eafffff7 b 30010384 <mq_unlink+0x64> <== NOT EXECUTED
3002d030 <nanosleep>:
int nanosleep(
const struct timespec *rqtp,
struct timespec *rmtp
)
{
3002d030: e92d4070 push {r4, r5, r6, lr}
3002d034: e1a05000 mov r5, r0
3002d038: 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 ) )
3002d03c: eb000053 bl 3002d190 <_Timespec_Is_valid> 3002d040: e3500000 cmp r0, #0
3002d044: 0a000031 beq 3002d110 <nanosleep+0xe0>
rtems_set_errno_and_return_minus_one( EINVAL );
ticks = _Timespec_To_ticks( rqtp );
3002d048: e1a00005 mov r0, r5 3002d04c: ebffb298 bl 30019ab4 <_Timespec_To_ticks>
*
* 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;
3002d050: e59f30e0 ldr r3, [pc, #224] ; 3002d138 <nanosleep+0x108> 3002d054: e5932000 ldr r2, [r3]
++level;
3002d058: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3002d05c: e5832000 str r2, [r3]
* 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 ) {
3002d060: e2505000 subs r5, r0, #0
3002d064: 0a00001e beq 3002d0e4 <nanosleep+0xb4>
/*
* Block for the desired amount of time
*/
_Thread_Disable_dispatch();
_Thread_Set_state(
3002d068: e59f60cc ldr r6, [pc, #204] ; 3002d13c <nanosleep+0x10c> 3002d06c: e3a01281 mov r1, #268435464 ; 0x10000008 3002d070: e5960008 ldr r0, [r6, #8] 3002d074: ebff9927 bl 30013518 <_Thread_Set_state>
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3002d078: e5963008 ldr r3, [r6, #8]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3002d07c: e59fe0bc ldr lr, [pc, #188] ; 3002d140 <nanosleep+0x110>
_Thread_Disable_dispatch();
_Thread_Set_state(
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
3002d080: e593c008 ldr ip, [r3, #8]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3002d084: e3a02000 mov r2, #0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3002d088: e59f00b4 ldr r0, [pc, #180] ; 3002d144 <nanosleep+0x114> 3002d08c: e2831048 add r1, r3, #72 ; 0x48
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3002d090: e5832050 str r2, [r3, #80] ; 0x50
the_watchdog->routine = routine;
3002d094: e583e064 str lr, [r3, #100] ; 0x64
the_watchdog->id = id;
3002d098: e583c068 str ip, [r3, #104] ; 0x68
the_watchdog->user_data = user_data;
3002d09c: e583206c str r2, [r3, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3002d0a0: e5835054 str r5, [r3, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3002d0a4: ebff9a18 bl 3001390c <_Watchdog_Insert>
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
_Thread_Enable_dispatch();
3002d0a8: ebff96ee bl 30012c68 <_Thread_Enable_dispatch>
/* calculate time remaining */
if ( rmtp ) {
3002d0ac: e3540000 cmp r4, #0 <== NOT EXECUTED 3002d0b0: 0a000014 beq 3002d108 <nanosleep+0xd8> <== NOT EXECUTED
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
3002d0b4: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
_Timespec_From_ticks( ticks, rmtp );
3002d0b8: e1a01004 mov r1, r4 <== NOT EXECUTED
/* calculate time remaining */
if ( rmtp ) {
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
3002d0bc: e593405c ldr r4, [r3, #92] ; 0x5c <== NOT EXECUTED 3002d0c0: e5933060 ldr r3, [r3, #96] ; 0x60 <== NOT EXECUTED 3002d0c4: e0634004 rsb r4, r3, r4 <== NOT EXECUTED
_Thread_Enable_dispatch();
/* calculate time remaining */
if ( rmtp ) {
ticks -=
3002d0c8: e0845005 add r5, r4, r5 <== NOT EXECUTED
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
_Timespec_From_ticks( ticks, rmtp );
3002d0cc: e1a00005 mov r0, r5 <== NOT EXECUTED 3002d0d0: eb00001d bl 3002d14c <_Timespec_From_ticks> <== NOT EXECUTED
*/
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
3002d0d4: e3550000 cmp r5, #0 <== NOT EXECUTED 3002d0d8: 1a000011 bne 3002d124 <nanosleep+0xf4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
3002d0dc: e1a00005 mov r0, r5 <== NOT EXECUTED
}
3002d0e0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
3002d0e4: e59f305c ldr r3, [pc, #92] ; 3002d148 <nanosleep+0x118> 3002d0e8: e1a0e00f mov lr, pc 3002d0ec: e593f00c ldr pc, [r3, #12]
*/
if ( !ticks ) {
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
3002d0f0: ebff96dc bl 30012c68 <_Thread_Enable_dispatch>
if ( rmtp ) {
3002d0f4: e3540000 cmp r4, #0
rmtp->tv_sec = 0;
3002d0f8: 15845000 strne r5, [r4]
rmtp->tv_nsec = 0;
3002d0fc: 15845004 strne r5, [r4, #4]
}
return 0;
3002d100: 11a00005 movne r0, r5
if ( !ticks ) {
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
if ( rmtp ) {
3002d104: 18bd8070 popne {r4, r5, r6, pc}
if ( ticks )
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
3002d108: e1a00004 mov r0, r4
3002d10c: e8bd8070 pop {r4, r5, r6, pc}
*
* NOTE: This behavior is beyond the POSIX specification.
* FSU and GNU/Linux pthreads shares this behavior.
*/
if ( !_Timespec_Is_valid( rqtp ) )
rtems_set_errno_and_return_minus_one( EINVAL );
3002d110: ebffbcac bl 3001c3c8 <__errno> <== NOT EXECUTED
3002d114: e3a03016 mov r3, #22 <== NOT EXECUTED
3002d118: e5803000 str r3, [r0] <== NOT EXECUTED
3002d11c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3002d120: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
rtems_set_errno_and_return_minus_one( EINTR );
3002d124: ebffbca7 bl 3001c3c8 <__errno> <== NOT EXECUTED
3002d128: e3a03004 mov r3, #4 <== NOT EXECUTED
3002d12c: e5803000 str r3, [r0] <== NOT EXECUTED
3002d130: e3e00000 mvn r0, #0 <== NOT EXECUTED
3002d134: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000c650 <pause>:
/**
* 3.4.2 Suspend Process Execution, P1003.1b-1993, p. 81
*/
int pause( void )
{
3000c650: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000c654: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
sigset_t all_signals;
int status;
(void) sigfillset( &all_signals );
3000c658: e1a0000d mov r0, sp <== NOT EXECUTED 3000c65c: eb000307 bl 3000d280 <sigfillset> <== NOT EXECUTED
status = sigtimedwait( &all_signals, NULL, NULL );
3000c660: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c664: e1a0000d mov r0, sp <== NOT EXECUTED 3000c668: e1a02001 mov r2, r1 <== NOT EXECUTED 3000c66c: eb000359 bl 3000d3d8 <sigtimedwait> <== NOT EXECUTED
return status;
}
3000c670: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c674: e8bd8000 pop {pc} <== NOT EXECUTED
3000a470 <pthread_atfork>:
int pthread_atfork(
void (*prepare)(void) __attribute__((unused)),
void (*parent)(void) __attribute__((unused)),
void (*child)(void) __attribute__((unused))
)
{
3000a470: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a474: eb0022a9 bl 30012f20 <__errno> <== NOT EXECUTED 3000a478: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a47c: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a480: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a484: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000eb44 <pthread_attr_destroy>:
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000eb44: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000eb48: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000eb4c: 012fff1e bxeq lr <== NOT EXECUTED 3000eb50: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000eb54: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000eb58: 13a00000 movne r0, #0 <== NOT EXECUTED 3000eb5c: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000eb60: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000eb64: e12fff1e bx lr <== NOT EXECUTED
3000eb68 <pthread_attr_getdetachstate>:
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000eb68: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000eb6c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000eb70: 012fff1e bxeq lr <== NOT EXECUTED 3000eb74: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000eb78: e3530000 cmp r3, #0 <== NOT EXECUTED 3000eb7c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*detachstate = attr->detachstate;
3000eb80: 1590203c ldrne r2, [r0, #60] ; 0x3c <== NOT EXECUTED
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000eb84: 13a03000 movne r3, #0 <== NOT EXECUTED 3000eb88: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*detachstate = attr->detachstate;
return 0;
3000eb8c: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !detachstate )
return EINVAL;
*detachstate = attr->detachstate;
3000eb90: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
return EINVAL;
3000eb94: 03a00016 moveq r0, #22 <== NOT EXECUTED
*detachstate = attr->detachstate;
return 0;
}
3000eb98: e12fff1e bx lr <== NOT EXECUTED
3000eb9c <pthread_attr_getguardsize>:
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000eb9c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000eba0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000eba4: 012fff1e bxeq lr <== NOT EXECUTED 3000eba8: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ebac: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ebb0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*guardsize = attr->guardsize;
3000ebb4: 15902034 ldrne r2, [r0, #52] ; 0x34 <== NOT EXECUTED
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000ebb8: 13a03000 movne r3, #0 <== NOT EXECUTED 3000ebbc: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*guardsize = attr->guardsize;
return 0;
3000ebc0: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !guardsize )
return EINVAL;
*guardsize = attr->guardsize;
3000ebc4: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
return EINVAL;
3000ebc8: 03a00016 moveq r0, #22 <== NOT EXECUTED
*guardsize = attr->guardsize;
return 0;
}
3000ebcc: e12fff1e bx lr <== NOT EXECUTED
3000ebd0 <pthread_attr_getinheritsched>:
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000ebd0: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ebd4: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000ebd8: 012fff1e bxeq lr <== NOT EXECUTED 3000ebdc: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ebe0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ebe4: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*inheritsched = attr->inheritsched;
3000ebe8: 15902010 ldrne r2, [r0, #16] <== NOT EXECUTED
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000ebec: 13a03000 movne r3, #0 <== NOT EXECUTED 3000ebf0: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*inheritsched = attr->inheritsched;
return 0;
3000ebf4: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
*inheritsched = attr->inheritsched;
3000ebf8: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
3000ebfc: 03a00016 moveq r0, #22 <== NOT EXECUTED
*inheritsched = attr->inheritsched;
return 0;
}
3000ec00: e12fff1e bx lr <== NOT EXECUTED
3000ec04 <pthread_attr_getschedparam>:
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000ec04: e3500000 cmp r0, #0 <== NOT EXECUTED
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
3000ec08: e92d0030 push {r4, r5} <== NOT EXECUTED
if ( !attr || !attr->is_initialized || !param )
3000ec0c: 0a000005 beq 3000ec28 <pthread_attr_getschedparam+0x24> <== NOT EXECUTED 3000ec10: e5905000 ldr r5, [r0] <== NOT EXECUTED 3000ec14: e3550000 cmp r5, #0 <== NOT EXECUTED 3000ec18: 13510000 cmpne r1, #0 <== NOT EXECUTED 3000ec1c: 13a05000 movne r5, #0 <== NOT EXECUTED 3000ec20: 03a05001 moveq r5, #1 <== NOT EXECUTED 3000ec24: 1a000003 bne 3000ec38 <pthread_attr_getschedparam+0x34> <== NOT EXECUTED
return EINVAL;
3000ec28: e3a05016 mov r5, #22 <== NOT EXECUTED
*param = attr->schedparam;
return 0;
}
3000ec2c: e1a00005 mov r0, r5 <== NOT EXECUTED
3000ec30: e8bd0030 pop {r4, r5} <== NOT EXECUTED
3000ec34: e12fff1e bx lr <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
*param = attr->schedparam;
3000ec38: e1a0c001 mov ip, r1 <== NOT EXECUTED
3000ec3c: e2804018 add r4, r0, #24 <== NOT EXECUTED
3000ec40: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3000ec44: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000ec48: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
3000ec4c: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
return 0;
3000ec50: eafffff5 b 3000ec2c <pthread_attr_getschedparam+0x28> <== NOT EXECUTED
3000ec54 <pthread_attr_getschedpolicy>:
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000ec54: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ec58: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000ec5c: 012fff1e bxeq lr <== NOT EXECUTED 3000ec60: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ec64: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ec68: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*policy = attr->schedpolicy;
3000ec6c: 15902014 ldrne r2, [r0, #20] <== NOT EXECUTED
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000ec70: 13a03000 movne r3, #0 <== NOT EXECUTED 3000ec74: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*policy = attr->schedpolicy;
return 0;
3000ec78: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !policy )
return EINVAL;
*policy = attr->schedpolicy;
3000ec7c: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
return EINVAL;
3000ec80: 03a00016 moveq r0, #22 <== NOT EXECUTED
*policy = attr->schedpolicy;
return 0;
}
3000ec84: e12fff1e bx lr <== NOT EXECUTED
3000ec88 <pthread_attr_getscope>:
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000ec88: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ec8c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000ec90: 012fff1e bxeq lr <== NOT EXECUTED 3000ec94: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ec98: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ec9c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*contentionscope = attr->contentionscope;
3000eca0: 1590200c ldrne r2, [r0, #12] <== NOT EXECUTED
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000eca4: 13a03000 movne r3, #0 <== NOT EXECUTED 3000eca8: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*contentionscope = attr->contentionscope;
return 0;
3000ecac: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
return EINVAL;
*contentionscope = attr->contentionscope;
3000ecb0: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
return EINVAL;
3000ecb4: 03a00016 moveq r0, #22 <== NOT EXECUTED
*contentionscope = attr->contentionscope;
return 0;
}
3000ecb8: e12fff1e bx lr <== NOT EXECUTED
3000ecf0 <pthread_attr_getstack>:
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
3000ecf0: e3500000 cmp r0, #0 <== NOT EXECUTED
int pthread_attr_getstack(
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
3000ecf4: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
3000ecf8: 0a000005 beq 3000ed14 <pthread_attr_getstack+0x24> <== NOT EXECUTED 3000ecfc: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ed00: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ed04: 13510000 cmpne r1, #0 <== NOT EXECUTED 3000ed08: 13a03000 movne r3, #0 <== NOT EXECUTED 3000ed0c: 03a03001 moveq r3, #1 <== NOT EXECUTED 3000ed10: 1a000002 bne 3000ed20 <pthread_attr_getstack+0x30> <== NOT EXECUTED
return EINVAL;
3000ed14: e3a00016 mov r0, #22 <== NOT EXECUTED
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
return 0;
}
3000ed18: e8bd0010 pop {r4} <== NOT EXECUTED
3000ed1c: e12fff1e bx lr <== NOT EXECUTED
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
3000ed20: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ed24: 0afffffa beq 3000ed14 <pthread_attr_getstack+0x24> <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
3000ed28: e9901010 ldmib r0, {r4, ip} <== NOT EXECUTED
return 0;
3000ed2c: e1a00003 mov r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
*stackaddr = attr->stackaddr;
3000ed30: e5814000 str r4, [r1] <== NOT EXECUTED
*stacksize = attr->stacksize;
3000ed34: e582c000 str ip, [r2] <== NOT EXECUTED
return 0;
3000ed38: eafffff6 b 3000ed18 <pthread_attr_getstack+0x28> <== NOT EXECUTED
3000ecbc <pthread_attr_getstackaddr>:
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000ecbc: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ecc0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000ecc4: 012fff1e bxeq lr <== NOT EXECUTED 3000ecc8: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000eccc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ecd0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000ecd4: 15902004 ldrne r2, [r0, #4] <== NOT EXECUTED
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000ecd8: 13a03000 movne r3, #0 <== NOT EXECUTED 3000ecdc: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
return 0;
3000ece0: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
return EINVAL;
*stackaddr = attr->stackaddr;
3000ece4: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
return EINVAL;
3000ece8: 03a00016 moveq r0, #22 <== NOT EXECUTED
*stackaddr = attr->stackaddr;
return 0;
}
3000ecec: e12fff1e bx lr <== NOT EXECUTED
3000ed3c <pthread_attr_getstacksize>:
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000ed3c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ed40: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000ed44: 012fff1e bxeq lr <== NOT EXECUTED 3000ed48: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ed4c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ed50: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*stacksize = attr->stacksize;
3000ed54: 15902008 ldrne r2, [r0, #8] <== NOT EXECUTED
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000ed58: 13a03000 movne r3, #0 <== NOT EXECUTED 3000ed5c: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*stacksize = attr->stacksize;
return 0;
3000ed60: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !stacksize )
return EINVAL;
*stacksize = attr->stacksize;
3000ed64: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
return EINVAL;
3000ed68: 03a00016 moveq r0, #22 <== NOT EXECUTED
*stacksize = attr->stacksize;
return 0;
}
3000ed6c: e12fff1e bx lr <== NOT EXECUTED
3000edb8 <pthread_attr_setdetachstate>:
int pthread_attr_setdetachstate(
pthread_attr_t *attr,
int detachstate
)
{
if ( !attr || !attr->is_initialized )
3000edb8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000edbc: 0a000002 beq 3000edcc <pthread_attr_setdetachstate+0x14> <== NOT EXECUTED 3000edc0: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000edc4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000edc8: 1a000001 bne 3000edd4 <pthread_attr_setdetachstate+0x1c> <== NOT EXECUTED
return EINVAL;
3000edcc: e3a00016 mov r0, #22 <== NOT EXECUTED 3000edd0: e12fff1e bx lr <== NOT EXECUTED
switch ( detachstate ) {
3000edd4: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_CREATE_DETACHED:
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
3000edd8: 9580103c strls r1, [r0, #60] ; 0x3c <== NOT EXECUTED
return 0;
3000eddc: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( detachstate ) {
3000ede0: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
return 0;
default:
return EINVAL;
3000ede4: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000ede8: e12fff1e bx lr <== NOT EXECUTED
3000edec <pthread_attr_setguardsize>:
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
3000edec: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000edf0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
3000edf4: 012fff1e bxeq lr <== NOT EXECUTED 3000edf8: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000edfc: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
attr->guardsize = guardsize;
3000ee00: 15801034 strne r1, [r0, #52] ; 0x34 <== NOT EXECUTED
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000ee04: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->guardsize = guardsize;
return 0;
3000ee08: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000ee0c: e12fff1e bx lr <== NOT EXECUTED
30010f44 <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
30010f44: e3500000 cmp r0, #0
30010f48: 0a000002 beq 30010f58 <pthread_attr_setinheritsched+0x14>
30010f4c: e5903000 ldr r3, [r0] 30010f50: e3530000 cmp r3, #0
30010f54: 1a000001 bne 30010f60 <pthread_attr_setinheritsched+0x1c>
return EINVAL;
30010f58: e3a00016 mov r0, #22 <== NOT EXECUTED 30010f5c: e12fff1e bx lr <== NOT EXECUTED
switch ( inheritsched ) {
30010f60: e2413001 sub r3, r1, #1 30010f64: e3530001 cmp r3, #1
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
30010f68: 95801010 strls r1, [r0, #16]
return 0;
30010f6c: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( inheritsched ) {
30010f70: 912fff1e bxls lr
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
return 0;
default:
return ENOTSUP;
30010f74: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
30010f78: e12fff1e bx lr <== NOT EXECUTED
3000ee48 <pthread_attr_setschedparam>:
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000ee48: e3500000 cmp r0, #0
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
3000ee4c: e92d0030 push {r4, r5}
if ( !attr || !attr->is_initialized || !param ) 3000ee50: 0a000005 beq 3000ee6c <pthread_attr_setschedparam+0x24>
3000ee54: e5905000 ldr r5, [r0] 3000ee58: e3550000 cmp r5, #0 3000ee5c: 13510000 cmpne r1, #0 3000ee60: 13a05000 movne r5, #0 3000ee64: 03a05001 moveq r5, #1
3000ee68: 1a000003 bne 3000ee7c <pthread_attr_setschedparam+0x34>
return EINVAL;
3000ee6c: e3a05016 mov r5, #22 <== NOT EXECUTED
attr->schedparam = *param;
return 0;
}
3000ee70: e1a00005 mov r0, r5
3000ee74: e8bd0030 pop {r4, r5}
3000ee78: e12fff1e bx lr
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
attr->schedparam = *param;
3000ee7c: e280c018 add ip, r0, #24
3000ee80: e1a04001 mov r4, r1
3000ee84: e8b4000f ldm r4!, {r0, r1, r2, r3}
3000ee88: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000ee8c: e8940007 ldm r4, {r0, r1, r2}
3000ee90: e88c0007 stm ip, {r0, r1, r2}
return 0;
3000ee94: eafffff5 b 3000ee70 <pthread_attr_setschedparam+0x28>
3000ee98 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
3000ee98: e3500000 cmp r0, #0
3000ee9c: 0a000002 beq 3000eeac <pthread_attr_setschedpolicy+0x14>
3000eea0: e5903000 ldr r3, [r0] 3000eea4: e3530000 cmp r3, #0
3000eea8: 1a000001 bne 3000eeb4 <pthread_attr_setschedpolicy+0x1c>
return EINVAL;
3000eeac: e3a00016 mov r0, #22 <== NOT EXECUTED 3000eeb0: e12fff1e bx lr <== NOT EXECUTED
switch ( policy ) {
3000eeb4: e3510004 cmp r1, #4
3000eeb8: 9a000001 bls 3000eec4 <pthread_attr_setschedpolicy+0x2c>
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
3000eebc: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
3000eec0: e12fff1e bx lr <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
3000eec4: e3a03001 mov r3, #1 3000eec8: e1a03113 lsl r3, r3, r1 3000eecc: e3130017 tst r3, #23
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
3000eed0: 15801014 strne r1, [r0, #20]
return 0;
3000eed4: 13a00000 movne r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
3000eed8: 112fff1e bxne lr
3000eedc: eafffff6 b 3000eebc <pthread_attr_setschedpolicy+0x24> <== NOT EXECUTED
3000eee0 <pthread_attr_setscope>:
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
3000eee0: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000eee4: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
3000eee8: 012fff1e bxeq lr <== NOT EXECUTED 3000eeec: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000eef0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000eef4: 1a000001 bne 3000ef00 <pthread_attr_setscope+0x20> <== NOT EXECUTED
return EINVAL;
3000eef8: e3a00016 mov r0, #22 <== NOT EXECUTED
return ENOTSUP;
default:
return EINVAL;
}
}
3000eefc: e12fff1e bx lr <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( contentionscope ) {
3000ef00: e3510000 cmp r1, #0 <== NOT EXECUTED
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
3000ef04: 0580100c streq r1, [r0, #12] <== NOT EXECUTED
return 0;
3000ef08: 01a00001 moveq r0, r1 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( contentionscope ) {
3000ef0c: 012fff1e bxeq lr <== NOT EXECUTED
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
default:
return EINVAL;
3000ef10: e3510001 cmp r1, #1 <== NOT EXECUTED 3000ef14: 03a00086 moveq r0, #134 ; 0x86 <== NOT EXECUTED 3000ef18: 13a00016 movne r0, #22 <== NOT EXECUTED 3000ef1c: e12fff1e bx lr <== NOT EXECUTED
3000ef44 <pthread_attr_setstack>:
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000ef44: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000ef48: 03a00016 moveq r0, #22 <== NOT EXECUTED
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000ef4c: 012fff1e bxeq lr <== NOT EXECUTED 3000ef50: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000ef54: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ef58: 1a000001 bne 3000ef64 <pthread_attr_setstack+0x20> <== NOT EXECUTED
return EINVAL;
3000ef5c: e3a00016 mov r0, #22 <== NOT EXECUTED
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
}
3000ef60: e12fff1e bx lr <== NOT EXECUTED
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
3000ef64: e5831004 str r1, [r3, #4] <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
3000ef68: e59f1018 ldr r1, [pc, #24] ; 3000ef88 <pthread_attr_setstack+0x44><== NOT EXECUTED
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
3000ef6c: e3a00000 mov r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
3000ef70: e5911000 ldr r1, [r1] <== NOT EXECUTED 3000ef74: e1a01081 lsl r1, r1, #1 <== NOT EXECUTED
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
3000ef78: e1510002 cmp r1, r2 <== NOT EXECUTED 3000ef7c: 25831008 strcs r1, [r3, #8] <== NOT EXECUTED 3000ef80: 35832008 strcc r2, [r3, #8] <== NOT EXECUTED
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
3000ef84: e12fff1e bx lr <== NOT EXECUTED
3000ef20 <pthread_attr_setstackaddr>:
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
3000ef20: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ef24: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
3000ef28: 012fff1e bxeq lr <== NOT EXECUTED 3000ef2c: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ef30: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
attr->stackaddr = stackaddr;
3000ef34: 15801004 strne r1, [r0, #4] <== NOT EXECUTED
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000ef38: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->stackaddr = stackaddr;
return 0;
3000ef3c: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000ef40: e12fff1e bx lr <== NOT EXECUTED
30010f7c <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
30010f7c: e3500000 cmp r0, #0
return EINVAL;
30010f80: 03a00016 moveq r0, #22
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
30010f84: 012fff1e bxeq lr 30010f88: e5903000 ldr r3, [r0] 30010f8c: e3530000 cmp r3, #0
30010f90: 1a000001 bne 30010f9c <pthread_attr_setstacksize+0x20>
return EINVAL;
30010f94: e3a00016 mov r0, #22 <== NOT EXECUTED
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
return 0;
}
30010f98: e12fff1e bx lr <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
30010f9c: e59f3018 ldr r3, [pc, #24] ; 30010fbc <pthread_attr_setstacksize+0x40> 30010fa0: e5933000 ldr r3, [r3] 30010fa4: e1a03083 lsl r3, r3, #1 30010fa8: e1530001 cmp r3, r1
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
30010fac: 85803008 strhi r3, [r0, #8]
else
attr->stacksize = stacksize;
30010fb0: 95801008 strls r1, [r0, #8]
return 0;
30010fb4: e3a00000 mov r0, #0 30010fb8: e12fff1e bx lr
3000ac2c <pthread_barrier_destroy>:
* source of the error.
*/
int pthread_barrier_destroy(
pthread_barrier_t *barrier
)
{
3000ac2c: e92d4030 push {r4, r5, lr}
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000ac30: e2503000 subs r3, r0, #0
* source of the error.
*/
int pthread_barrier_destroy(
pthread_barrier_t *barrier
)
{
3000ac34: e24dd004 sub sp, sp, #4
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000ac38: 0a00000d beq 3000ac74 <pthread_barrier_destroy+0x48>
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
3000ac3c: e5931000 ldr r1, [r3] 3000ac40: e59f005c ldr r0, [pc, #92] ; 3000aca4 <pthread_barrier_destroy+0x78> 3000ac44: e1a0200d mov r2, sp 3000ac48: eb0009dc bl 3000d3c0 <_Objects_Get>
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
3000ac4c: e59d3000 ldr r3, [sp] 3000ac50: e1a04000 mov r4, r0 3000ac54: e3530000 cmp r3, #0
3000ac58: 1a000005 bne 3000ac74 <pthread_barrier_destroy+0x48>
case OBJECTS_LOCAL:
if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) {
3000ac5c: e5905058 ldr r5, [r0, #88] ; 0x58 3000ac60: e3550000 cmp r5, #0
3000ac64: 0a000005 beq 3000ac80 <pthread_barrier_destroy+0x54>
_Thread_Enable_dispatch();
3000ac68: eb000d7c bl 3000e260 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000ac6c: e3a00010 mov r0, #16 <== NOT EXECUTED 3000ac70: ea000000 b 3000ac78 <pthread_barrier_destroy+0x4c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ac74: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000ac78: e28dd004 add sp, sp, #4
3000ac7c: e8bd8030 pop {r4, r5, pc}
if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) {
_Thread_Enable_dispatch();
return EBUSY;
}
_Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object );
3000ac80: e59f001c ldr r0, [pc, #28] ; 3000aca4 <pthread_barrier_destroy+0x78> 3000ac84: e1a01004 mov r1, r4 3000ac88: eb0008ba bl 3000cf78 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Barrier_Free (
POSIX_Barrier_Control *the_barrier
)
{
_Objects_Free( &_POSIX_Barrier_Information, &the_barrier->Object );
3000ac8c: e59f0010 ldr r0, [pc, #16] ; 3000aca4 <pthread_barrier_destroy+0x78> 3000ac90: e1a01004 mov r1, r4 3000ac94: eb000972 bl 3000d264 <_Objects_Free>
_POSIX_Barrier_Free( the_barrier );
_Thread_Enable_dispatch();
3000ac98: eb000d70 bl 3000e260 <_Thread_Enable_dispatch>
return 0;
3000ac9c: e1a00005 mov r0, r5 3000aca0: eafffff4 b 3000ac78 <pthread_barrier_destroy+0x4c>
3000aca8 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
3000aca8: e92d40f0 push {r4, r5, r6, r7, lr}
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
3000acac: e2504000 subs r4, r0, #0
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
3000acb0: e24dd014 sub sp, sp, #20
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
3000acb4: 0a000001 beq 3000acc0 <pthread_barrier_init+0x18>
return EINVAL;
if ( count == 0 )
3000acb8: e3520000 cmp r2, #0
3000acbc: 1a000002 bne 3000accc <pthread_barrier_init+0x24>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
3000acc0: 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; }
3000acc4: e28dd014 add sp, sp, #20
3000acc8: e8bd80f0 pop {r4, r5, r6, r7, pc}
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
3000accc: e3510000 cmp r1, #0
3000acd0: 0a00001c beq 3000ad48 <pthread_barrier_init+0xa0>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
3000acd4: e5913000 ldr r3, [r1] 3000acd8: e3530000 cmp r3, #0
3000acdc: 0afffff7 beq 3000acc0 <pthread_barrier_init+0x18>
return EINVAL;
switch ( the_attr->process_shared ) {
3000ace0: e5915004 ldr r5, [r1, #4] 3000ace4: e3550000 cmp r5, #0
3000ace8: 1afffff4 bne 3000acc0 <pthread_barrier_init+0x18>
*
* 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;
3000acec: e59f3078 ldr r3, [pc, #120] ; 3000ad6c <pthread_barrier_init+0xc4>
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
the_attributes.maximum_count = count;
3000acf0: e58d2008 str r2, [sp, #8] 3000acf4: e5931000 ldr r1, [r3]
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
3000acf8: e58d5004 str r5, [sp, #4]
++level;
3000acfc: e2812001 add r2, r1, #1
_Thread_Dispatch_disable_level = level;
3000ad00: 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 *)
3000ad04: e59f7064 ldr r7, [pc, #100] ; 3000ad70 <pthread_barrier_init+0xc8> 3000ad08: e1a00007 mov r0, r7 3000ad0c: eb000876 bl 3000ceec <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
3000ad10: e2506000 subs r6, r0, #0
3000ad14: 0a000011 beq 3000ad60 <pthread_barrier_init+0xb8>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
3000ad18: e2860010 add r0, r6, #16 3000ad1c: e28d1004 add r1, sp, #4 3000ad20: eb0005ed bl 3000c4dc <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000ad24: e5963008 ldr r3, [r6, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ad28: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000ad2c: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ad30: e7826721 str r6, [r2, r1, lsr #14]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000ad34: e586500c str r5, [r6, #12]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
3000ad38: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
3000ad3c: eb000d47 bl 3000e260 <_Thread_Enable_dispatch>
return 0;
3000ad40: e1a00005 mov r0, r5 3000ad44: eaffffde b 3000acc4 <pthread_barrier_init+0x1c>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
3000ad48: e28d000c add r0, sp, #12 3000ad4c: e58d2000 str r2, [sp] 3000ad50: ebffffa1 bl 3000abdc <pthread_barrierattr_init>
the_attr = &my_attr;
3000ad54: e28d100c add r1, sp, #12 3000ad58: e59d2000 ldr r2, [sp] 3000ad5c: eaffffdc b 3000acd4 <pthread_barrier_init+0x2c>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
3000ad60: eb000d3e bl 3000e260 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000ad64: e3a0000b mov r0, #11 <== NOT EXECUTED 3000ad68: eaffffd5 b 3000acc4 <pthread_barrier_init+0x1c> <== NOT EXECUTED
3000ad74 <pthread_barrier_wait>:
*/
int pthread_barrier_wait(
pthread_barrier_t *barrier
)
{
3000ad74: e52de004 push {lr} ; (str lr, [sp, #-4]!)
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000ad78: e2503000 subs r3, r0, #0
*/
int pthread_barrier_wait(
pthread_barrier_t *barrier
)
{
3000ad7c: e24dd008 sub sp, sp, #8
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000ad80: 0a000006 beq 3000ada0 <pthread_barrier_wait+0x2c>
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
3000ad84: e59f0050 ldr r0, [pc, #80] ; 3000addc <pthread_barrier_wait+0x68> 3000ad88: e5931000 ldr r1, [r3] 3000ad8c: e28d2004 add r2, sp, #4 3000ad90: eb00098a bl 3000d3c0 <_Objects_Get>
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
3000ad94: e59dc004 ldr ip, [sp, #4] 3000ad98: e35c0000 cmp ip, #0
3000ad9c: 0a000002 beq 3000adac <pthread_barrier_wait+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ada0: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000ada4: e28dd008 add sp, sp, #8
3000ada8: e8bd8000 pop {pc}
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
3000adac: e5901008 ldr r1, [r0, #8] 3000adb0: e1a0300c mov r3, ip 3000adb4: e2800010 add r0, r0, #16 3000adb8: e3a02001 mov r2, #1 3000adbc: e58dc000 str ip, [sp] 3000adc0: eb0005d0 bl 3000c508 <_CORE_barrier_Wait>
the_barrier->Object.id,
true,
0,
NULL
);
_Thread_Enable_dispatch();
3000adc4: eb000d25 bl 3000e260 <_Thread_Enable_dispatch>
return _POSIX_Barrier_Translate_core_barrier_return_code(
_Thread_Executing->Wait.return_code );
3000adc8: e59f3010 ldr r3, [pc, #16] ; 3000ade0 <pthread_barrier_wait+0x6c> 3000adcc: e5933008 ldr r3, [r3, #8]
true,
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_Barrier_Translate_core_barrier_return_code(
3000add0: e5930034 ldr r0, [r3, #52] ; 0x34 3000add4: eb0017b1 bl 30010ca0 <_POSIX_Barrier_Translate_core_barrier_return_code> 3000add8: eafffff1 b 3000ada4 <pthread_barrier_wait+0x30>
3000ab90 <pthread_barrierattr_destroy>:
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000ab90: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000ab94: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000ab98: 012fff1e bxeq lr <== NOT EXECUTED 3000ab9c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000aba0: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000aba4: 13a00000 movne r0, #0 <== NOT EXECUTED 3000aba8: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000abac: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000abb0: e12fff1e bx lr <== NOT EXECUTED
3000abb4 <pthread_barrierattr_getpshared>:
int pthread_barrierattr_getpshared(
const pthread_barrierattr_t *attr,
int *pshared
)
{
if ( !attr )
3000abb4: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000abb8: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_barrierattr_getpshared(
const pthread_barrierattr_t *attr,
int *pshared
)
{
if ( !attr )
3000abbc: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000abc0: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000abc4: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000abc8: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000abcc: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
3000abd0: 13a00000 movne r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
*pshared = attr->process_shared;
3000abd4: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0; }
3000abd8: e12fff1e bx lr <== NOT EXECUTED
3000abf8 <pthread_barrierattr_setpshared>:
int pthread_barrierattr_setpshared(
pthread_barrierattr_t *attr,
int pshared
)
{
if ( !attr )
3000abf8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000abfc: 0a000002 beq 3000ac0c <pthread_barrierattr_setpshared+0x14><== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000ac00: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ac04: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ac08: 1a000001 bne 3000ac14 <pthread_barrierattr_setpshared+0x1c><== NOT EXECUTED
return EINVAL;
3000ac0c: e3a00016 mov r0, #22 <== NOT EXECUTED 3000ac10: e12fff1e bx lr <== NOT EXECUTED
switch ( pshared ) {
3000ac14: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000ac18: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000ac1c: 93a00000 movls r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000ac20: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000ac24: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000ac28: e12fff1e bx lr <== NOT EXECUTED
3000a17c <pthread_cancel>:
*/
int pthread_cancel(
pthread_t thread
)
{
3000a17c: e92d4010 push {r4, lr} <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
3000a180: e59f304c ldr r3, [pc, #76] ; 3000a1d4 <pthread_cancel+0x58><== NOT EXECUTED
*/
int pthread_cancel(
pthread_t thread
)
{
3000a184: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
3000a188: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a18c: e3530000 cmp r3, #0 <== NOT EXECUTED
return EPROTO;
3000a190: 13a00047 movne r0, #71 ; 0x47 <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
3000a194: 0a000001 beq 3000a1a0 <pthread_cancel+0x24> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000a198: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a19c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
3000a1a0: e1a0100d mov r1, sp <== NOT EXECUTED 3000a1a4: eb000c49 bl 3000d2d0 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000a1a8: e59d4000 ldr r4, [sp] <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
3000a1ac: e1a03000 mov r3, r0 <== NOT EXECUTED
switch ( location ) {
3000a1b0: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a1b4: 13a00016 movne r0, #22 <== NOT EXECUTED
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000a1b8: 1afffff6 bne 3000a198 <pthread_cancel+0x1c> <== NOT EXECUTED
case OBJECTS_LOCAL:
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
thread_support->cancelation_requested = 1;
3000a1bc: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED 3000a1c0: e3a02001 mov r2, #1 <== NOT EXECUTED 3000a1c4: e58320e0 str r2, [r3, #224] ; 0xe0 <== NOT EXECUTED
/* This enables dispatch implicitly */
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( the_thread );
3000a1c8: eb0015f3 bl 3000f99c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
return 0;
3000a1cc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a1d0: eafffff0 b 3000a198 <pthread_cancel+0x1c> <== NOT EXECUTED
30009f78 <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;
30009f78: e59f2084 ldr r2, [pc, #132] ; 3000a004 <pthread_cleanup_pop+0x8c>
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 ];
30009f7c: e59f3084 ldr r3, [pc, #132] ; 3000a008 <pthread_cleanup_pop+0x90> 30009f80: e5921000 ldr r1, [r2] 30009f84: e5933008 ldr r3, [r3, #8]
++level;
30009f88: e2811001 add r1, r1, #1
*/
void pthread_cleanup_pop(
int execute
)
{
30009f8c: 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 ];
30009f90: e59330f4 ldr r3, [r3, #244] ; 0xf4
_Thread_Dispatch_disable_level = level;
30009f94: e5821000 str r1, [r2]
*/
void pthread_cleanup_pop(
int execute
)
{
30009f98: e1a04000 mov r4, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30009f9c: e10f5000 mrs r5, CPSR 30009fa0: e3852080 orr r2, r5, #128 ; 0x80 30009fa4: e129f002 msr CPSR_fc, r2
*/
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
30009fa8: 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 );
30009fac: e28320e8 add r2, r3, #232 ; 0xe8 30009fb0: e1510002 cmp r1, r2
30009fb4: 0a00000f beq 30009ff8 <pthread_cleanup_pop+0x80>
_Thread_Enable_dispatch();
_ISR_Enable( level );
return;
}
handler = (POSIX_Cancel_Handler_control *)
30009fb8: e59330ec ldr r3, [r3, #236] ; 0xec
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
30009fbc: e8930006 ldm r3, {r1, r2}
next->previous = previous;
30009fc0: e5812004 str r2, [r1, #4]
previous->next = next;
30009fc4: e5821000 str r1, [r2]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009fc8: e129f005 msr CPSR_fc, r5
_ISR_Enable( level );
tmp_handler = *handler;
_Workspace_Free( handler );
30009fcc: e1a00003 mov r0, r3
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
tmp_handler = *handler;
30009fd0: e5935008 ldr r5, [r3, #8] 30009fd4: e593600c ldr r6, [r3, #12]
_Workspace_Free( handler );
30009fd8: eb000fe0 bl 3000df60 <_Workspace_Free>
_Thread_Enable_dispatch();
30009fdc: eb000bbd bl 3000ced8 <_Thread_Enable_dispatch>
if ( execute )
30009fe0: e3540000 cmp r4, #0
30009fe4: 08bd8070 popeq {r4, r5, r6, pc}
(*tmp_handler.routine)( tmp_handler.arg );
30009fe8: e1a00006 mov r0, r6 <== NOT EXECUTED
30009fec: e1a0e00f mov lr, pc <== NOT EXECUTED
30009ff0: e12fff15 bx r5 <== NOT EXECUTED
30009ff4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
_Thread_Enable_dispatch();
30009ff8: eb000bb6 bl 3000ced8 <_Thread_Enable_dispatch> <== NOT EXECUTED
30009ffc: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
3000a000: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000b4c4 <pthread_cond_destroy>:
* P1003.1c/Draft 10, p. 87
*/
int pthread_cond_destroy(
pthread_cond_t *cond
)
{
3000b4c4: e92d4030 push {r4, r5, lr}
3000b4c8: e24dd004 sub sp, sp, #4
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000b4cc: e1a0100d mov r1, sp 3000b4d0: eb000016 bl 3000b530 <_POSIX_Condition_variables_Get>
switch ( location ) {
3000b4d4: e59d3000 ldr r3, [sp]
)
{
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000b4d8: e1a04000 mov r4, r0
switch ( location ) {
3000b4dc: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b4e0: 13a00016 movne r0, #22
{
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
switch ( location ) {
3000b4e4: 1a000005 bne 3000b500 <pthread_cond_destroy+0x3c>
case OBJECTS_LOCAL:
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
3000b4e8: e2840018 add r0, r4, #24 3000b4ec: eb0010fc bl 3000f8e4 <_Thread_queue_First> 3000b4f0: e2505000 subs r5, r0, #0
3000b4f4: 0a000003 beq 3000b508 <pthread_cond_destroy+0x44>
_Thread_Enable_dispatch();
3000b4f8: eb000f22 bl 3000f188 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000b4fc: e3a00010 mov r0, #16 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000b500: e28dd004 add sp, sp, #4
3000b504: e8bd8030 pop {r4, r5, pc}
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
_Thread_Enable_dispatch();
return EBUSY;
}
_Objects_Close(
3000b508: e59f001c ldr r0, [pc, #28] ; 3000b52c <pthread_cond_destroy+0x68> 3000b50c: e1a01004 mov r1, r4 3000b510: eb000a62 bl 3000dea0 <_Objects_Close>
RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free (
POSIX_Condition_variables_Control *the_condition_variable
)
{
_Objects_Free(
3000b514: e59f0010 ldr r0, [pc, #16] ; 3000b52c <pthread_cond_destroy+0x68> 3000b518: e1a01004 mov r1, r4 3000b51c: eb000b1a bl 3000e18c <_Objects_Free>
&_POSIX_Condition_variables_Information,
&the_cond->Object
);
_POSIX_Condition_variables_Free( the_cond );
_Thread_Enable_dispatch();
3000b520: eb000f18 bl 3000f188 <_Thread_Enable_dispatch>
return 0;
3000b524: e1a00005 mov r0, r5 3000b528: eafffff4 b 3000b500 <pthread_cond_destroy+0x3c>
3000b590 <pthread_cond_init>:
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
3000b590: 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;
3000b594: e3510000 cmp r1, #0 3000b598: e59f60a0 ldr r6, [pc, #160] ; 3000b640 <pthread_cond_init+0xb0> 3000b59c: 11a06001 movne r6, r1
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000b5a0: e5963004 ldr r3, [r6, #4]
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
3000b5a4: e1a04000 mov r4, r0
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000b5a8: e3530001 cmp r3, #1
return EINVAL;
3000b5ac: 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 )
3000b5b0: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return EINVAL;
if ( !the_attr->is_initialized )
3000b5b4: e5963000 ldr r3, [r6] 3000b5b8: e3530000 cmp r3, #0
3000b5bc: 1a000001 bne 3000b5c8 <pthread_cond_init+0x38>
return EINVAL;
3000b5c0: e3a00016 mov r0, #22 <== NOT EXECUTED
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000b5c4: e8bd80f0 pop {r4, r5, r6, r7, 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;
3000b5c8: e59f3074 ldr r3, [pc, #116] ; 3000b644 <pthread_cond_init+0xb4> 3000b5cc: e5932000 ldr r2, [r3]
++level;
3000b5d0: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000b5d4: e5832000 str r2, [r3]
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
3000b5d8: e59f7068 ldr r7, [pc, #104] ; 3000b648 <pthread_cond_init+0xb8> 3000b5dc: e1a00007 mov r0, r7 3000b5e0: eb000a0b bl 3000de14 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
3000b5e4: e2505000 subs r5, r0, #0
3000b5e8: 0a000011 beq 3000b634 <pthread_cond_init+0xa4>
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
3000b5ec: e596c004 ldr ip, [r6, #4]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
3000b5f0: e3a06000 mov r6, #0
_Thread_queue_Initialize(
3000b5f4: e2850018 add r0, r5, #24 3000b5f8: e1a01006 mov r1, r6 3000b5fc: e59f2048 ldr r2, [pc, #72] ; 3000b64c <pthread_cond_init+0xbc> 3000b600: e3a03074 mov r3, #116 ; 0x74
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
3000b604: e585c010 str ip, [r5, #16]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
3000b608: e5856014 str r6, [r5, #20]
_Thread_queue_Initialize(
3000b60c: eb0010d6 bl 3000f96c <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000b610: e5953008 ldr r3, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b614: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000b618: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b61c: e7825721 str r5, [r2, r1, lsr #14]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000b620: e585600c str r6, [r5, #12]
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
3000b624: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
3000b628: eb000ed6 bl 3000f188 <_Thread_Enable_dispatch>
return 0;
3000b62c: e1a00006 mov r0, r6
3000b630: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
3000b634: eb000ed3 bl 3000f188 <_Thread_Enable_dispatch>
return ENOMEM;
3000b638: e3a0000c mov r0, #12
3000b63c: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000b650 <pthread_cond_signal>:
*/
int pthread_cond_signal(
pthread_cond_t *cond
)
{
return _POSIX_Condition_variables_Signal_support( cond, false );
3000b650: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b654: eaffffff b 3000b658 <_POSIX_Condition_variables_Signal_support><== NOT EXECUTED
3000b6b8 <pthread_cond_timedwait>:
int pthread_cond_timedwait(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
3000b6b8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000b6bc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000b6c0: e1a05000 mov r5, r0 <== NOT EXECUTED
3000b6c4: 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);
3000b6c8: e1a00002 mov r0, r2 <== NOT EXECUTED 3000b6cc: e1a0100d mov r1, sp <== NOT EXECUTED 3000b6d0: eb00012a bl 3000bb80 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000b6d4: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000b6d8: 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 )
3000b6dc: 1a000001 bne 3000b6e8 <pthread_cond_timedwait+0x30> <== NOT EXECUTED
cond,
mutex,
ticks,
already_timedout
);
}
3000b6e0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b6e4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
already_timedout = false;
status = _POSIX_Absolute_timeout_to_ticks(abstime, &ticks);
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000b6e8: e2403001 sub r3, r0, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
already_timedout = true;
return _POSIX_Condition_variables_Wait_support(
3000b6ec: e3530001 cmp r3, #1 <== NOT EXECUTED 3000b6f0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b6f4: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b6f8: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000b6fc: 83a03000 movhi r3, #0 <== NOT EXECUTED 3000b700: 93a03001 movls r3, #1 <== NOT EXECUTED 3000b704: eb000003 bl 3000b718 <_POSIX_Condition_variables_Wait_support><== NOT EXECUTED 3000b708: eafffff4 b 3000b6e0 <pthread_cond_timedwait+0x28> <== NOT EXECUTED
3000b70c <pthread_cond_wait>:
int pthread_cond_wait(
pthread_cond_t *cond,
pthread_mutex_t *mutex
)
{
return _POSIX_Condition_variables_Wait_support(
3000b70c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000b710: e1a03002 mov r3, r2 <== NOT EXECUTED 3000b714: eaffffff b 3000b718 <_POSIX_Condition_variables_Wait_support><== NOT EXECUTED
3000b438 <pthread_condattr_destroy>:
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000b438: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000b43c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000b440: 012fff1e bxeq lr <== NOT EXECUTED 3000b444: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b448: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000b44c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b450: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000b454: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000b458: e12fff1e bx lr <== NOT EXECUTED
3000b45c <pthread_condattr_getpshared>:
int pthread_condattr_getpshared(
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
3000b45c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000b460: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
return EINVAL;
3000b464: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
3000b468: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr )
return EINVAL;
*pshared = attr->process_shared;
3000b46c: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0; }
3000b470: e12fff1e bx lr <== NOT EXECUTED
3000b474 <pthread_condattr_init>:
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
if ( !attr )
3000b474: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
3000b478: e92d0030 push {r4, r5} <== NOT EXECUTED
if ( !attr )
return EINVAL;
3000b47c: 03a00016 moveq r0, #22 <== NOT EXECUTED
*attr = _POSIX_Condition_variables_Default_attributes;
3000b480: 159f2010 ldrne r2, [pc, #16] ; 3000b498 <pthread_condattr_init+0x24><== NOT EXECUTED
return 0;
3000b484: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr )
return EINVAL;
*attr = _POSIX_Condition_variables_Default_attributes;
3000b488: 18920030 ldmne r2, {r4, r5} <== NOT EXECUTED
3000b48c: 18830030 stmne r3, {r4, r5} <== NOT EXECUTED
return 0; }
3000b490: e8bd0030 pop {r4, r5} <== NOT EXECUTED
3000b494: e12fff1e bx lr <== NOT EXECUTED
3000b49c <pthread_condattr_setpshared>:
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
if ( !attr )
3000b49c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000b4a0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
if ( !attr )
3000b4a4: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000b4a8: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000b4ac: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
default:
return EINVAL;
3000b4b0: 83a00016 movhi r0, #22 <== NOT EXECUTED
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
3000b4b4: 93a00000 movls r0, #0 <== NOT EXECUTED
default:
return EINVAL;
}
}
3000b4b8: e12fff1e bx lr <== NOT EXECUTED
3000a91c <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
3000a91c: 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 )
3000a920: e2528000 subs r8, r2, #0
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
3000a924: e24dd048 sub sp, sp, #72 ; 0x48 3000a928: e1a07000 mov r7, r0 3000a92c: e1a05003 mov r5, r3
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
3000a930: 03a0600e moveq r6, #14
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
3000a934: 0a000006 beq 3000a954 <pthread_create+0x38>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
3000a938: e59f4234 ldr r4, [pc, #564] ; 3000ab74 <pthread_create+0x258> 3000a93c: e3510000 cmp r1, #0 3000a940: 11a04001 movne r4, r1
if ( !the_attr->is_initialized )
3000a944: e5943000 ldr r3, [r4] 3000a948: e3530000 cmp r3, #0
3000a94c: 1a000003 bne 3000a960 <pthread_create+0x44>
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
3000a950: e3a06016 mov r6, #22 <== NOT EXECUTED
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
3000a954: e1a00006 mov r0, r6
3000a958: e28dd048 add sp, sp, #72 ; 0x48
3000a95c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* 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) )
3000a960: e5943004 ldr r3, [r4, #4] 3000a964: e3530000 cmp r3, #0
3000a968: 0a000004 beq 3000a980 <pthread_create+0x64>
3000a96c: e59f3204 ldr r3, [pc, #516] ; 3000ab78 <pthread_create+0x25c><== NOT EXECUTED 3000a970: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3000a974: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a978: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a97c: 3afffff3 bcc 3000a950 <pthread_create+0x34> <== 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 ) {
3000a980: e5943010 ldr r3, [r4, #16] 3000a984: e3530001 cmp r3, #1
3000a988: 0a000043 beq 3000aa9c <pthread_create+0x180>
3000a98c: e3530002 cmp r3, #2
3000a990: 1affffee bne 3000a950 <pthread_create+0x34>
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
3000a994: e28d9024 add r9, sp, #36 ; 0x24
3000a998: e1a0c009 mov ip, r9
3000a99c: e2846018 add r6, r4, #24
3000a9a0: e8b6000f ldm r6!, {r0, r1, r2, r3}
3000a9a4: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000a9a8: e8960007 ldm r6, {r0, r1, r2}
3000a9ac: e88c0007 stm ip, {r0, r1, r2}
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
3000a9b0: e594b014 ldr fp, [r4, #20]
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
3000a9b4: e594300c ldr r3, [r4, #12] 3000a9b8: e3530000 cmp r3, #0
return ENOTSUP;
3000a9bc: 13a06086 movne r6, #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 )
3000a9c0: 1affffe3 bne 3000a954 <pthread_create+0x38>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
3000a9c4: e59d0024 ldr r0, [sp, #36] ; 0x24 3000a9c8: eb001906 bl 30010de8 <_POSIX_Priority_Is_valid> 3000a9cc: e3500000 cmp r0, #0
3000a9d0: 0affffde beq 3000a950 <pthread_create+0x34>
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
3000a9d4: e59dc024 ldr ip, [sp, #36] ; 0x24
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
3000a9d8: e1a0000b mov r0, fp
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
3000a9dc: e58dc020 str ip, [sp, #32]
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000a9e0: e59fc194 ldr ip, [pc, #404] ; 3000ab7c <pthread_create+0x260>
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
3000a9e4: e1a01009 mov r1, r9 3000a9e8: e28d2040 add r2, sp, #64 ; 0x40 3000a9ec: e28d3044 add r3, sp, #68 ; 0x44 3000a9f0: e5dca000 ldrb sl, [ip] 3000a9f4: eb001906 bl 30010e14 <_POSIX_Thread_Translate_sched_param>
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
3000a9f8: e2506000 subs r6, r0, #0
3000a9fc: 1affffd4 bne 3000a954 <pthread_create+0x38>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
3000aa00: e59f1178 ldr r1, [pc, #376] ; 3000ab80 <pthread_create+0x264> 3000aa04: e5910000 ldr r0, [r1] 3000aa08: eb000633 bl 3000c2dc <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
3000aa0c: e59f0170 ldr r0, [pc, #368] ; 3000ab84 <pthread_create+0x268> 3000aa10: eb0008e1 bl 3000cd9c <_Objects_Allocate>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
3000aa14: e3500000 cmp r0, #0 3000aa18: e58d001c str r0, [sp, #28]
3000aa1c: 0a000019 beq 3000aa88 <pthread_create+0x16c>
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
3000aa20: e59f3150 ldr r3, [pc, #336] ; 3000ab78 <pthread_create+0x25c> 3000aa24: e59dc020 ldr ip, [sp, #32]
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
3000aa28: e3a01001 mov r1, #1
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
3000aa2c: e5932000 ldr r2, [r3]
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
3000aa30: e5943008 ldr r3, [r4, #8]
3000aa34: e58d1008 str r1, [sp, #8]
3000aa38: e59d1040 ldr r1, [sp, #64] ; 0x40
3000aa3c: e06ca00a rsb sl, ip, sl
3000aa40: e58d100c str r1, [sp, #12]
3000aa44: e88d0440 stm sp, {r6, sl}
3000aa48: e59d1044 ldr r1, [sp, #68] ; 0x44
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
3000aa4c: e1a02082 lsl r2, r2, #1
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
3000aa50: e58d1010 str r1, [sp, #16] 3000aa54: e58d6014 str r6, [sp, #20] 3000aa58: e58d6018 str r6, [sp, #24] 3000aa5c: e1520003 cmp r2, r3 3000aa60: 21a03002 movcs r3, r2 3000aa64: e59f0118 ldr r0, [pc, #280] ; 3000ab84 <pthread_create+0x268> 3000aa68: e59d101c ldr r1, [sp, #28] 3000aa6c: e5942004 ldr r2, [r4, #4] 3000aa70: eb000dd3 bl 3000e1c4 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
3000aa74: e3500000 cmp r0, #0
3000aa78: 1a000013 bne 3000aacc <pthread_create+0x1b0>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
3000aa7c: e59f0100 ldr r0, [pc, #256] ; 3000ab84 <pthread_create+0x268> 3000aa80: e59d101c ldr r1, [sp, #28] 3000aa84: eb0009a2 bl 3000d114 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
3000aa88: e59f20f0 ldr r2, [pc, #240] ; 3000ab80 <pthread_create+0x264>
return EAGAIN;
3000aa8c: e3a0600b mov r6, #11
name /* posix threads don't have a name */
);
if ( !status ) {
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
3000aa90: e5920000 ldr r0, [r2] 3000aa94: eb00062c bl 3000c34c <_API_Mutex_Unlock>
return EAGAIN;
3000aa98: eaffffad b 3000a954 <pthread_create+0x38>
* 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 ];
3000aa9c: e59f30e4 ldr r3, [pc, #228] ; 3000ab88 <pthread_create+0x26c>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
3000aaa0: e28d9024 add r9, sp, #36 ; 0x24
* 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 ];
3000aaa4: e5933008 ldr r3, [r3, #8]
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
3000aaa8: e1a0a009 mov sl, r9
* 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 ];
3000aaac: e59360f4 ldr r6, [r3, #244] ; 0xf4
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
3000aab0: e286c088 add ip, r6, #136 ; 0x88
3000aab4: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000aab8: e8aa000f stmia sl!, {r0, r1, r2, r3}
3000aabc: e89c0007 ldm ip, {r0, r1, r2}
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
schedpolicy = api->schedpolicy;
3000aac0: e596b084 ldr fp, [r6, #132] ; 0x84
schedparam = api->schedparam;
3000aac4: e88a0007 stm sl, {r0, r1, r2}
break;
3000aac8: eaffffb9 b 3000a9b4 <pthread_create+0x98>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000aacc: e59dc01c ldr ip, [sp, #28]
api->Attributes = *the_attr;
3000aad0: e1a0e004 mov lr, r4
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000aad4: e59ca0f4 ldr sl, [ip, #244] ; 0xf4
api->Attributes = *the_attr;
3000aad8: e8be000f ldm lr!, {r0, r1, r2, r3}
3000aadc: e1a0c00a mov ip, sl
3000aae0: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000aae4: e8be000f ldm lr!, {r0, r1, r2, r3}
3000aae8: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000aaec: e8be000f ldm lr!, {r0, r1, r2, r3}
3000aaf0: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000aaf4: e89e000f ldm lr, {r0, r1, r2, r3}
3000aaf8: e88c000f stm ip, {r0, r1, r2, r3}
api->detachstate = the_attr->detachstate;
3000aafc: e594303c ldr r3, [r4, #60] ; 0x3c
api->schedpolicy = schedpolicy; api->schedparam = schedparam;
3000ab00: e28ac088 add ip, sl, #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;
3000ab04: e58a3040 str r3, [sl, #64] ; 0x40
api->schedpolicy = schedpolicy; api->schedparam = schedparam;
3000ab08: e8b9000f ldm r9!, {r0, r1, r2, r3}
3000ab0c: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000ab10: e8990007 ldm r9, {r0, r1, r2}
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
3000ab14: e58ab084 str fp, [sl, #132] ; 0x84
api->schedparam = schedparam;
3000ab18: e88c0007 stm ip, {r0, r1, r2}
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
3000ab1c: e1a03005 mov r3, r5 3000ab20: e59d001c ldr r0, [sp, #28] 3000ab24: e3a01001 mov r1, #1 3000ab28: e1a02008 mov r2, r8 3000ab2c: e58d6000 str r6, [sp] 3000ab30: eb000fed bl 3000eaec <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
3000ab34: e35b0004 cmp fp, #4
3000ab38: 0a000006 beq 3000ab58 <pthread_create+0x23c>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
3000ab3c: e59dc01c ldr ip, [sp, #28]
_RTEMS_Unlock_allocator();
3000ab40: e59f1038 ldr r1, [pc, #56] ; 3000ab80 <pthread_create+0x264>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
3000ab44: e59c3008 ldr r3, [ip, #8]
_RTEMS_Unlock_allocator();
3000ab48: e5910000 ldr r0, [r1]
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
3000ab4c: e5873000 str r3, [r7]
_RTEMS_Unlock_allocator();
3000ab50: eb0005fd bl 3000c34c <_API_Mutex_Unlock>
return 0;
3000ab54: eaffff7e b 3000a954 <pthread_create+0x38>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
3000ab58: e28a0090 add r0, sl, #144 ; 0x90 <== NOT EXECUTED 3000ab5c: eb001008 bl 3000eb84 <_Timespec_To_ticks> <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ab60: e28a10a8 add r1, sl, #168 ; 0xa8 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000ab64: e58a00b4 str r0, [sl, #180] ; 0xb4 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ab68: e59f001c ldr r0, [pc, #28] ; 3000ab8c <pthread_create+0x270><== NOT EXECUTED 3000ab6c: eb0010b1 bl 3000ee38 <_Watchdog_Insert> <== NOT EXECUTED 3000ab70: eafffff1 b 3000ab3c <pthread_create+0x220> <== NOT EXECUTED
3000a8e4 <pthread_detach>:
* 16.1.4 Detaching a Thread, P1003.1c/Draft 10, p. 149
*/
int pthread_detach(
pthread_t thread
)
{
3000a8e4: e92d4010 push {r4, lr} <== NOT EXECUTED
3000a8e8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
the_thread = _Thread_Get( thread, &location );
3000a8ec: e1a0100d mov r1, sp <== NOT EXECUTED 3000a8f0: eb000d0a bl 3000dd20 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000a8f4: e59d4000 ldr r4, [sp] <== NOT EXECUTED 3000a8f8: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000a8fc: 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 ) {
3000a900: 1a000003 bne 3000a914 <pthread_detach+0x30> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->detachstate = PTHREAD_CREATE_DETACHED;
3000a904: e59030f4 ldr r3, [r0, #244] ; 0xf4 <== NOT EXECUTED 3000a908: e5834040 str r4, [r3, #64] ; 0x40 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a90c: eb000cfb bl 3000dd00 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a910: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
3000a914: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a918: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ab90 <pthread_equal>:
break;
}
return status;
#endif
}
3000ab90: e0613000 rsb r3, r1, r0 <== NOT EXECUTED 3000ab94: e2730000 rsbs r0, r3, #0 <== NOT EXECUTED 3000ab98: e0a00003 adc r0, r0, r3 <== NOT EXECUTED 3000ab9c: e12fff1e bx lr <== NOT EXECUTED
3000a488 <pthread_getcpuclockid>:
int pthread_getcpuclockid(
pthread_t pid,
clockid_t *clock_id
)
{
3000a488: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a48c: eb0022a3 bl 30012f20 <__errno> <== NOT EXECUTED 3000a490: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a494: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a498: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a49c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000d258 <pthread_getschedparam>:
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
3000d258: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000d25c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000d260: 13520000 cmpne r2, #0 <== NOT EXECUTED
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
3000d264: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000d268: e1a04002 mov r4, r2 <== NOT EXECUTED 3000d26c: e1a07001 mov r7, r1 <== NOT EXECUTED
return EINVAL;
3000d270: 03a00016 moveq r0, #22 <== NOT EXECUTED
{
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000d274: 1a000001 bne 3000d280 <pthread_getschedparam+0x28> <== NOT EXECUTED
break;
}
return ESRCH;
}
3000d278: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000d27c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
register Thread_Control *the_thread;
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
3000d280: e1a0100d mov r1, sp <== NOT EXECUTED 3000d284: eb000cfa bl 30010674 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000d288: e59d5000 ldr r5, [sp] <== NOT EXECUTED
register Thread_Control *the_thread;
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
3000d28c: e1a0c000 mov ip, r0 <== NOT EXECUTED
switch ( location ) {
3000d290: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000d294: 13a00003 movne r0, #3 <== NOT EXECUTED
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000d298: 1afffff6 bne 3000d278 <pthread_getschedparam+0x20> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000d29c: e59c60f4 ldr r6, [ip, #244] ; 0xf4 <== NOT EXECUTED
if ( policy )
*policy = api->schedpolicy;
if ( param ) {
*param = api->schedparam;
3000d2a0: e1a0e004 mov lr, r4 <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( policy )
*policy = api->schedpolicy;
3000d2a4: e5963084 ldr r3, [r6, #132] ; 0x84 <== NOT EXECUTED
if ( param ) {
*param = api->schedparam;
3000d2a8: 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;
3000d2ac: e5873000 str r3, [r7] <== NOT EXECUTED
if ( param ) {
*param = api->schedparam;
3000d2b0: e8b6000f ldm r6!, {r0, r1, r2, r3} <== NOT EXECUTED
3000d2b4: 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);
3000d2b8: e59f3020 ldr r3, [pc, #32] ; 3000d2e0 <pthread_getschedparam+0x88><== NOT EXECUTED
3000d2bc: e8960007 ldm r6, {r0, r1, r2} <== NOT EXECUTED
3000d2c0: e5d37000 ldrb r7, [r3] <== NOT EXECUTED
3000d2c4: e59c3014 ldr r3, [ip, #20] <== NOT EXECUTED
3000d2c8: e88e0007 stm lr, {r0, r1, r2} <== NOT EXECUTED
3000d2cc: e0633007 rsb r3, r3, r7 <== NOT EXECUTED
param->sched_priority =
3000d2d0: e5843000 str r3, [r4] <== NOT EXECUTED
_POSIX_Priority_From_core( the_thread->current_priority );
}
_Thread_Enable_dispatch();
3000d2d4: eb000cde bl 30010654 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000d2d8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000d2dc: eaffffe5 b 3000d278 <pthread_getschedparam+0x20> <== NOT EXECUTED
3000f450 <pthread_join>:
int pthread_join(
pthread_t thread,
void **value_ptr
)
{
3000f450: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000f454: e59f40cc ldr r4, [pc, #204] ; 3000f528 <pthread_join+0xd8> <== NOT EXECUTED 3000f458: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
/*
* Put ourself on the threads join list
*/
if ( the_thread->current_state ==
3000f45c: e59f50c8 ldr r5, [pc, #200] ; 3000f52c <pthread_join+0xdc> <== NOT EXECUTED
int pthread_join(
pthread_t thread,
void **value_ptr
)
{
3000f460: e1a06000 mov r6, r0 <== NOT EXECUTED 3000f464: e1a0a001 mov sl, r1 <== NOT EXECUTED
_Thread_Clear_state(
the_thread,
(STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT)
);
} else {
_Thread_Executing->Wait.return_argument = &return_pointer;
3000f468: e28d7004 add r7, sp, #4 <== NOT EXECUTED
POSIX_API_Control *api;
Objects_Locations location;
void *return_pointer;
on_EINTR:
the_thread = _Thread_Get( thread, &location );
3000f46c: e1a0100d mov r1, sp <== NOT EXECUTED 3000f470: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f474: eb000cef bl 30012838 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000f478: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000f47c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000f480: 0a000002 beq 3000f490 <pthread_join+0x40> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000f484: e3a00003 mov r0, #3 <== NOT EXECUTED
}
3000f488: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000f48c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
on_EINTR:
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000f490: e590c0f4 ldr ip, [r0, #244] ; 0xf4 <== NOT EXECUTED
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
3000f494: e59c2040 ldr r2, [ip, #64] ; 0x40 <== NOT EXECUTED 3000f498: e3520000 cmp r2, #0 <== NOT EXECUTED
(STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT)
);
} else {
_Thread_Executing->Wait.return_argument = &return_pointer;
_Thread_queue_Enter_critical_section( &api->Join_List );
_Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT );
3000f49c: e59f208c ldr r2, [pc, #140] ; 3000f530 <pthread_join+0xe0> <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
3000f4a0: 0a00001a beq 3000f510 <pthread_join+0xc0> <== NOT EXECUTED 3000f4a4: e594e008 ldr lr, [r4, #8] <== NOT EXECUTED
_Thread_Enable_dispatch();
return EINVAL;
}
if ( _Thread_Is_executing( the_thread ) ) {
3000f4a8: e150000e cmp r0, lr <== NOT EXECUTED 3000f4ac: 0a00001a beq 3000f51c <pthread_join+0xcc> <== NOT EXECUTED
/*
* Put ourself on the threads join list
*/
if ( the_thread->current_state ==
3000f4b0: e5908010 ldr r8, [r0, #16] <== NOT EXECUTED 3000f4b4: e1580005 cmp r8, r5 <== NOT EXECUTED 3000f4b8: 0a00000f beq 3000f4fc <pthread_join+0xac> <== 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;
3000f4bc: e3a03001 mov r3, #1 <== NOT EXECUTED
_Thread_Clear_state(
the_thread,
(STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT)
);
} else {
_Thread_Executing->Wait.return_argument = &return_pointer;
3000f4c0: e58e7028 str r7, [lr, #40] ; 0x28 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &api->Join_List );
_Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT );
3000f4c4: e28c0044 add r0, ip, #68 ; 0x44 <== NOT EXECUTED 3000f4c8: e58c3074 str r3, [ip, #116] ; 0x74 <== NOT EXECUTED 3000f4cc: eb000e07 bl 30012cf0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
}
_Thread_Enable_dispatch();
3000f4d0: eb000cd0 bl 30012818 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( _Thread_Executing->Wait.return_code == EINTR )
3000f4d4: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000f4d8: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000f4dc: e3530004 cmp r3, #4 <== NOT EXECUTED 3000f4e0: 0affffe1 beq 3000f46c <pthread_join+0x1c> <== NOT EXECUTED
goto on_EINTR;
if ( value_ptr )
3000f4e4: e35a0000 cmp sl, #0 <== NOT EXECUTED
*value_ptr = return_pointer;
return 0;
3000f4e8: 01a0000a moveq r0, sl <== NOT EXECUTED
if ( _Thread_Executing->Wait.return_code == EINTR )
goto on_EINTR;
if ( value_ptr )
*value_ptr = return_pointer;
3000f4ec: 159d3004 ldrne r3, [sp, #4] <== NOT EXECUTED
return 0;
3000f4f0: 13a00000 movne r0, #0 <== NOT EXECUTED
if ( _Thread_Executing->Wait.return_code == EINTR )
goto on_EINTR;
if ( value_ptr )
*value_ptr = return_pointer;
3000f4f4: 158a3000 strne r3, [sl] <== NOT EXECUTED 3000f4f8: eaffffe2 b 3000f488 <pthread_join+0x38> <== 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;
3000f4fc: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
_Thread_Clear_state(
3000f500: 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;
3000f504: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
_Thread_Clear_state(
3000f508: eb000bcd bl 30012444 <_Thread_Clear_state> <== NOT EXECUTED 3000f50c: eaffffef b 3000f4d0 <pthread_join+0x80> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
_Thread_Enable_dispatch();
3000f510: eb000cc0 bl 30012818 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EINVAL;
3000f514: e3a00016 mov r0, #22 <== NOT EXECUTED 3000f518: eaffffda b 3000f488 <pthread_join+0x38> <== NOT EXECUTED
}
if ( _Thread_Is_executing( the_thread ) ) {
_Thread_Enable_dispatch();
3000f51c: eb000cbd bl 30012818 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EDEADLK;
3000f520: e3a0002d mov r0, #45 ; 0x2d <== NOT EXECUTED 3000f524: eaffffd7 b 3000f488 <pthread_join+0x38> <== NOT EXECUTED
3000a690 <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;
3000a690: e59f30d8 ldr r3, [pc, #216] ; 3000a770 <pthread_key_create+0xe0>
*/
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
3000a694: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000a698: e5932000 ldr r2, [r3]
3000a69c: e1a09000 mov r9, r0
++level;
3000a6a0: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000a6a4: e5832000 str r2, [r3] 3000a6a8: e1a04001 mov r4, 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 );
3000a6ac: e59f00c0 ldr r0, [pc, #192] ; 3000a774 <pthread_key_create+0xe4> 3000a6b0: eb000906 bl 3000cad0 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
3000a6b4: e2508000 subs r8, r0, #0
3000a6b8: 0a000021 beq 3000a744 <pthread_key_create+0xb4>
_Thread_Enable_dispatch();
return EAGAIN;
}
the_key->destructor = destructor;
3000a6bc: e59f70b4 ldr r7, [pc, #180] ; 3000a778 <pthread_key_create+0xe8> 3000a6c0: e5884010 str r4, [r8, #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++ ) {
3000a6c4: e3a05001 mov r5, #1
if ( !the_key ) {
_Thread_Enable_dispatch();
return EAGAIN;
}
the_key->destructor = destructor;
3000a6c8: e1a04008 mov r4, r8
* 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;
3000a6cc: e3a0a000 mov sl, #0 3000a6d0: e584a018 str sl, [r4, #24]
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
3000a6d4: e5b73004 ldr r3, [r7, #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;
3000a6d8: e3a06000 mov r6, #0
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
3000a6dc: e5933004 ldr r3, [r3, #4]
* 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++ ) {
3000a6e0: e2855001 add r5, r5, #1
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
3000a6e4: e1d3b1b0 ldrh fp, [r3, #16] 3000a6e8: e28bb001 add fp, fp, #1
true,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
3000a6ec: e1a0b10b lsl fp, fp, #2
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
3000a6f0: e1a0000b mov r0, fp 3000a6f4: eb001244 bl 3000f00c <_Workspace_Allocate>
if ( !table ) {
3000a6f8: e2503000 subs r3, r0, #0
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
memset( table, '\0', bytes_to_allocate );
3000a6fc: e1a01006 mov r1, r6 3000a700: e1a0200b mov r2, fp
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
3000a704: 0a000011 beq 3000a750 <pthread_key_create+0xc0>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
3000a708: e5843018 str r3, [r4, #24]
memset( table, '\0', bytes_to_allocate );
3000a70c: eb0025b7 bl 30013df0 <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++ ) {
3000a710: e3550004 cmp r5, #4 3000a714: e2844004 add r4, r4, #4
3000a718: 1affffec bne 3000a6d0 <pthread_key_create+0x40>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a71c: e59f2050 ldr r2, [pc, #80] ; 3000a774 <pthread_key_create+0xe4>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000a720: e5983008 ldr r3, [r8, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a724: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000a728: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a72c: e7828721 str r8, [r2, r1, lsr #14]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000a730: e588600c str r6, [r8, #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;
3000a734: e5893000 str r3, [r9]
_Thread_Enable_dispatch();
3000a738: eb000dc1 bl 3000de44 <_Thread_Enable_dispatch>
return 0;
3000a73c: e1a00006 mov r0, r6
}
3000a740: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
_Thread_Enable_dispatch();
3000a744: eb000dbe bl 3000de44 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000a748: e3a0000b mov r0, #11 <== NOT EXECUTED
3000a74c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
_POSIX_Keys_Free_memory( the_key );
3000a750: e1a00008 mov r0, r8 3000a754: eb000020 bl 3000a7dc <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
3000a758: e59f0014 ldr r0, [pc, #20] ; 3000a774 <pthread_key_create+0xe4> 3000a75c: e1a01008 mov r1, r8 3000a760: eb0009b8 bl 3000ce48 <_Objects_Free>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
3000a764: eb000db6 bl 3000de44 <_Thread_Enable_dispatch>
return ENOMEM;
3000a768: e3a0000c mov r0, #12
3000a76c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3001e09c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
3001e09c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
3001e0a0: e2516000 subs r6, r1, #0 <== NOT EXECUTED
int pthread_kill(
pthread_t thread,
int sig
)
{
3001e0a4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
3001e0a8: 0a000027 beq 3001e14c <pthread_kill+0xb0> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3001e0ac: e2467001 sub r7, r6, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
3001e0b0: e357001f cmp r7, #31 <== NOT EXECUTED 3001e0b4: 8a000024 bhi 3001e14c <pthread_kill+0xb0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
3001e0b8: e1a0100d mov r1, sp <== NOT EXECUTED 3001e0bc: ebffbc25 bl 3000d158 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3001e0c0: e59d8000 ldr r8, [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 );
3001e0c4: e1a04000 mov r4, r0 <== NOT EXECUTED
switch ( location ) {
3001e0c8: e3580000 cmp r8, #0 <== NOT EXECUTED 3001e0cc: 1a000023 bne 3001e160 <pthread_kill+0xc4> <== NOT EXECUTED 3001e0d0: e59f009c ldr r0, [pc, #156] ; 3001e174 <pthread_kill+0xd8> <== NOT EXECUTED 3001e0d4: ebffb434 bl 3000b1ac <_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 ) {
3001e0d8: e59f3098 ldr r3, [pc, #152] ; 3001e178 <pthread_kill+0xdc> <== NOT EXECUTED 3001e0dc: e0862086 add r2, r6, r6, lsl #1 <== NOT EXECUTED 3001e0e0: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED 3001e0e4: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
* If sig == 0 then just validate arguments
*/
_POSIX_signals_Add_post_switch_extension();
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3001e0e8: e59430f4 ldr r3, [r4, #244] ; 0xf4 <== NOT EXECUTED
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
3001e0ec: e3520001 cmp r2, #1 <== NOT EXECUTED 3001e0f0: 0a000012 beq 3001e140 <pthread_kill+0xa4> <== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
3001e0f4: e59320d4 ldr r2, [r3, #212] ; 0xd4 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3001e0f8: e3a05001 mov r5, #1 <== NOT EXECUTED 3001e0fc: e1827715 orr r7, r2, r5, lsl r7 <== NOT EXECUTED
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
3001e100: e1a00004 mov r0, r4 <== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
3001e104: e58370d4 str r7, [r3, #212] ; 0xd4 <== NOT EXECUTED
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
3001e108: e1a02008 mov r2, r8 <== NOT EXECUTED 3001e10c: e1a01006 mov r1, r6 <== NOT EXECUTED 3001e110: ebffff97 bl 3001df74 <_POSIX_signals_Unblock_thread> <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
3001e114: e59f3060 ldr r3, [pc, #96] ; 3001e17c <pthread_kill+0xe0> <== NOT EXECUTED 3001e118: e5932000 ldr r2, [r3] <== NOT EXECUTED 3001e11c: e3520000 cmp r2, #0 <== NOT EXECUTED 3001e120: 0a000002 beq 3001e130 <pthread_kill+0x94> <== NOT EXECUTED 3001e124: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 3001e128: e1540002 cmp r4, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3001e12c: 05c35004 strbeq r5, [r3, #4] <== NOT EXECUTED
}
_Thread_Enable_dispatch();
3001e130: ebffbc00 bl 3000d138 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3001e134: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
3001e138: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001e13c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
_Thread_Enable_dispatch();
3001e140: ebffbbfc bl 3000d138 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3001e144: e1a00008 mov r0, r8 <== NOT EXECUTED 3001e148: eafffffa b 3001e138 <pthread_kill+0x9c> <== NOT EXECUTED
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
3001e14c: ebffd1c5 bl 30012868 <__errno> <== NOT EXECUTED 3001e150: e3a03016 mov r3, #22 <== NOT EXECUTED 3001e154: e5803000 str r3, [r0] <== NOT EXECUTED 3001e158: e3e00000 mvn r0, #0 <== NOT EXECUTED 3001e15c: eafffff5 b 3001e138 <pthread_kill+0x9c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
3001e160: ebffd1c0 bl 30012868 <__errno> <== NOT EXECUTED 3001e164: e3a03003 mov r3, #3 <== NOT EXECUTED 3001e168: e5803000 str r3, [r0] <== NOT EXECUTED 3001e16c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3001e170: eafffff0 b 3001e138 <pthread_kill+0x9c> <== NOT EXECUTED
3000c954 <pthread_mutex_destroy>:
*/
int pthread_mutex_destroy(
pthread_mutex_t *mutex
)
{
3000c954: e92d4030 push {r4, r5, lr}
3000c958: e24dd004 sub sp, sp, #4
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000c95c: e1a0100d mov r1, sp 3000c960: eb000019 bl 3000c9cc <_POSIX_Mutex_Get>
switch ( location ) {
3000c964: e59d4000 ldr r4, [sp]
)
{
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000c968: e1a05000 mov r5, r0
switch ( location ) {
3000c96c: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000c970: 13a00016 movne r0, #22
{
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
switch ( location ) {
3000c974: 1a000004 bne 3000c98c <pthread_mutex_destroy+0x38>
/*
* 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 ) ) {
3000c978: e5953064 ldr r3, [r5, #100] ; 0x64 3000c97c: e3530000 cmp r3, #0
3000c980: 1a000003 bne 3000c994 <pthread_mutex_destroy+0x40>
_Thread_Enable_dispatch();
3000c984: eb000f32 bl 30010654 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000c988: e3a00010 mov r0, #16 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000c98c: e28dd004 add sp, sp, #4
3000c990: e8bd8030 pop {r4, r5, pc}
if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) {
_Thread_Enable_dispatch();
return EBUSY;
}
_Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object );
3000c994: e59f002c ldr r0, [pc, #44] ; 3000c9c8 <pthread_mutex_destroy+0x74> 3000c998: e1a01005 mov r1, r5 3000c99c: eb000a72 bl 3000f36c <_Objects_Close>
_CORE_mutex_Flush( &the_mutex->Mutex, NULL, EINVAL );
3000c9a0: e3a02016 mov r2, #22 3000c9a4: e2850014 add r0, r5, #20 3000c9a8: e1a01004 mov r1, r4 3000c9ac: eb0007c9 bl 3000e8d8 <_CORE_mutex_Flush>
RTEMS_INLINE_ROUTINE void _POSIX_Mutex_Free (
POSIX_Mutex_Control *the_mutex
)
{
_Objects_Free( &_POSIX_Mutex_Information, &the_mutex->Object );
3000c9b0: e59f0010 ldr r0, [pc, #16] ; 3000c9c8 <pthread_mutex_destroy+0x74> 3000c9b4: e1a01005 mov r1, r5 3000c9b8: eb000b26 bl 3000f658 <_Objects_Free>
_POSIX_Mutex_Free( the_mutex );
_Thread_Enable_dispatch();
3000c9bc: eb000f24 bl 30010654 <_Thread_Enable_dispatch>
return 0;
3000c9c0: e1a00004 mov r0, r4 3000c9c4: eafffff0 b 3000c98c <pthread_mutex_destroy+0x38>
3000cae8 <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;
3000cae8: e59f3130 ldr r3, [pc, #304] ; 3000cc20 <pthread_mutex_init+0x138> 3000caec: e3510000 cmp r1, #0
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
3000caf0: 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;
3000caf4: 11a08001 movne r8, r1 3000caf8: 01a08003 moveq r8, r3
/* Check for NULL mutex */
if ( !mutex )
3000cafc: e2504000 subs r4, r0, #0
3000cb00: 0a000002 beq 3000cb10 <pthread_mutex_init+0x28>
}
}
}
#endif
if ( !the_attr->is_initialized )
3000cb04: e5983000 ldr r3, [r8] 3000cb08: e3530000 cmp r3, #0
3000cb0c: 1a000001 bne 3000cb18 <pthread_mutex_init+0x30>
/*
* Validate the priority ceiling field -- should always be valid.
*/
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
return EINVAL;
3000cb10: e3a00016 mov r0, #22 <== NOT EXECUTED
3000cb14: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000cb18: e5983004 ldr r3, [r8, #4] 3000cb1c: e3530001 cmp r3, #1
return ENOSYS;
3000cb20: 03a00058 moveq r0, #88 ; 0x58
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000cb24: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return ENOSYS;
if ( the_attr->process_shared != PTHREAD_PROCESS_PRIVATE )
3000cb28: e3530000 cmp r3, #0
3000cb2c: 1afffff7 bne 3000cb10 <pthread_mutex_init+0x28>
return EINVAL;
/*
* Determine the discipline of the mutex
*/
switch ( the_attr->protocol ) {
3000cb30: e598500c ldr r5, [r8, #12] 3000cb34: e3550001 cmp r5, #1
3000cb38: 0a00002f beq 3000cbfc <pthread_mutex_init+0x114>
3000cb3c: e3550002 cmp r5, #2
3000cb40: 0a00002f beq 3000cc04 <pthread_mutex_init+0x11c>
3000cb44: e3550000 cmp r5, #0
3000cb48: 1afffff0 bne 3000cb10 <pthread_mutex_init+0x28>
}
/*
* Validate the priority ceiling field -- should always be valid.
*/
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
3000cb4c: e5980008 ldr r0, [r8, #8] 3000cb50: eb0000db bl 3000cec4 <_POSIX_Priority_Is_valid> 3000cb54: e3500000 cmp r0, #0
3000cb58: 0affffec beq 3000cb10 <pthread_mutex_init+0x28>
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
/*
* Validate the mutex type and set appropriate SuperCore mutex
* attributes.
*/
switch ( the_attr->type ) {
3000cb5c: e5983010 ldr r3, [r8, #16] 3000cb60: e3530003 cmp r3, #3
3000cb64: 8a000028 bhi 3000cc0c <pthread_mutex_init+0x124>
*
* 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;
3000cb68: e59f30b4 ldr r3, [pc, #180] ; 3000cc24 <pthread_mutex_init+0x13c> 3000cb6c: e5932000 ldr r2, [r3]
++level;
3000cb70: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000cb74: 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 );
3000cb78: e59f70a8 ldr r7, [pc, #168] ; 3000cc28 <pthread_mutex_init+0x140> 3000cb7c: e1a00007 mov r0, r7 3000cb80: eb0009d6 bl 3000f2e0 <_Objects_Allocate>
*/
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
3000cb84: e2506000 subs r6, r0, #0
3000cb88: 0a000021 beq 3000cc14 <pthread_mutex_init+0x12c>
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000cb8c: e59f3098 ldr r3, [pc, #152] ; 3000cc2c <pthread_mutex_init+0x144>
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;
3000cb90: e598c014 ldr ip, [r8, #20] 3000cb94: e5982008 ldr r2, [r8, #8] 3000cb98: e5d30000 ldrb r0, [r3]
if ( !the_mutex ) {
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
3000cb9c: e598e004 ldr lr, [r8, #4]
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000cba0: e27cc001 rsbs ip, ip, #1
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
3000cba4: e3a03001 mov r3, #1
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;
3000cba8: 33a0c000 movcc ip, #0 3000cbac: e0620000 rsb r0, r2, r0
the_mutex_attr->discipline = the_discipline;
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
3000cbb0: e2861054 add r1, r6, #84 ; 0x54 3000cbb4: e1a02003 mov r2, r3
if ( !the_mutex ) {
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
3000cbb8: e586e010 str lr, [r6, #16] 3000cbbc: e586c054 str ip, [r6, #84] ; 0x54
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;
3000cbc0: e5c63058 strb r3, [r6, #88] ; 0x58
the_mutex_attr->priority_ceiling =
3000cbc4: e5860060 str r0, [r6, #96] ; 0x60
_POSIX_Priority_To_core( the_attr->prio_ceiling );
the_mutex_attr->discipline = the_discipline;
3000cbc8: e586505c str r5, [r6, #92] ; 0x5c
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
3000cbcc: e2860014 add r0, r6, #20 3000cbd0: eb000741 bl 3000e8dc <_CORE_mutex_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000cbd4: e5963008 ldr r3, [r6, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000cbd8: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000cbdc: e1a01803 lsl r1, r3, #16
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000cbe0: e3a05000 mov r5, #0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000cbe4: e7826721 str r6, [r2, r1, lsr #14]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000cbe8: e586500c str r5, [r6, #12]
CORE_MUTEX_UNLOCKED
);
_Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 );
*mutex = the_mutex->Object.id;
3000cbec: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
3000cbf0: eb000e97 bl 30010654 <_Thread_Enable_dispatch>
return 0;
3000cbf4: e1a00005 mov r0, r5
3000cbf8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
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;
3000cbfc: e3a05002 mov r5, #2 <== NOT EXECUTED 3000cc00: eaffffd1 b 3000cb4c <pthread_mutex_init+0x64> <== NOT EXECUTED
break;
case PTHREAD_PRIO_PROTECT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
3000cc04: e3a05003 mov r5, #3 <== NOT EXECUTED
break;
3000cc08: eaffffcf b 3000cb4c <pthread_mutex_init+0x64> <== NOT EXECUTED
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
break;
default:
return EINVAL;
3000cc0c: e3a00016 mov r0, #22 <== NOT EXECUTED
*mutex = the_mutex->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000cc10: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
_Thread_Enable_dispatch();
3000cc14: eb000e8e bl 30010654 <_Thread_Enable_dispatch>
return EAGAIN;
3000cc18: e3a0000b mov r0, #11
3000cc1c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000cca4 <pthread_mutex_setprioceiling>:
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
3000cca4: e92d41f0 push {r4, r5, r6, r7, r8, lr}
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
Priority_Control the_priority;
if ( !old_ceiling )
3000cca8: e2526000 subs r6, r2, #0
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
3000ccac: e24dd004 sub sp, sp, #4 3000ccb0: e1a04000 mov r4, r0 3000ccb4: e1a05001 mov r5, r1
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
Priority_Control the_priority;
if ( !old_ceiling )
3000ccb8: 0a000003 beq 3000cccc <pthread_mutex_setprioceiling+0x28>
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000ccbc: e1a00001 mov r0, r1 3000ccc0: eb00007f bl 3000cec4 <_POSIX_Priority_Is_valid> 3000ccc4: e3500000 cmp r0, #0
3000ccc8: 1a000002 bne 3000ccd8 <pthread_mutex_setprioceiling+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000cccc: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000ccd0: e28dd004 add sp, sp, #4
3000ccd4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000ccd8: e59f7054 ldr r7, [pc, #84] ; 3000cd34 <pthread_mutex_setprioceiling+0x90>
/*
* Must acquire the mutex before we can change it's ceiling.
* POSIX says block until we acquire it.
*/
(void) pthread_mutex_lock( mutex );
3000ccdc: e1a00004 mov r0, r4 3000cce0: e5d78000 ldrb r8, [r7] 3000cce4: ebffffd1 bl 3000cc30 <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 );
3000cce8: e1a00004 mov r0, r4 3000ccec: e1a0100d mov r1, sp 3000ccf0: ebffff35 bl 3000c9cc <_POSIX_Mutex_Get>
switch ( location ) {
3000ccf4: e59d4000 ldr r4, [sp] 3000ccf8: e3540000 cmp r4, #0
3000ccfc: 1afffff2 bne 3000cccc <pthread_mutex_setprioceiling+0x28>
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000cd00: e5903060 ldr r3, [r0, #96] ; 0x60 3000cd04: e5d72000 ldrb r2, [r7]
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000cd08: e0655008 rsb r5, r5, r8
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000cd0c: e0633002 rsb r3, r3, r2
case OBJECTS_LOCAL:
*old_ceiling = _POSIX_Priority_From_core(
3000cd10: e5863000 str r3, [r6]
);
the_mutex->Mutex.Attributes.priority_ceiling = the_priority;
/*
* We are required to unlock the mutex before we return.
*/
_CORE_mutex_Surrender(
3000cd14: e5901008 ldr r1, [r0, #8] 3000cd18: e1a02004 mov r2, r4
case OBJECTS_LOCAL:
*old_ceiling = _POSIX_Priority_From_core(
the_mutex->Mutex.Attributes.priority_ceiling
);
the_mutex->Mutex.Attributes.priority_ceiling = the_priority;
3000cd1c: e5805060 str r5, [r0, #96] ; 0x60
/*
* We are required to unlock the mutex before we return.
*/
_CORE_mutex_Surrender(
3000cd20: e2800014 add r0, r0, #20 3000cd24: eb00076f bl 3000eae8 <_CORE_mutex_Surrender>
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
3000cd28: eb000e49 bl 30010654 <_Thread_Enable_dispatch>
return 0;
3000cd2c: e1a00004 mov r0, r4 3000cd30: eaffffe6 b 3000ccd0 <pthread_mutex_setprioceiling+0x2c>
3000cd38 <pthread_mutex_timedlock>:
*/
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
3000cd38: e92d4030 push {r4, r5, lr}
3000cd3c: e24dd004 sub sp, sp, #4
3000cd40: e1a05000 mov r5, 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 );
3000cd44: e1a00001 mov r0, r1 3000cd48: e1a0100d mov r1, sp 3000cd4c: eb00002e bl 3000ce0c <_POSIX_Absolute_timeout_to_ticks> 3000cd50: e1a04000 mov r4, r0
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
3000cd54: e3540003 cmp r4, #3
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
3000cd58: e1a00005 mov r0, r5
* 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 );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
3000cd5c: 0a000006 beq 3000cd7c <pthread_mutex_timedlock+0x44>
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
3000cd60: e3a01000 mov r1, #0 3000cd64: e59d2000 ldr r2, [sp] 3000cd68: ebffffb3 bl 3000cc3c <_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) ) {
3000cd6c: e3500010 cmp r0, #16
3000cd70: 0a000005 beq 3000cd8c <pthread_mutex_timedlock+0x54>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
3000cd74: e28dd004 add sp, sp, #4
3000cd78: e8bd8030 pop {r4, r5, pc}
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
3000cd7c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000cd80: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000cd84: ebffffac bl 3000cc3c <_POSIX_Mutex_Lock_support> <== NOT EXECUTED 3000cd88: eafffff9 b 3000cd74 <pthread_mutex_timedlock+0x3c> <== 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 )
3000cd8c: e3540000 cmp r4, #0 <== NOT EXECUTED
return EINVAL;
3000cd90: 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 )
3000cd94: 0afffff6 beq 3000cd74 <pthread_mutex_timedlock+0x3c> <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000cd98: e2440001 sub r0, r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
3000cd9c: e3500001 cmp r0, #1 <== NOT EXECUTED 3000cda0: 83a00010 movhi r0, #16 <== NOT EXECUTED 3000cda4: 93a00074 movls r0, #116 ; 0x74 <== NOT EXECUTED 3000cda8: eafffff1 b 3000cd74 <pthread_mutex_timedlock+0x3c> <== NOT EXECUTED
3000c7ac <pthread_mutexattr_destroy>:
*/
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000c7ac: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000c7b0: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000c7b4: 012fff1e bxeq lr <== NOT EXECUTED 3000c7b8: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c7bc: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000c7c0: 13a00000 movne r0, #0 <== NOT EXECUTED 3000c7c4: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000c7c8: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000c7cc: e12fff1e bx lr <== NOT EXECUTED
3000c7d0 <pthread_mutexattr_getprioceiling>:
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000c7d0: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000c7d4: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000c7d8: 012fff1e bxeq lr <== NOT EXECUTED 3000c7dc: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000c7e0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c7e4: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*prioceiling = attr->prio_ceiling;
3000c7e8: 15902008 ldrne r2, [r0, #8] <== NOT EXECUTED
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000c7ec: 13a03000 movne r3, #0 <== NOT EXECUTED 3000c7f0: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*prioceiling = attr->prio_ceiling;
return 0;
3000c7f4: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
return EINVAL;
*prioceiling = attr->prio_ceiling;
3000c7f8: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
return EINVAL;
3000c7fc: 03a00016 moveq r0, #22 <== NOT EXECUTED
*prioceiling = attr->prio_ceiling;
return 0;
}
3000c800: e12fff1e bx lr <== NOT EXECUTED
3000c804 <pthread_mutexattr_getprotocol>:
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000c804: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000c808: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000c80c: 012fff1e bxeq lr <== NOT EXECUTED 3000c810: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000c814: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c818: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*protocol = attr->protocol;
3000c81c: 1590200c ldrne r2, [r0, #12] <== NOT EXECUTED
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000c820: 13a03000 movne r3, #0 <== NOT EXECUTED 3000c824: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*protocol = attr->protocol;
return 0;
3000c828: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !protocol )
return EINVAL;
*protocol = attr->protocol;
3000c82c: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
return EINVAL;
3000c830: 03a00016 moveq r0, #22 <== NOT EXECUTED
*protocol = attr->protocol;
return 0;
}
3000c834: e12fff1e bx lr <== NOT EXECUTED
3000c838 <pthread_mutexattr_getpshared>:
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000c838: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000c83c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000c840: 012fff1e bxeq lr <== NOT EXECUTED 3000c844: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000c848: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c84c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000c850: 15902004 ldrne r2, [r0, #4] <== NOT EXECUTED
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000c854: 13a03000 movne r3, #0 <== NOT EXECUTED 3000c858: 03a03001 moveq r3, #1 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
return 0;
3000c85c: 11a00003 movne r0, r3 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !pshared )
return EINVAL;
*pshared = attr->process_shared;
3000c860: 15812000 strne r2, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
return EINVAL;
3000c864: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
}
3000c868: e12fff1e bx lr <== NOT EXECUTED
3000a2d0 <pthread_mutexattr_gettype>:
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
if ( !attr )
3000a2d0: e3500000 cmp r0, #0
3000a2d4: 0a000002 beq 3000a2e4 <pthread_mutexattr_gettype+0x14>
return EINVAL;
if ( !attr->is_initialized )
3000a2d8: e5903000 ldr r3, [r0] 3000a2dc: e3530000 cmp r3, #0
3000a2e0: 1a000001 bne 3000a2ec <pthread_mutexattr_gettype+0x1c>
return EINVAL;
3000a2e4: e3a00016 mov r0, #22 3000a2e8: e12fff1e bx lr
if ( !type )
3000a2ec: e3510000 cmp r1, #0
3000a2f0: 0a000003 beq 3000a304 <pthread_mutexattr_gettype+0x34>
return EINVAL;
*type = attr->type;
3000a2f4: e5903010 ldr r3, [r0, #16]
return 0;
3000a2f8: e3a00000 mov r0, #0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
3000a2fc: e5813000 str r3, [r1]
return 0;
3000a300: e12fff1e bx lr
if ( !attr->is_initialized )
return EINVAL;
if ( !type )
return EINVAL;
3000a304: e3a00016 mov r0, #22 <== NOT EXECUTED
*type = attr->type;
return 0;
}
3000a308: e12fff1e bx lr <== NOT EXECUTED
3000c8a0 <pthread_mutexattr_setprioceiling>:
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
3000c8a0: e92d4010 push {r4, lr} <== NOT EXECUTED
if ( !attr || !attr->is_initialized )
3000c8a4: e2504000 subs r4, r0, #0 <== NOT EXECUTED
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
3000c8a8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
if ( !attr || !attr->is_initialized )
3000c8ac: 0a000002 beq 3000c8bc <pthread_mutexattr_setprioceiling+0x1c><== NOT EXECUTED 3000c8b0: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000c8b4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c8b8: 1a000002 bne 3000c8c8 <pthread_mutexattr_setprioceiling+0x28><== NOT EXECUTED
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
return EINVAL;
3000c8bc: e3a00016 mov r0, #22 <== NOT EXECUTED
attr->prio_ceiling = prioceiling;
return 0;
}
3000c8c0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c8c4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000c8c8: e1a00001 mov r0, r1 <== NOT EXECUTED 3000c8cc: e58d1000 str r1, [sp] <== NOT EXECUTED 3000c8d0: eb00017b bl 3000cec4 <_POSIX_Priority_Is_valid> <== NOT EXECUTED 3000c8d4: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000c8d8: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
attr->prio_ceiling = prioceiling;
3000c8dc: 15841008 strne r1, [r4, #8] <== NOT EXECUTED
return 0;
3000c8e0: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000c8e4: 0afffff4 beq 3000c8bc <pthread_mutexattr_setprioceiling+0x1c><== NOT EXECUTED 3000c8e8: eafffff4 b 3000c8c0 <pthread_mutexattr_setprioceiling+0x20><== NOT EXECUTED
3000c8ec <pthread_mutexattr_setprotocol>:
int pthread_mutexattr_setprotocol(
pthread_mutexattr_t *attr,
int protocol
)
{
if ( !attr || !attr->is_initialized )
3000c8ec: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c8f0: 0a000002 beq 3000c900 <pthread_mutexattr_setprotocol+0x14> <== NOT EXECUTED 3000c8f4: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000c8f8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c8fc: 1a000001 bne 3000c908 <pthread_mutexattr_setprotocol+0x1c> <== NOT EXECUTED
return EINVAL;
3000c900: e3a00016 mov r0, #22 <== NOT EXECUTED 3000c904: e12fff1e bx lr <== NOT EXECUTED
switch ( protocol ) {
3000c908: e3510002 cmp r1, #2 <== NOT EXECUTED
case PTHREAD_PRIO_NONE:
case PTHREAD_PRIO_INHERIT:
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
3000c90c: 9580100c strls r1, [r0, #12] <== NOT EXECUTED
return 0;
3000c910: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( protocol ) {
3000c914: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
return 0;
default:
return EINVAL;
3000c918: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000c91c: e12fff1e bx lr <== NOT EXECUTED
3000c920 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
3000c920: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c924: 0a000002 beq 3000c934 <pthread_mutexattr_setpshared+0x14> <== NOT EXECUTED 3000c928: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000c92c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c930: 1a000001 bne 3000c93c <pthread_mutexattr_setpshared+0x1c> <== NOT EXECUTED
return EINVAL;
3000c934: e3a00016 mov r0, #22 <== NOT EXECUTED 3000c938: e12fff1e bx lr <== NOT EXECUTED
switch ( pshared ) {
3000c93c: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000c940: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000c944: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000c948: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000c94c: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000c950: e12fff1e bx lr <== NOT EXECUTED
3000b000 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
3000b000: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !once_control || !init_routine )
3000b004: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b008: 13510000 cmpne r1, #0 <== NOT EXECUTED 3000b00c: e1a04000 mov r4, r0 <== NOT EXECUTED
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
3000b010: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
if ( !once_control || !init_routine )
3000b014: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b018: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000b01c: e1a05001 mov r5, r1 <== NOT EXECUTED
return EINVAL;
3000b020: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
3000b024: 1a000001 bne 3000b030 <pthread_once+0x30> <== NOT EXECUTED
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
3000b028: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b02c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
3000b030: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000b034: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b038: 1afffffa bne 3000b028 <pthread_once+0x28> <== NOT EXECUTED
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
3000b03c: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED 3000b040: e1a01000 mov r1, r0 <== NOT EXECUTED 3000b044: e1a0200d mov r2, sp <== NOT EXECUTED 3000b048: eb0002fa bl 3000bc38 <rtems_task_mode> <== NOT EXECUTED
if ( !once_control->init_executed ) {
3000b04c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000b050: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b054: 0a000005 beq 3000b070 <pthread_once+0x70> <== NOT EXECUTED
once_control->is_initialized = true;
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
3000b058: e59d0000 ldr r0, [sp] <== NOT EXECUTED 3000b05c: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 3000b060: e1a0200d mov r2, sp <== NOT EXECUTED 3000b064: eb0002f3 bl 3000bc38 <rtems_task_mode> <== NOT EXECUTED
} return 0;
3000b068: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b06c: eaffffed b 3000b028 <pthread_once+0x28> <== NOT EXECUTED
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( !once_control->init_executed ) {
once_control->is_initialized = true;
3000b070: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b074: e5843000 str r3, [r4] <== NOT EXECUTED
once_control->init_executed = true;
3000b078: e5843004 str r3, [r4, #4] <== NOT EXECUTED
(*init_routine)();
3000b07c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b080: e12fff15 bx r5 <== NOT EXECUTED 3000b084: eafffff3 b 3000b058 <pthread_once+0x58> <== NOT EXECUTED
3000baf8 <pthread_rwlock_destroy>:
* source of the error.
*/
int pthread_rwlock_destroy(
pthread_rwlock_t *rwlock
)
{
3000baf8: e92d4030 push {r4, r5, lr}
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
3000bafc: e2503000 subs r3, r0, #0
* source of the error.
*/
int pthread_rwlock_destroy(
pthread_rwlock_t *rwlock
)
{
3000bb00: e24dd004 sub sp, sp, #4
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
3000bb04: 0a00000e beq 3000bb44 <pthread_rwlock_destroy+0x4c>
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
3000bb08: e5931000 ldr r1, [r3] 3000bb0c: e59f0060 ldr r0, [pc, #96] ; 3000bb74 <pthread_rwlock_destroy+0x7c> 3000bb10: e1a0200d mov r2, sp 3000bb14: eb000b72 bl 3000e8e4 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000bb18: e59d3000 ldr r3, [sp] 3000bb1c: e1a04000 mov r4, r0 3000bb20: e3530000 cmp r3, #0
3000bb24: 1a000006 bne 3000bb44 <pthread_rwlock_destroy+0x4c>
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 ) {
3000bb28: e2800010 add r0, r0, #16 3000bb2c: eb00112a bl 3000ffdc <_Thread_queue_First> 3000bb30: e2505000 subs r5, r0, #0
3000bb34: 0a000005 beq 3000bb50 <pthread_rwlock_destroy+0x58>
_Thread_Enable_dispatch();
3000bb38: eb000f11 bl 3000f784 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000bb3c: e3a00010 mov r0, #16 <== NOT EXECUTED 3000bb40: ea000000 b 3000bb48 <pthread_rwlock_destroy+0x50> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000bb44: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000bb48: e28dd004 add sp, sp, #4
3000bb4c: e8bd8030 pop {r4, r5, pc}
/*
* POSIX doesn't require behavior when it is locked.
*/
_Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object );
3000bb50: e59f001c ldr r0, [pc, #28] ; 3000bb74 <pthread_rwlock_destroy+0x7c> 3000bb54: e1a01004 mov r1, r4 3000bb58: eb000a4f bl 3000e49c <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free (
POSIX_RWLock_Control *the_RWLock
)
{
_Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object );
3000bb5c: e59f0010 ldr r0, [pc, #16] ; 3000bb74 <pthread_rwlock_destroy+0x7c> 3000bb60: e1a01004 mov r1, r4 3000bb64: eb000b07 bl 3000e788 <_Objects_Free>
_POSIX_RWLock_Free( the_rwlock );
_Thread_Enable_dispatch();
3000bb68: eb000f05 bl 3000f784 <_Thread_Enable_dispatch>
return 0;
3000bb6c: e1a00005 mov r0, r5 3000bb70: eafffff4 b 3000bb48 <pthread_rwlock_destroy+0x50>
3000af30 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
3000af30: e92d40f0 push {r4, r5, r6, r7, lr}
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
3000af34: e2504000 subs r4, r0, #0
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
3000af38: e24dd00c sub sp, sp, #12
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
3000af3c: 0a000004 beq 3000af54 <pthread_rwlock_init+0x24>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
3000af40: e3510000 cmp r1, #0
3000af44: 0a00001e beq 3000afc4 <pthread_rwlock_init+0x94>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
3000af48: e5913000 ldr r3, [r1] 3000af4c: e3530000 cmp r3, #0
3000af50: 1a000002 bne 3000af60 <pthread_rwlock_init+0x30>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
3000af54: e3a00016 mov r0, #22 <== NOT EXECUTED
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000af58: e28dd00c add sp, sp, #12
3000af5c: e8bd80f0 pop {r4, r5, r6, r7, pc}
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
switch ( the_attr->process_shared ) {
3000af60: e5915004 ldr r5, [r1, #4] 3000af64: e3550000 cmp r5, #0
3000af68: 1afffff9 bne 3000af54 <pthread_rwlock_init+0x24>
*
* 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;
3000af6c: e59f306c ldr r3, [pc, #108] ; 3000afe0 <pthread_rwlock_init+0xb0>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
3000af70: e58d5008 str r5, [sp, #8] 3000af74: e5932000 ldr r2, [r3]
++level;
3000af78: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000af7c: 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 *)
3000af80: e59f705c ldr r7, [pc, #92] ; 3000afe4 <pthread_rwlock_init+0xb4> 3000af84: e1a00007 mov r0, r7 3000af88: eb000a8b bl 3000d9bc <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
3000af8c: e2506000 subs r6, r0, #0
3000af90: 0a00000f beq 3000afd4 <pthread_rwlock_init+0xa4>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
3000af94: e2860010 add r0, r6, #16 3000af98: e28d1008 add r1, sp, #8 3000af9c: eb0008f1 bl 3000d368 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000afa0: e5963008 ldr r3, [r6, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000afa4: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000afa8: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000afac: e7826721 str r6, [r2, r1, lsr #14]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000afb0: e586500c str r5, [r6, #12]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
3000afb4: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
3000afb8: eb000f92 bl 3000ee08 <_Thread_Enable_dispatch>
return 0;
3000afbc: e1a00005 mov r0, r5 3000afc0: eaffffe4 b 3000af58 <pthread_rwlock_init+0x28>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
3000afc4: e1a0000d mov r0, sp <== NOT EXECUTED 3000afc8: eb0001ad bl 3000b684 <pthread_rwlockattr_init> <== NOT EXECUTED
the_attr = &default_attr;
3000afcc: e1a0100d mov r1, sp <== NOT EXECUTED 3000afd0: eaffffdc b 3000af48 <pthread_rwlock_init+0x18> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
3000afd4: eb000f8b bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000afd8: e3a0000b mov r0, #11 <== NOT EXECUTED 3000afdc: eaffffdd b 3000af58 <pthread_rwlock_init+0x28> <== NOT EXECUTED
3000bc30 <pthread_rwlock_rdlock>:
*/
int pthread_rwlock_rdlock(
pthread_rwlock_t *rwlock
)
{
3000bc30: e92d4010 push {r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000bc34: e2504000 subs r4, r0, #0
*/
int pthread_rwlock_rdlock(
pthread_rwlock_t *rwlock
)
{
3000bc38: e24dd008 sub sp, sp, #8
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000bc3c: 0a000006 beq 3000bc5c <pthread_rwlock_rdlock+0x2c>
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
3000bc40: e59f0050 ldr r0, [pc, #80] ; 3000bc98 <pthread_rwlock_rdlock+0x68> 3000bc44: e5941000 ldr r1, [r4] 3000bc48: e28d2004 add r2, sp, #4 3000bc4c: eb000b24 bl 3000e8e4 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000bc50: e59dc004 ldr ip, [sp, #4] 3000bc54: e35c0000 cmp ip, #0
3000bc58: 0a000002 beq 3000bc68 <pthread_rwlock_rdlock+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000bc5c: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000bc60: e28dd008 add sp, sp, #8
3000bc64: e8bd8010 pop {r4, pc}
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000bc68: e5941000 ldr r1, [r4] 3000bc6c: e1a0300c mov r3, ip 3000bc70: e2800010 add r0, r0, #16 3000bc74: e3a02001 mov r2, #1 3000bc78: e58dc000 str ip, [sp] 3000bc7c: eb0007a4 bl 3000db14 <_CORE_RWLock_Obtain_for_reading>
true, /* we are willing to wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
3000bc80: eb000ebf bl 3000f784 <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000bc84: e59f3010 ldr r3, [pc, #16] ; 3000bc9c <pthread_rwlock_rdlock+0x6c> 3000bc88: e5933008 ldr r3, [r3, #8]
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000bc8c: e5930034 ldr r0, [r3, #52] ; 0x34 3000bc90: eb000060 bl 3000be18 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000bc94: eafffff1 b 3000bc60 <pthread_rwlock_rdlock+0x30>
3000bca0 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000bca0: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000bca4: e2505000 subs r5, r0, #0
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000bca8: e24dd00c sub sp, sp, #12 3000bcac: e1a00001 mov r0, r1
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000bcb0: 0a00001c beq 3000bd28 <pthread_rwlock_timedrdlock+0x88>
*
* 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 );
3000bcb4: e28d1008 add r1, sp, #8 3000bcb8: eb0019ab bl 3001236c <_POSIX_Absolute_timeout_to_ticks> 3000bcbc: e5951000 ldr r1, [r5] 3000bcc0: e1a04000 mov r4, r0 3000bcc4: e28d2004 add r2, sp, #4 3000bcc8: e59f0084 ldr r0, [pc, #132] ; 3000bd54 <pthread_rwlock_timedrdlock+0xb4> 3000bccc: eb000b04 bl 3000e8e4 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000bcd0: e59dc004 ldr ip, [sp, #4] 3000bcd4: e35c0000 cmp ip, #0
3000bcd8: 1a000012 bne 3000bd28 <pthread_rwlock_timedrdlock+0x88> 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,
3000bcdc: e2443003 sub r3, r4, #3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000bce0: e5951000 ldr r1, [r5] 3000bce4: e2735000 rsbs r5, r3, #0 3000bce8: e0a55003 adc r5, r5, r3 3000bcec: e2800010 add r0, r0, #16 3000bcf0: e59d3008 ldr r3, [sp, #8] 3000bcf4: e1a02005 mov r2, r5 3000bcf8: e58dc000 str ip, [sp] 3000bcfc: eb000784 bl 3000db14 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
3000bd00: eb000e9f bl 3000f784 <_Thread_Enable_dispatch>
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
3000bd04: e59f304c ldr r3, [pc, #76] ; 3000bd58 <pthread_rwlock_timedrdlock+0xb8>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
3000bd08: e3550000 cmp r5, #0
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
3000bd0c: e5933008 ldr r3, [r3, #8] 3000bd10: e5930034 ldr r0, [r3, #52] ; 0x34
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
3000bd14: 1a000001 bne 3000bd20 <pthread_rwlock_timedrdlock+0x80>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
3000bd18: e3500002 cmp r0, #2
3000bd1c: 0a000004 beq 3000bd34 <pthread_rwlock_timedrdlock+0x94>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000bd20: eb00003c bl 3000be18 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000bd24: ea000000 b 3000bd2c <pthread_rwlock_timedrdlock+0x8c>
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
3000bd28: e3a00016 mov r0, #22 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000bd2c: e28dd00c add sp, sp, #12
3000bd30: e8bd8030 pop {r4, r5, pc}
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000bd34: e3540000 cmp r4, #0 <== NOT EXECUTED 3000bd38: 0afffffa beq 3000bd28 <pthread_rwlock_timedrdlock+0x88> <== NOT EXECUTED
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000bd3c: e2444001 sub r4, r4, #1 <== NOT EXECUTED 3000bd40: e3540001 cmp r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
3000bd44: 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 ||
3000bd48: 9afffff7 bls 3000bd2c <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000bd4c: eb000031 bl 3000be18 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000bd50: eafffff5 b 3000bd2c <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
3000bd5c <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000bd5c: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000bd60: e2505000 subs r5, r0, #0
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000bd64: e24dd00c sub sp, sp, #12 3000bd68: e1a00001 mov r0, r1
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000bd6c: 0a00001c beq 3000bde4 <pthread_rwlock_timedwrlock+0x88>
*
* 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 );
3000bd70: e28d1008 add r1, sp, #8 3000bd74: eb00197c bl 3001236c <_POSIX_Absolute_timeout_to_ticks> 3000bd78: e5951000 ldr r1, [r5] 3000bd7c: e1a04000 mov r4, r0 3000bd80: e28d2004 add r2, sp, #4 3000bd84: e59f0084 ldr r0, [pc, #132] ; 3000be10 <pthread_rwlock_timedwrlock+0xb4> 3000bd88: eb000ad5 bl 3000e8e4 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000bd8c: e59dc004 ldr ip, [sp, #4] 3000bd90: e35c0000 cmp ip, #0
3000bd94: 1a000012 bne 3000bde4 <pthread_rwlock_timedwrlock+0x88>
(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,
3000bd98: e2443003 sub r3, r4, #3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000bd9c: e5951000 ldr r1, [r5] 3000bda0: e2735000 rsbs r5, r3, #0 3000bda4: e0a55003 adc r5, r5, r3 3000bda8: e2800010 add r0, r0, #16 3000bdac: e59d3008 ldr r3, [sp, #8] 3000bdb0: e1a02005 mov r2, r5 3000bdb4: e58dc000 str ip, [sp] 3000bdb8: eb000788 bl 3000dbe0 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
3000bdbc: eb000e70 bl 3000f784 <_Thread_Enable_dispatch>
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
3000bdc0: e59f304c ldr r3, [pc, #76] ; 3000be14 <pthread_rwlock_timedwrlock+0xb8>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
3000bdc4: e3550000 cmp r5, #0
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
3000bdc8: e5933008 ldr r3, [r3, #8] 3000bdcc: e5930034 ldr r0, [r3, #52] ; 0x34
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
3000bdd0: 1a000001 bne 3000bddc <pthread_rwlock_timedwrlock+0x80>
3000bdd4: e3500002 cmp r0, #2
3000bdd8: 0a000004 beq 3000bdf0 <pthread_rwlock_timedwrlock+0x94>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000bddc: eb00000d bl 3000be18 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000bde0: ea000000 b 3000bde8 <pthread_rwlock_timedwrlock+0x8c>
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
3000bde4: e3a00016 mov r0, #22 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000bde8: e28dd00c add sp, sp, #12
3000bdec: e8bd8030 pop {r4, r5, pc}
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000bdf0: e3540000 cmp r4, #0 <== NOT EXECUTED 3000bdf4: 0afffffa beq 3000bde4 <pthread_rwlock_timedwrlock+0x88> <== NOT EXECUTED
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000bdf8: e2444001 sub r4, r4, #1 <== NOT EXECUTED 3000bdfc: e3540001 cmp r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
3000be00: 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 ||
3000be04: 9afffff7 bls 3000bde8 <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000be08: eb000002 bl 3000be18 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000be0c: eafffff5 b 3000bde8 <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
3000be28 <pthread_rwlock_tryrdlock>:
*/
int pthread_rwlock_tryrdlock(
pthread_rwlock_t *rwlock
)
{
3000be28: e92d4010 push {r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000be2c: e2504000 subs r4, r0, #0
*/
int pthread_rwlock_tryrdlock(
pthread_rwlock_t *rwlock
)
{
3000be30: e24dd008 sub sp, sp, #8
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000be34: 0a000006 beq 3000be54 <pthread_rwlock_tryrdlock+0x2c>
3000be38: e59f0050 ldr r0, [pc, #80] ; 3000be90 <pthread_rwlock_tryrdlock+0x68> 3000be3c: e5941000 ldr r1, [r4] 3000be40: e28d2004 add r2, sp, #4 3000be44: eb000aa6 bl 3000e8e4 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000be48: e59dc004 ldr ip, [sp, #4] 3000be4c: e35c0000 cmp ip, #0
3000be50: 0a000002 beq 3000be60 <pthread_rwlock_tryrdlock+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000be54: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000be58: e28dd008 add sp, sp, #8
3000be5c: e8bd8010 pop {r4, pc}
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000be60: e5941000 ldr r1, [r4] 3000be64: e1a0300c mov r3, ip 3000be68: e1a0200c mov r2, ip 3000be6c: e2800010 add r0, r0, #16 3000be70: e58dc000 str ip, [sp] 3000be74: eb000726 bl 3000db14 <_CORE_RWLock_Obtain_for_reading>
0,
NULL
);
_Thread_Enable_dispatch();
3000be78: eb000e41 bl 3000f784 <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000be7c: e59f3010 ldr r3, [pc, #16] ; 3000be94 <pthread_rwlock_tryrdlock+0x6c> 3000be80: e5933008 ldr r3, [r3, #8]
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000be84: e5930034 ldr r0, [r3, #52] ; 0x34 3000be88: ebffffe2 bl 3000be18 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000be8c: eafffff1 b 3000be58 <pthread_rwlock_tryrdlock+0x30>
3000be98 <pthread_rwlock_trywrlock>:
*/
int pthread_rwlock_trywrlock(
pthread_rwlock_t *rwlock
)
{
3000be98: e92d4010 push {r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000be9c: e2504000 subs r4, r0, #0
*/
int pthread_rwlock_trywrlock(
pthread_rwlock_t *rwlock
)
{
3000bea0: e24dd008 sub sp, sp, #8
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000bea4: 0a000006 beq 3000bec4 <pthread_rwlock_trywrlock+0x2c>
3000bea8: e59f0050 ldr r0, [pc, #80] ; 3000bf00 <pthread_rwlock_trywrlock+0x68> 3000beac: e5941000 ldr r1, [r4] 3000beb0: e28d2004 add r2, sp, #4 3000beb4: eb000a8a bl 3000e8e4 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000beb8: e59dc004 ldr ip, [sp, #4] 3000bebc: e35c0000 cmp ip, #0
3000bec0: 0a000002 beq 3000bed0 <pthread_rwlock_trywrlock+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000bec4: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000bec8: e28dd008 add sp, sp, #8
3000becc: e8bd8010 pop {r4, pc}
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000bed0: e5941000 ldr r1, [r4] 3000bed4: e1a0300c mov r3, ip 3000bed8: e1a0200c mov r2, ip 3000bedc: e2800010 add r0, r0, #16 3000bee0: e58dc000 str ip, [sp] 3000bee4: eb00073d bl 3000dbe0 <_CORE_RWLock_Obtain_for_writing>
false, /* we are not willing to wait */
0,
NULL
);
_Thread_Enable_dispatch();
3000bee8: eb000e25 bl 3000f784 <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000beec: e59f3010 ldr r3, [pc, #16] ; 3000bf04 <pthread_rwlock_trywrlock+0x6c> 3000bef0: e5933008 ldr r3, [r3, #8]
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000bef4: e5930034 ldr r0, [r3, #52] ; 0x34 3000bef8: ebffffc6 bl 3000be18 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000befc: eafffff1 b 3000bec8 <pthread_rwlock_trywrlock+0x30>
3000bf08 <pthread_rwlock_unlock>:
*/
int pthread_rwlock_unlock(
pthread_rwlock_t *rwlock
)
{
3000bf08: e92d4010 push {r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
CORE_RWLock_Status status;
if ( !rwlock )
3000bf0c: e2503000 subs r3, r0, #0
*/
int pthread_rwlock_unlock(
pthread_rwlock_t *rwlock
)
{
3000bf10: e24dd004 sub sp, sp, #4
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
CORE_RWLock_Status status;
if ( !rwlock )
3000bf14: 0a000006 beq 3000bf34 <pthread_rwlock_unlock+0x2c>
3000bf18: e5931000 ldr r1, [r3] 3000bf1c: e59f0038 ldr r0, [pc, #56] ; 3000bf5c <pthread_rwlock_unlock+0x54> 3000bf20: e1a0200d mov r2, sp 3000bf24: eb000a6e bl 3000e8e4 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000bf28: e59d3000 ldr r3, [sp] 3000bf2c: e3530000 cmp r3, #0
3000bf30: 0a000002 beq 3000bf40 <pthread_rwlock_unlock+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000bf34: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000bf38: e28dd004 add sp, sp, #4
3000bf3c: e8bd8010 pop {r4, pc}
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_RWLock_Release( &the_rwlock->RWLock );
3000bf40: e2800010 add r0, r0, #16 3000bf44: eb00074a bl 3000dc74 <_CORE_RWLock_Release> 3000bf48: e1a04000 mov r4, r0
_Thread_Enable_dispatch();
3000bf4c: eb000e0c bl 3000f784 <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code( status );
3000bf50: e1a00004 mov r0, r4 3000bf54: ebffffaf bl 3000be18 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000bf58: eafffff6 b 3000bf38 <pthread_rwlock_unlock+0x30>
3000bf60 <pthread_rwlock_wrlock>:
*/
int pthread_rwlock_wrlock(
pthread_rwlock_t *rwlock
)
{
3000bf60: e92d4010 push {r4, lr}
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000bf64: e2504000 subs r4, r0, #0
*/
int pthread_rwlock_wrlock(
pthread_rwlock_t *rwlock
)
{
3000bf68: e24dd008 sub sp, sp, #8
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000bf6c: 0a000006 beq 3000bf8c <pthread_rwlock_wrlock+0x2c>
3000bf70: e59f0050 ldr r0, [pc, #80] ; 3000bfc8 <pthread_rwlock_wrlock+0x68> 3000bf74: e5941000 ldr r1, [r4] 3000bf78: e28d2004 add r2, sp, #4 3000bf7c: eb000a58 bl 3000e8e4 <_Objects_Get>
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000bf80: e59dc004 ldr ip, [sp, #4] 3000bf84: e35c0000 cmp ip, #0
3000bf88: 0a000002 beq 3000bf98 <pthread_rwlock_wrlock+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000bf8c: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000bf90: e28dd008 add sp, sp, #8
3000bf94: e8bd8010 pop {r4, pc}
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000bf98: e5941000 ldr r1, [r4] 3000bf9c: e1a0300c mov r3, ip 3000bfa0: e2800010 add r0, r0, #16 3000bfa4: e3a02001 mov r2, #1 3000bfa8: e58dc000 str ip, [sp] 3000bfac: eb00070b bl 3000dbe0 <_CORE_RWLock_Obtain_for_writing>
true, /* do not timeout -- wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
3000bfb0: eb000df3 bl 3000f784 <_Thread_Enable_dispatch>
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000bfb4: e59f3010 ldr r3, [pc, #16] ; 3000bfcc <pthread_rwlock_wrlock+0x6c> 3000bfb8: e5933008 ldr r3, [r3, #8]
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000bfbc: e5930034 ldr r0, [r3, #52] ; 0x34 3000bfc0: ebffff94 bl 3000be18 <_POSIX_RWLock_Translate_core_RWLock_return_code> 3000bfc4: eafffff1 b 3000bf90 <pthread_rwlock_wrlock+0x30>
3000c570 <pthread_rwlockattr_destroy>:
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000c570: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000c574: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000c578: 012fff1e bxeq lr <== NOT EXECUTED 3000c57c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c580: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000c584: 13a00000 movne r0, #0 <== NOT EXECUTED 3000c588: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000c58c: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000c590: e12fff1e bx lr <== NOT EXECUTED
3000c594 <pthread_rwlockattr_getpshared>:
int pthread_rwlockattr_getpshared(
const pthread_rwlockattr_t *attr,
int *pshared
)
{
if ( !attr )
3000c594: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000c598: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_rwlockattr_getpshared(
const pthread_rwlockattr_t *attr,
int *pshared
)
{
if ( !attr )
3000c59c: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000c5a0: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000c5a4: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000c5a8: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000c5ac: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
3000c5b0: 13a00000 movne r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
*pshared = attr->process_shared;
3000c5b4: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0; }
3000c5b8: e12fff1e bx lr <== NOT EXECUTED
3000c5d8 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
3000c5d8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c5dc: 0a000002 beq 3000c5ec <pthread_rwlockattr_setpshared+0x14> <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000c5e0: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000c5e4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c5e8: 1a000001 bne 3000c5f4 <pthread_rwlockattr_setpshared+0x1c> <== NOT EXECUTED
return EINVAL;
3000c5ec: e3a00016 mov r0, #22 <== NOT EXECUTED 3000c5f0: e12fff1e bx lr <== NOT EXECUTED
switch ( pshared ) {
3000c5f4: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000c5f8: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000c5fc: 93a00000 movls r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000c600: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000c604: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000c608: e12fff1e bx lr <== NOT EXECUTED
3001e180 <pthread_self>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
pthread_t pthread_self( void )
{
return _Thread_Executing->Object.id;
3001e180: e59f3008 ldr r3, [pc, #8] ; 3001e190 <pthread_self+0x10> <== NOT EXECUTED 3001e184: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
}
3001e188: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3001e18c: e12fff1e bx lr <== NOT EXECUTED
3000a278 <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() )
3000a278: e59f3064 ldr r3, [pc, #100] ; 3000a2e4 <pthread_setcancelstate+0x6c><== NOT EXECUTED
int pthread_setcancelstate(
int state,
int *oldstate
)
{
3000a27c: 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() )
3000a280: e5934000 ldr r4, [r3] <== NOT EXECUTED
int pthread_setcancelstate(
int state,
int *oldstate
)
{
3000a284: e1a02000 mov r2, r0 <== 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() )
3000a288: e3540000 cmp r4, #0 <== NOT EXECUTED
return EPROTO;
3000a28c: 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() )
3000a290: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return EPROTO;
if ( !oldstate )
3000a294: e3510000 cmp r1, #0 <== NOT EXECUTED
return EINVAL;
3000a298: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
if ( !oldstate )
3000a29c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
3000a2a0: e3520001 cmp r2, #1 <== NOT EXECUTED 3000a2a4: 9a000001 bls 3000a2b0 <pthread_setcancelstate+0x38> <== NOT EXECUTED
return EINVAL;
3000a2a8: e3a00016 mov r0, #22 <== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
3000a2ac: e8bd8010 pop {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;
3000a2b0: e59f0030 ldr r0, [pc, #48] ; 3000a2e8 <pthread_setcancelstate+0x70><== NOT EXECUTED
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000a2b4: e593c008 ldr ip, [r3, #8] <== NOT EXECUTED 3000a2b8: e590e000 ldr lr, [r0] <== NOT EXECUTED 3000a2bc: e59cc0f4 ldr ip, [ip, #244] ; 0xf4 <== NOT EXECUTED
++level;
3000a2c0: e28ee001 add lr, lr, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000a2c4: e580e000 str lr, [r0] <== NOT EXECUTED
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
3000a2c8: e59ce0d8 ldr lr, [ip, #216] ; 0xd8 <== NOT EXECUTED
thread_support->cancelability_state = state;
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
3000a2cc: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
3000a2d0: e581e000 str lr, [r1] <== NOT EXECUTED
thread_support->cancelability_state = state;
3000a2d4: e58c20d8 str r2, [ip, #216] ; 0xd8 <== NOT EXECUTED
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
3000a2d8: eb0015af bl 3000f99c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
3000a2dc: e1a00004 mov r0, r4 <== NOT EXECUTED
3000a2e0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a2ec <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() )
3000a2ec: e59f3064 ldr r3, [pc, #100] ; 3000a358 <pthread_setcanceltype+0x6c><== NOT EXECUTED
int pthread_setcanceltype(
int type,
int *oldtype
)
{
3000a2f0: 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() )
3000a2f4: e5934000 ldr r4, [r3] <== NOT EXECUTED
int pthread_setcanceltype(
int type,
int *oldtype
)
{
3000a2f8: e1a02000 mov r2, r0 <== 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() )
3000a2fc: e3540000 cmp r4, #0 <== NOT EXECUTED
return EPROTO;
3000a300: 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() )
3000a304: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return EPROTO;
if ( !oldtype )
3000a308: e3510000 cmp r1, #0 <== NOT EXECUTED
return EINVAL;
3000a30c: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
if ( !oldtype )
3000a310: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
3000a314: e3520001 cmp r2, #1 <== NOT EXECUTED 3000a318: 9a000001 bls 3000a324 <pthread_setcanceltype+0x38> <== NOT EXECUTED
return EINVAL;
3000a31c: e3a00016 mov r0, #22 <== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
3000a320: e8bd8010 pop {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;
3000a324: e59f0030 ldr r0, [pc, #48] ; 3000a35c <pthread_setcanceltype+0x70><== NOT EXECUTED
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000a328: e593c008 ldr ip, [r3, #8] <== NOT EXECUTED 3000a32c: e590e000 ldr lr, [r0] <== NOT EXECUTED 3000a330: e59cc0f4 ldr ip, [ip, #244] ; 0xf4 <== NOT EXECUTED
++level;
3000a334: e28ee001 add lr, lr, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000a338: e580e000 str lr, [r0] <== NOT EXECUTED
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
3000a33c: e59ce0dc ldr lr, [ip, #220] ; 0xdc <== NOT EXECUTED
thread_support->cancelability_type = type;
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
3000a340: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
3000a344: e581e000 str lr, [r1] <== NOT EXECUTED
thread_support->cancelability_type = type;
3000a348: e58c20dc str r2, [ip, #220] ; 0xdc <== NOT EXECUTED
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
3000a34c: eb001592 bl 3000f99c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
3000a350: e1a00004 mov r0, r4 <== NOT EXECUTED
3000a354: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000d664 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
3000d664: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int rc;
/*
* Check all the parameters
*/
if ( !param )
3000d668: e2526000 subs r6, r2, #0 <== NOT EXECUTED
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
3000d66c: e24dd00c sub sp, sp, #12 <== NOT EXECUTED 3000d670: e1a07000 mov r7, r0 <== NOT EXECUTED 3000d674: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
3000d678: 03a04016 moveq r4, #22 <== NOT EXECUTED
int rc;
/*
* Check all the parameters
*/
if ( !param )
3000d67c: 0a000006 beq 3000d69c <pthread_setschedparam+0x38> <== NOT EXECUTED
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
3000d680: e1a00001 mov r0, r1 <== NOT EXECUTED 3000d684: e1a0200d mov r2, sp <== NOT EXECUTED 3000d688: e1a01006 mov r1, r6 <== NOT EXECUTED 3000d68c: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000d690: eb001776 bl 30013470 <_POSIX_Thread_Translate_sched_param> <== NOT EXECUTED
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
3000d694: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000d698: 0a000002 beq 3000d6a8 <pthread_setschedparam+0x44> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
3000d69c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000d6a0: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000d6a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
3000d6a8: e1a00007 mov r0, r7 <== NOT EXECUTED 3000d6ac: e28d1008 add r1, sp, #8 <== NOT EXECUTED 3000d6b0: eb000bef bl 30010674 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000d6b4: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
3000d6b8: e1a07000 mov r7, r0 <== NOT EXECUTED
switch ( location ) {
3000d6bc: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000d6c0: 13a04003 movne r4, #3 <== NOT EXECUTED
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000d6c4: 1afffff4 bne 3000d69c <pthread_setschedparam+0x38> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000d6c8: e59080f4 ldr r8, [r0, #244] ; 0xf4 <== NOT EXECUTED
if ( api->schedpolicy == SCHED_SPORADIC )
3000d6cc: e5983084 ldr r3, [r8, #132] ; 0x84 <== NOT EXECUTED 3000d6d0: e3530004 cmp r3, #4 <== NOT EXECUTED 3000d6d4: 0a000025 beq 3000d770 <pthread_setschedparam+0x10c> <== NOT EXECUTED
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
3000d6d8: e5885084 str r5, [r8, #132] ; 0x84 <== NOT EXECUTED
api->schedparam = *param;
3000d6dc: e288c088 add ip, r8, #136 ; 0x88 <== NOT EXECUTED
3000d6e0: e8b6000f ldm r6!, {r0, r1, r2, r3} <== NOT EXECUTED
3000d6e4: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
the_thread->budget_algorithm = budget_algorithm;
3000d6e8: e59d3000 ldr r3, [sp] <== NOT EXECUTED
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
3000d6ec: e8960007 ldm r6, {r0, r1, r2} <== NOT EXECUTED
3000d6f0: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
the_thread->budget_algorithm = budget_algorithm;
3000d6f4: e5873078 str r3, [r7, #120] ; 0x78 <== NOT EXECUTED
the_thread->budget_callout = budget_callout;
3000d6f8: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
switch ( api->schedpolicy ) {
3000d6fc: e3550000 cmp r5, #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;
3000d700: e587307c str r3, [r7, #124] ; 0x7c <== NOT EXECUTED
switch ( api->schedpolicy ) {
3000d704: ba00000a blt 3000d734 <pthread_setschedparam+0xd0> <== NOT EXECUTED 3000d708: e3550002 cmp r5, #2 <== NOT EXECUTED 3000d70c: da00000a ble 3000d73c <pthread_setschedparam+0xd8> <== NOT EXECUTED 3000d710: e3550004 cmp r5, #4 <== NOT EXECUTED 3000d714: 1a000006 bne 3000d734 <pthread_setschedparam+0xd0> <== NOT EXECUTED
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
3000d718: e5983088 ldr r3, [r8, #136] ; 0x88 <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
3000d71c: e28800a8 add r0, r8, #168 ; 0xa8 <== NOT EXECUTED
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
3000d720: e58830a4 str r3, [r8, #164] ; 0xa4 <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
3000d724: eb000fd2 bl 30011674 <_Watchdog_Remove> <== NOT EXECUTED
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
3000d728: e3a00000 mov r0, #0 <== NOT EXECUTED 3000d72c: e1a01007 mov r1, r7 <== NOT EXECUTED 3000d730: ebffff7f bl 3000d534 <_POSIX_Threads_Sporadic_budget_TSR> <== NOT EXECUTED
break;
}
_Thread_Enable_dispatch();
3000d734: eb000bc6 bl 30010654 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000d738: eaffffd7 b 3000d69c <pthread_setschedparam+0x38> <== NOT EXECUTED 3000d73c: e59f3038 ldr r3, [pc, #56] ; 3000d77c <pthread_setschedparam+0x118><== NOT EXECUTED 3000d740: e5982088 ldr r2, [r8, #136] ; 0x88 <== NOT EXECUTED 3000d744: e5d31000 ldrb r1, [r3] <== NOT EXECUTED
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000d748: e59f3030 ldr r3, [pc, #48] ; 3000d780 <pthread_setschedparam+0x11c><== NOT EXECUTED 3000d74c: e0621001 rsb r1, r2, r1 <== NOT EXECUTED 3000d750: e5933000 ldr r3, [r3] <== NOT EXECUTED
the_thread->real_priority =
3000d754: e5871018 str r1, [r7, #24] <== NOT EXECUTED
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000d758: e5873074 str r3, [r7, #116] ; 0x74 <== NOT EXECUTED
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
3000d75c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000d760: e3a02001 mov r2, #1 <== NOT EXECUTED 3000d764: eb000a87 bl 30010188 <_Thread_Change_priority> <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
3000d768: eb000bb9 bl 30010654 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000d76c: eaffffca b 3000d69c <pthread_setschedparam+0x38> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
3000d770: e28800a8 add r0, r8, #168 ; 0xa8 <== NOT EXECUTED 3000d774: eb000fbe bl 30011674 <_Watchdog_Remove> <== NOT EXECUTED 3000d778: eaffffd6 b 3000d6d8 <pthread_setschedparam+0x74> <== NOT EXECUTED
3001121c <pthread_sigmask>:
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
3001121c: e2713001 rsbs r3, r1, #1 <== NOT EXECUTED 30011220: 33a03000 movcc r3, #0 <== NOT EXECUTED 30011224: e3520000 cmp r2, #0 <== NOT EXECUTED 30011228: 03510000 cmpeq r1, #0 <== NOT EXECUTED
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
3001122c: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set && !oset )
30011230: 0a00001e beq 300112b0 <pthread_sigmask+0x94> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30011234: e59fc0a4 ldr ip, [pc, #164] ; 300112e0 <pthread_sigmask+0xc4><== NOT EXECUTED
if ( oset )
30011238: 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 ];
3001123c: e59cc008 ldr ip, [ip, #8] <== NOT EXECUTED 30011240: e59cc0f4 ldr ip, [ip, #244] ; 0xf4 <== NOT EXECUTED
if ( oset )
*oset = api->signals_blocked;
30011244: 159c40d0 ldrne r4, [ip, #208] ; 0xd0 <== NOT EXECUTED 30011248: 15824000 strne r4, [r2] <== NOT EXECUTED
if ( !set )
3001124c: e3530000 cmp r3, #0 <== NOT EXECUTED 30011250: 1a000020 bne 300112d8 <pthread_sigmask+0xbc> <== NOT EXECUTED
return 0;
switch ( how ) {
30011254: e3500001 cmp r0, #1 <== NOT EXECUTED 30011258: 0a000019 beq 300112c4 <pthread_sigmask+0xa8> <== NOT EXECUTED 3001125c: e3500002 cmp r0, #2 <== NOT EXECUTED 30011260: 0a00000d beq 3001129c <pthread_sigmask+0x80> <== NOT EXECUTED 30011264: e3500000 cmp r0, #0 <== NOT EXECUTED 30011268: 1a000010 bne 300112b0 <pthread_sigmask+0x94> <== NOT EXECUTED
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
break;
case SIG_SETMASK:
api->signals_blocked = *set;
3001126c: e5913000 ldr r3, [r1] <== NOT EXECUTED 30011270: e58c30d0 str r3, [ip, #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) ) {
30011274: e59f1068 ldr r1, [pc, #104] ; 300112e4 <pthread_sigmask+0xc8><== NOT EXECUTED 30011278: e59c20d4 ldr r2, [ip, #212] ; 0xd4 <== NOT EXECUTED 3001127c: e5910000 ldr r0, [r1] <== NOT EXECUTED
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
30011280: e1800002 orr r0, r0, r2 <== NOT EXECUTED
30011284: e1c00003 bic r0, r0, r3 <== NOT EXECUTED
30011288: e3500000 cmp r0, #0 <== NOT EXECUTED
3001128c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
30011290: ebfff2e7 bl 3000de34 <_Thread_Dispatch> <== NOT EXECUTED
}
return 0;
30011294: e3a00000 mov r0, #0 <== NOT EXECUTED
30011298: e8bd8010 pop {r4, pc} <== NOT EXECUTED
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
3001129c: e5912000 ldr r2, [r1] <== NOT EXECUTED 300112a0: e59c30d0 ldr r3, [ip, #208] ; 0xd0 <== NOT EXECUTED 300112a4: e1c33002 bic r3, r3, r2 <== NOT EXECUTED 300112a8: e58c30d0 str r3, [ip, #208] ; 0xd0 <== NOT EXECUTED
break;
300112ac: eafffff0 b 30011274 <pthread_sigmask+0x58> <== NOT EXECUTED
case SIG_SETMASK:
api->signals_blocked = *set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
300112b0: eb0009a0 bl 30013938 <__errno> <== NOT EXECUTED
300112b4: e3a03016 mov r3, #22 <== NOT EXECUTED
300112b8: e5803000 str r3, [r0] <== NOT EXECUTED
300112bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
300112c0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !set )
return 0;
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
300112c4: e5912000 ldr r2, [r1] <== NOT EXECUTED 300112c8: e59c30d0 ldr r3, [ip, #208] ; 0xd0 <== NOT EXECUTED 300112cc: e1823003 orr r3, r2, r3 <== NOT EXECUTED 300112d0: e58c30d0 str r3, [ip, #208] ; 0xd0 <== NOT EXECUTED
break;
300112d4: eaffffe6 b 30011274 <pthread_sigmask+0x58> <== NOT EXECUTED
if ( oset )
*oset = api->signals_blocked;
if ( !set )
return 0;
300112d8: e3a00000 mov r0, #0 <== NOT EXECUTED
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
300112dc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a900 <pthread_spin_destroy>:
* source of the error.
*/
int pthread_spin_destroy(
pthread_spinlock_t *spinlock
)
{
3000a900: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
if ( !spinlock )
3000a904: e2503000 subs r3, r0, #0 <== NOT EXECUTED
* source of the error.
*/
int pthread_spin_destroy(
pthread_spinlock_t *spinlock
)
{
3000a908: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
if ( !spinlock )
3000a90c: 0a00000d beq 3000a948 <pthread_spin_destroy+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(
3000a910: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a914: e59f005c ldr r0, [pc, #92] ; 3000a978 <pthread_spin_destroy+0x78><== NOT EXECUTED 3000a918: e1a0200d mov r2, sp <== NOT EXECUTED 3000a91c: eb0008d4 bl 3000cc74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000a920: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a924: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a928: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a92c: 1a000005 bne 3000a948 <pthread_spin_destroy+0x48> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _CORE_spinlock_Is_busy(
CORE_spinlock_Control *the_spinlock
)
{
return (the_spinlock->users != 0);
3000a930: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) {
3000a934: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a938: 0a000005 beq 3000a954 <pthread_spin_destroy+0x54> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a93c: eb000c74 bl 3000db14 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000a940: e3a00010 mov r0, #16 <== NOT EXECUTED 3000a944: ea000000 b 3000a94c <pthread_spin_destroy+0x4c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a948: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a94c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a950: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) {
_Thread_Enable_dispatch();
return EBUSY;
}
_Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object );
3000a954: e59f001c ldr r0, [pc, #28] ; 3000a978 <pthread_spin_destroy+0x78><== NOT EXECUTED 3000a958: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a95c: eb0007b2 bl 3000c82c <_Objects_Close> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _POSIX_Spinlock_Free (
POSIX_Spinlock_Control *the_spinlock
)
{
_Objects_Free( &_POSIX_Spinlock_Information, &the_spinlock->Object );
3000a960: e59f0010 ldr r0, [pc, #16] ; 3000a978 <pthread_spin_destroy+0x78><== NOT EXECUTED 3000a964: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a968: eb00086a bl 3000cb18 <_Objects_Free> <== NOT EXECUTED
_POSIX_Spinlock_Free( the_spinlock );
_Thread_Enable_dispatch();
3000a96c: eb000c68 bl 3000db14 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a970: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a974: eafffff4 b 3000a94c <pthread_spin_destroy+0x4c> <== NOT EXECUTED
3000afe8 <pthread_spin_init>:
int pthread_spin_init(
pthread_spinlock_t *spinlock,
int pshared
)
{
3000afe8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock;
CORE_spinlock_Attributes attributes;
if ( !spinlock )
3000afec: e2505000 subs r5, r0, #0 <== NOT EXECUTED
int pthread_spin_init(
pthread_spinlock_t *spinlock,
int pshared
)
{
3000aff0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000aff4: e1a04001 mov r4, r1 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock;
CORE_spinlock_Attributes attributes;
if ( !spinlock )
3000aff8: 0a000018 beq 3000b060 <pthread_spin_init+0x78> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000affc: e3510000 cmp r1, #0 <== NOT EXECUTED 3000b000: 1a000016 bne 3000b060 <pthread_spin_init+0x78> <== 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;
3000b004: e59f306c ldr r3, [pc, #108] ; 3000b078 <pthread_spin_init+0x90><== NOT EXECUTED 3000b008: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3000b00c: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000b010: 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 *)
3000b014: e59f7060 ldr r7, [pc, #96] ; 3000b07c <pthread_spin_init+0x94><== NOT EXECUTED 3000b018: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b01c: eb000a66 bl 3000d9bc <_Objects_Allocate> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_spinlock = _POSIX_Spinlock_Allocate();
if ( !the_spinlock ) {
3000b020: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000b024: 0a000010 beq 3000b06c <pthread_spin_init+0x84> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _CORE_spinlock_Initialize_attributes(
CORE_spinlock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
3000b028: e28d1004 add r1, sp, #4 <== NOT EXECUTED
return EAGAIN;
}
_CORE_spinlock_Initialize_attributes( &attributes );
_CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes );
3000b02c: e2860010 add r0, r6, #16 <== NOT EXECUTED 3000b030: e5214004 str r4, [r1, #-4]! <== NOT EXECUTED 3000b034: e1a0100d mov r1, sp <== NOT EXECUTED 3000b038: eb0008f2 bl 3000d408 <_CORE_spinlock_Initialize> <== NOT EXECUTED
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000b03c: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b040: e597201c ldr r2, [r7, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000b044: e1a01803 lsl r1, r3, #16 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b048: e7826721 str r6, [r2, r1, lsr #14] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000b04c: e586400c str r4, [r6, #12] <== NOT EXECUTED
_Objects_Open_u32( &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 );
*spinlock = the_spinlock->Object.id;
3000b050: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b054: eb000f6b bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000b058: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b05c: ea000000 b 3000b064 <pthread_spin_init+0x7c> <== NOT EXECUTED
switch ( pshared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
3000b060: e3a00016 mov r0, #22 <== NOT EXECUTED
*spinlock = the_spinlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000b064: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b068: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_spinlock = _POSIX_Spinlock_Allocate();
if ( !the_spinlock ) {
_Thread_Enable_dispatch();
3000b06c: eb000f65 bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000b070: e3a0000b mov r0, #11 <== NOT EXECUTED 3000b074: eafffffa b 3000b064 <pthread_spin_init+0x7c> <== NOT EXECUTED
3000aa14 <pthread_spin_lock>:
* source of the error.
*/
int pthread_spin_lock(
pthread_spinlock_t *spinlock
)
{
3000aa14: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000aa18: e2503000 subs r3, r0, #0 <== NOT EXECUTED
* source of the error.
*/
int pthread_spin_lock(
pthread_spinlock_t *spinlock
)
{
3000aa1c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000aa20: 0a000006 beq 3000aa40 <pthread_spin_lock+0x2c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get (
pthread_spinlock_t *spinlock,
Objects_Locations *location
)
{
return (POSIX_Spinlock_Control *) _Objects_Get(
3000aa24: e1a0200d mov r2, sp <== NOT EXECUTED 3000aa28: e59f003c ldr r0, [pc, #60] ; 3000aa6c <pthread_spin_lock+0x58><== NOT EXECUTED 3000aa2c: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000aa30: eb00088f bl 3000cc74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000aa34: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000aa38: e3520000 cmp r2, #0 <== NOT EXECUTED 3000aa3c: 0a000002 beq 3000aa4c <pthread_spin_lock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000aa40: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000aa44: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000aa48: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, true, 0 );
3000aa4c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000aa50: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000aa54: eb0005b3 bl 3000c128 <_CORE_spinlock_Wait> <== NOT EXECUTED 3000aa58: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000aa5c: eb000c2c bl 3000db14 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
3000aa60: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aa64: eb000001 bl 3000aa70 <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 3000aa68: eafffff5 b 3000aa44 <pthread_spin_lock+0x30> <== NOT EXECUTED
3000aa80 <pthread_spin_trylock>:
*/
int pthread_spin_trylock(
pthread_spinlock_t *spinlock
)
{
3000aa80: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000aa84: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_trylock(
pthread_spinlock_t *spinlock
)
{
3000aa88: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000aa8c: 0a000006 beq 3000aaac <pthread_spin_trylock+0x2c> <== NOT EXECUTED 3000aa90: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000aa94: e59f003c ldr r0, [pc, #60] ; 3000aad8 <pthread_spin_trylock+0x58><== NOT EXECUTED 3000aa98: e1a0200d mov r2, sp <== NOT EXECUTED 3000aa9c: eb000874 bl 3000cc74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000aaa0: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000aaa4: e3510000 cmp r1, #0 <== NOT EXECUTED 3000aaa8: 0a000002 beq 3000aab8 <pthread_spin_trylock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000aaac: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000aab0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000aab4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, false, 0 );
3000aab8: e1a02001 mov r2, r1 <== NOT EXECUTED 3000aabc: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000aac0: eb000598 bl 3000c128 <_CORE_spinlock_Wait> <== NOT EXECUTED 3000aac4: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000aac8: eb000c11 bl 3000db14 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
3000aacc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aad0: ebffffe6 bl 3000aa70 <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 3000aad4: eafffff5 b 3000aab0 <pthread_spin_trylock+0x30> <== NOT EXECUTED
3000aadc <pthread_spin_unlock>:
*/
int pthread_spin_unlock(
pthread_spinlock_t *spinlock
)
{
3000aadc: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000aae0: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_unlock(
pthread_spinlock_t *spinlock
)
{
3000aae4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000aae8: 0a000006 beq 3000ab08 <pthread_spin_unlock+0x2c> <== NOT EXECUTED 3000aaec: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000aaf0: e59f0038 ldr r0, [pc, #56] ; 3000ab30 <pthread_spin_unlock+0x54><== NOT EXECUTED 3000aaf4: e1a0200d mov r2, sp <== NOT EXECUTED 3000aaf8: eb00085d bl 3000cc74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000aafc: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000ab00: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ab04: 0a000002 beq 3000ab14 <pthread_spin_unlock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ab08: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000ab0c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000ab10: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_spinlock_Release( &the_spinlock->Spinlock );
3000ab14: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000ab18: eb000566 bl 3000c0b8 <_CORE_spinlock_Release> <== NOT EXECUTED 3000ab1c: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ab20: eb000bfb bl 3000db14 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
3000ab24: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ab28: ebffffd0 bl 3000aa70 <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 3000ab2c: eafffff6 b 3000ab0c <pthread_spin_unlock+0x30> <== NOT EXECUTED
3000ac6c <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
3000ac6c: 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() )
3000ac70: e59f4054 ldr r4, [pc, #84] ; 3000accc <pthread_testcancel+0x60><== NOT EXECUTED
3000ac74: e5943000 ldr r3, [r4] <== NOT EXECUTED
3000ac78: e3530000 cmp r3, #0 <== NOT EXECUTED
3000ac7c: 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;
3000ac80: e59f3048 ldr r3, [pc, #72] ; 3000acd0 <pthread_testcancel+0x64><== NOT EXECUTED
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000ac84: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3000ac88: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000ac8c: e59220f4 ldr r2, [r2, #244] ; 0xf4 <== NOT EXECUTED
++level;
3000ac90: e2811001 add r1, r1, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000ac94: e5831000 str r1, [r3] <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
3000ac98: e59230d8 ldr r3, [r2, #216] ; 0xd8 <== NOT EXECUTED 3000ac9c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000aca0: 1a000007 bne 3000acc4 <pthread_testcancel+0x58> <== NOT EXECUTED 3000aca4: e59230e0 ldr r3, [r2, #224] ; 0xe0 <== NOT EXECUTED 3000aca8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000acac: 0a000004 beq 3000acc4 <pthread_testcancel+0x58> <== NOT EXECUTED
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
3000acb0: eb000b7f bl 3000dab4 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
3000acb4: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED 3000acb8: e3e01000 mvn r1, #0 <== NOT EXECUTED
}
3000acbc: e8bd4010 pop {r4, lr} <== NOT EXECUTED
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
3000acc0: ea001728 b 30010968 <_POSIX_Thread_Exit> <== NOT EXECUTED
}
3000acc4: e8bd4010 pop {r4, lr} <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
3000acc8: ea000b79 b 3000dab4 <_Thread_Enable_dispatch> <== NOT EXECUTED
3000b2bc <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
3000b2bc: 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);
3000b2c0: e59f41bc ldr r4, [pc, #444] ; 3000b484 <rtems_aio_enqueue+0x1c8><== NOT EXECUTED
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
3000b2c4: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED 3000b2c8: 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);
3000b2cc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b2d0: eb000264 bl 3000bc68 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0) {
3000b2d4: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000b2d8: 1a00002a bne 3000b388 <rtems_aio_enqueue+0xcc> <== NOT EXECUTED
return result;
}
/* _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);
3000b2dc: eb00048f bl 3000c520 <pthread_self> <== NOT EXECUTED 3000b2e0: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000b2e4: e1a0200d mov r2, sp <== NOT EXECUTED 3000b2e8: eb00038e bl 3000c128 <pthread_getschedparam> <== NOT EXECUTED
req->caller_thread = pthread_self ();
3000b2ec: eb00048b bl 3000c520 <pthread_self> <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
3000b2f0: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000b2f4: e59dc000 ldr ip, [sp] <== NOT EXECUTED 3000b2f8: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
3000b2fc: e5941068 ldr r1, [r4, #104] ; 0x68 <== 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 ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
3000b300: e062200c rsb r2, r2, ip <== NOT EXECUTED 3000b304: e586200c str r2, [r6, #12] <== NOT EXECUTED
req->policy = policy;
3000b308: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
3000b30c: e3510000 cmp r1, #0 <== NOT EXECUTED
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
3000b310: e5862008 str r2, [r6, #8] <== NOT EXECUTED
req->aiocbp->error_code = EINPROGRESS;
3000b314: e3a02077 mov r2, #119 ; 0x77 <== 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 ();
3000b318: e5860010 str r0, [r6, #16] <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio; req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
3000b31c: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = 0;
3000b320: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
3000b324: 1a000002 bne 3000b334 <rtems_aio_enqueue+0x78> <== NOT EXECUTED 3000b328: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED 3000b32c: e3520004 cmp r2, #4 <== NOT EXECUTED 3000b330: da000017 ble 3000b394 <rtems_aio_enqueue+0xd8> <== 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,
3000b334: e59f014c ldr r0, [pc, #332] ; 3000b488 <rtems_aio_enqueue+0x1cc><== NOT EXECUTED 3000b338: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000b33c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000b340: ebffff78 bl 3000b128 <rtems_aio_search_fd> <== NOT EXECUTED
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
3000b344: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000b348: 0a00002e beq 3000b408 <rtems_aio_enqueue+0x14c> <== NOT EXECUTED
{
pthread_mutex_lock (&r_chain->mutex);
3000b34c: e287401c add r4, r7, #28 <== NOT EXECUTED 3000b350: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b354: eb000243 bl 3000bc68 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
3000b358: e2870008 add r0, r7, #8 <== NOT EXECUTED 3000b35c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b360: ebffff19 bl 3000afcc <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
3000b364: e2870020 add r0, r7, #32 <== NOT EXECUTED 3000b368: eb000127 bl 3000b80c <pthread_cond_signal> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000b36c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b370: eb00025d bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
3000b374: e59f0108 ldr r0, [pc, #264] ; 3000b484 <rtems_aio_enqueue+0x1c8><== NOT EXECUTED 3000b378: eb00025b bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
return 0; }
3000b37c: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b380: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
3000b384: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
3000b388: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b38c: ebffeeb3 bl 30006e60 <free> <== NOT EXECUTED
return result;
3000b390: eafffff9 b 3000b37c <rtems_aio_enqueue+0xc0> <== 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);
3000b394: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000b398: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000b39c: e3a02001 mov r2, #1 <== NOT EXECUTED 3000b3a0: ebffff60 bl 3000b128 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000b3a4: 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);
3000b3a8: e1a07000 mov r7, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000b3ac: e3530001 cmp r3, #1 <== NOT EXECUTED 3000b3b0: 1affffe5 bne 3000b34c <rtems_aio_enqueue+0x90> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
3000b3b4: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b3b8: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000b3bc: eb0008d7 bl 3000d720 <_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);
3000b3c0: 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;
3000b3c4: e5875018 str r5, [r7, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
3000b3c8: e287001c add r0, r7, #28 <== NOT EXECUTED 3000b3cc: eb0001d3 bl 3000bb20 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
3000b3d0: e1a01005 mov r1, r5 <== NOT EXECUTED 3000b3d4: e2870020 add r0, r7, #32 <== NOT EXECUTED 3000b3d8: eb0000db bl 3000b74c <pthread_cond_init> <== NOT EXECUTED
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
3000b3dc: e28d001c add r0, sp, #28 <== NOT EXECUTED 3000b3e0: e2841008 add r1, r4, #8 <== NOT EXECUTED 3000b3e4: e59f20a0 ldr r2, [pc, #160] ; 3000b48c <rtems_aio_enqueue+0x1d0><== NOT EXECUTED 3000b3e8: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b3ec: eb0002b0 bl 3000beb4 <pthread_create> <== NOT EXECUTED
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
3000b3f0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000b3f4: 1a00001e bne 3000b474 <rtems_aio_enqueue+0x1b8> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
3000b3f8: e5943064 ldr r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000b3fc: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000b400: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000b404: eaffffda b 3000b374 <rtems_aio_enqueue+0xb8> <== 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);
3000b408: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000b40c: e59f007c ldr r0, [pc, #124] ; 3000b490 <rtems_aio_enqueue+0x1d4><== NOT EXECUTED 3000b410: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000b414: e3a02001 mov r2, #1 <== NOT EXECUTED 3000b418: ebffff42 bl 3000b128 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000b41c: 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);
3000b420: e1a08000 mov r8, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000b424: e3530001 cmp r3, #1 <== NOT EXECUTED 3000b428: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000b42c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b430: 0a000006 beq 3000b450 <rtems_aio_enqueue+0x194> <== NOT EXECUTED
r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL); pthread_cond_init (&r_chain->cond, NULL); } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
3000b434: ebfffee4 bl 3000afcc <rtems_aio_insert_prio> <== NOT EXECUTED
if (aio_request_queue.idle_threads > 0)
3000b438: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED 3000b43c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b440: daffffcb ble 3000b374 <rtems_aio_enqueue+0xb8> <== NOT EXECUTED
pthread_cond_signal (&aio_request_queue.new_req);
3000b444: e59f0048 ldr r0, [pc, #72] ; 3000b494 <rtems_aio_enqueue+0x1d8><== NOT EXECUTED 3000b448: eb0000ef bl 3000b80c <pthread_cond_signal> <== NOT EXECUTED 3000b44c: eaffffc8 b 3000b374 <rtems_aio_enqueue+0xb8> <== NOT EXECUTED 3000b450: eb0008b2 bl 3000d720 <_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);
3000b454: e1a01007 mov r1, r7 <== 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;
3000b458: e5887018 str r7, [r8, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
3000b45c: e288001c add r0, r8, #28 <== NOT EXECUTED 3000b460: eb0001ae bl 3000bb20 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
3000b464: e2880020 add r0, r8, #32 <== NOT EXECUTED 3000b468: e1a01007 mov r1, r7 <== NOT EXECUTED 3000b46c: eb0000b6 bl 3000b74c <pthread_cond_init> <== NOT EXECUTED 3000b470: eafffff0 b 3000b438 <rtems_aio_enqueue+0x17c> <== NOT EXECUTED
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
3000b474: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b478: eb00021b bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
return result;
3000b47c: e1a05006 mov r5, r6 <== NOT EXECUTED 3000b480: eaffffbd b 3000b37c <rtems_aio_enqueue+0xc0> <== NOT EXECUTED
3000ad38 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
3000ad38: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, 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);
3000ad3c: e59f7280 ldr r7, [pc, #640] ; 3000afc4 <rtems_aio_handle+0x28c><== NOT EXECUTED
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
3000ad40: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED 3000ad44: e1a05000 mov r5, r0 <== NOT EXECUTED 3000ad48: e280601c add r6, r0, #28 <== 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);
3000ad4c: e1a09007 mov r9, r7 <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* 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)) {
3000ad50: e287b058 add fp, r7, #88 ; 0x58 <== 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);
3000ad54: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ad58: eb0003c2 bl 3000bc68 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
3000ad5c: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3000ad60: 1a000022 bne 3000adf0 <rtems_aio_handle+0xb8> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000ad64: e5954008 ldr r4, [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 );
3000ad68: 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)) {
3000ad6c: e1540003 cmp r4, r3 <== NOT EXECUTED 3000ad70: 0a000038 beq 3000ae58 <rtems_aio_handle+0x120> <== 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);
3000ad74: eb0005e9 bl 3000c520 <pthread_self> <== NOT EXECUTED 3000ad78: e28d1028 add r1, sp, #40 ; 0x28 <== NOT EXECUTED 3000ad7c: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000ad80: eb0004e8 bl 3000c128 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
3000ad84: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3000ad88: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
3000ad8c: eb0005e3 bl 3000c520 <pthread_self> <== NOT EXECUTED 3000ad90: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 3000ad94: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000ad98: eb0005e5 bl 3000c534 <pthread_setschedparam> <== NOT EXECUTED 3000ad9c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ada0: eb000a49 bl 3000d6cc <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
3000ada4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ada8: eb0003cf bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
3000adac: e5948014 ldr r8, [r4, #20] <== NOT EXECUTED 3000adb0: e598302c ldr r3, [r8, #44] ; 0x2c <== NOT EXECUTED 3000adb4: e3530002 cmp r3, #2 <== NOT EXECUTED 3000adb8: 0a00001f beq 3000ae3c <rtems_aio_handle+0x104> <== NOT EXECUTED 3000adbc: e3530003 cmp r3, #3 <== NOT EXECUTED 3000adc0: 0a00001a beq 3000ae30 <rtems_aio_handle+0xf8> <== NOT EXECUTED 3000adc4: e3530001 cmp r3, #1 <== NOT EXECUTED 3000adc8: 0a00000b beq 3000adfc <rtems_aio_handle+0xc4> <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
3000adcc: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000add0: e5883034 str r3, [r8, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
3000add4: eb0027c9 bl 30014d00 <__errno> <== NOT EXECUTED 3000add8: e5903000 ldr r3, [r0] <== 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);
3000addc: e1a00006 mov r0, r6 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
3000ade0: e5883030 str r3, [r8, #48] ; 0x30 <== 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);
3000ade4: eb00039f bl 3000bc68 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
3000ade8: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3000adec: 0affffdc beq 3000ad64 <rtems_aio_handle+0x2c> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000adf0: e3a00000 mov r0, #0 <== NOT EXECUTED
3000adf4: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
3000adf8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
3000adfc: e5980000 ldr r0, [r8] <== NOT EXECUTED
3000ae00: e598100c ldr r1, [r8, #12] <== NOT EXECUTED
3000ae04: e5982010 ldr r2, [r8, #16] <== NOT EXECUTED
3000ae08: e9981008 ldmib r8, {r3, ip} <== NOT EXECUTED
3000ae0c: e58dc000 str ip, [sp] <== NOT EXECUTED
3000ae10: eb002a94 bl 30015868 <pread> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
3000ae14: e3700001 cmn r0, #1 <== NOT EXECUTED 3000ae18: 0a000061 beq 3000afa4 <rtems_aio_handle+0x26c> <== NOT EXECUTED
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
3000ae1c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
req->aiocbp->error_code = 0;
3000ae20: 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;
3000ae24: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = 0;
3000ae28: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED 3000ae2c: eaffffc8 b 3000ad54 <rtems_aio_handle+0x1c> <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
3000ae30: e5980000 ldr r0, [r8] <== NOT EXECUTED 3000ae34: eb001a8f bl 30011878 <fsync> <== NOT EXECUTED
break;
3000ae38: eafffff5 b 3000ae14 <rtems_aio_handle+0xdc> <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
3000ae3c: e5980000 ldr r0, [r8] <== NOT EXECUTED
3000ae40: e598100c ldr r1, [r8, #12] <== NOT EXECUTED
3000ae44: e5982010 ldr r2, [r8, #16] <== NOT EXECUTED
3000ae48: e9981008 ldmib r8, {r3, ip} <== NOT EXECUTED
3000ae4c: e58dc000 str ip, [sp] <== NOT EXECUTED
3000ae50: eb002ac7 bl 30015974 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
3000ae54: eaffffee b 3000ae14 <rtems_aio_handle+0xdc> <== 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);
3000ae58: e59fa164 ldr sl, [pc, #356] ; 3000afc4 <rtems_aio_handle+0x28c><== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
3000ae5c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ae60: eb0003a1 bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
3000ae64: e1a0000a mov r0, sl <== NOT EXECUTED 3000ae68: eb00037e bl 3000bc68 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
3000ae6c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000ae70: e1540003 cmp r4, r3 <== NOT EXECUTED 3000ae74: 0a000002 beq 3000ae84 <rtems_aio_handle+0x14c> <== 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);
3000ae78: e59f0144 ldr r0, [pc, #324] ; 3000afc4 <rtems_aio_handle+0x28c><== NOT EXECUTED 3000ae7c: eb00039a bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED 3000ae80: eaffffb3 b 3000ad54 <rtems_aio_handle+0x1c> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
3000ae84: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000ae88: e3a00001 mov r0, #1 <== NOT EXECUTED 3000ae8c: eb0001cb bl 3000b5c0 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
3000ae90: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
3000ae94: e2854020 add r4, 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;
3000ae98: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
3000ae9c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aea0: e1a0100a mov r1, sl <== NOT EXECUTED 3000aea4: 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;
3000aea8: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
3000aeac: e58d8024 str r8, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
3000aeb0: eb00026f bl 3000b874 <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) {
3000aeb4: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 3000aeb8: 1affffee bne 3000ae78 <rtems_aio_handle+0x140> <== NOT EXECUTED 3000aebc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000aec0: eb000a01 bl 3000d6cc <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
3000aec4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000aec8: eb0002c4 bl 3000b9e0 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
3000aecc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aed0: eb0001ea bl 3000b680 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
3000aed4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000aed8: ebffefe0 bl 30006e60 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000aedc: e5995054 ldr r5, [r9, #84] ; 0x54 <== 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)) {
3000aee0: e155000b cmp r5, fp <== NOT EXECUTED 3000aee4: 0a000019 beq 3000af50 <rtems_aio_handle+0x218> <== 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;
3000aee8: e5972068 ldr r2, [r7, #104] ; 0x68 <== NOT EXECUTED
++aio_request_queue.active_threads;
3000aeec: e5973064 ldr r3, [r7, #100] ; 0x64 <== 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;
3000aef0: e2422001 sub r2, r2, #1 <== NOT EXECUTED
++aio_request_queue.active_threads;
3000aef4: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000aef8: e1a00005 mov r0, r5 <== 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;
3000aefc: e5872068 str r2, [r7, #104] ; 0x68 <== NOT EXECUTED
++aio_request_queue.active_threads;
3000af00: e5873064 str r3, [r7, #100] ; 0x64 <== NOT EXECUTED 3000af04: eb0009f0 bl 3000d6cc <_Chain_Extract> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000af08: e5973048 ldr r3, [r7, #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 &&
3000af0c: e5951014 ldr r1, [r5, #20] <== NOT EXECUTED 3000af10: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED 3000af14: e1520001 cmp r2, r1 <== NOT EXECUTED 3000af18: aa000007 bge 3000af3c <rtems_aio_handle+0x204> <== NOT EXECUTED 3000af1c: e59f00a4 ldr r0, [pc, #164] ; 3000afc8 <rtems_aio_handle+0x290><== NOT EXECUTED 3000af20: ea000003 b 3000af34 <rtems_aio_handle+0x1fc> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000af24: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000af28: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED 3000af2c: e1510002 cmp r1, r2 <== NOT EXECUTED 3000af30: da000001 ble 3000af3c <rtems_aio_handle+0x204> <== NOT EXECUTED 3000af34: e1530000 cmp r3, r0 <== NOT EXECUTED 3000af38: 1afffff9 bne 3000af24 <rtems_aio_handle+0x1ec> <== 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 );
3000af3c: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 3000af40: e1a01005 mov r1, r5 <== NOT EXECUTED 3000af44: eb0009f5 bl 3000d720 <_Chain_Insert> <== NOT EXECUTED 3000af48: e285601c add r6, r5, #28 <== NOT EXECUTED 3000af4c: eaffffc9 b 3000ae78 <rtems_aio_handle+0x140> <== 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;
3000af50: e5992068 ldr r2, [r9, #104] ; 0x68 <== NOT EXECUTED
--aio_request_queue.active_threads;
3000af54: e5993064 ldr r3, [r9, #100] ; 0x64 <== 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;
3000af58: e2822001 add r2, r2, #1 <== NOT EXECUTED
--aio_request_queue.active_threads;
3000af5c: e2433001 sub r3, r3, #1 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
3000af60: 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;
3000af64: e5892068 str r2, [r9, #104] ; 0x68 <== NOT EXECUTED
--aio_request_queue.active_threads;
3000af68: e5893064 str r3, [r9, #100] ; 0x64 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
3000af6c: e3a00001 mov r0, #1 <== NOT EXECUTED 3000af70: eb000192 bl 3000b5c0 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
3000af74: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000af78: e28a0004 add r0, sl, #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;
3000af7c: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000af80: e1a0100a mov r1, sl <== NOT EXECUTED 3000af84: 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;
3000af88: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
3000af8c: e58d8024 str r8, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000af90: eb000237 bl 3000b874 <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) {
3000af94: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 3000af98: 0a000003 beq 3000afac <rtems_aio_handle+0x274> <== NOT EXECUTED 3000af9c: e5995054 ldr r5, [r9, #84] ; 0x54 <== NOT EXECUTED 3000afa0: eaffffd0 b 3000aee8 <rtems_aio_handle+0x1b0> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
3000afa4: e5948014 ldr r8, [r4, #20] <== NOT EXECUTED 3000afa8: eaffff87 b 3000adcc <rtems_aio_handle+0x94> <== 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;
3000afac: e59a3068 ldr r3, [sl, #104] ; 0x68 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000afb0: e1a0000a mov r0, sl <== 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;
3000afb4: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000afb8: e58a3068 str r3, [sl, #104] ; 0x68 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000afbc: eb00034a bl 3000bcec <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
3000afc0: eaffff8a b 3000adf0 <rtems_aio_handle+0xb8> <== NOT EXECUTED
3000b024 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
3000b024: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
3000b028: e59f00e4 ldr r0, [pc, #228] ; 3000b114 <rtems_aio_init+0xf0><== NOT EXECUTED 3000b02c: eb000381 bl 3000be38 <pthread_attr_init> <== NOT EXECUTED
if (result != 0)
3000b030: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000b034: 0a000001 beq 3000b040 <rtems_aio_init+0x1c> <== NOT EXECUTED
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
3000b038: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b03c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
3000b040: e59f00cc ldr r0, [pc, #204] ; 3000b114 <rtems_aio_init+0xf0><== NOT EXECUTED 3000b044: e1a01005 mov r1, r5 <== NOT EXECUTED 3000b048: eb00038c bl 3000be80 <pthread_attr_setdetachstate> <== NOT EXECUTED
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
3000b04c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b050: 1a00001b bne 3000b0c4 <rtems_aio_init+0xa0> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
3000b054: e59f40bc ldr r4, [pc, #188] ; 3000b118 <rtems_aio_init+0xf4><== NOT EXECUTED 3000b058: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b05c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b060: eb0002ae bl 3000bb20 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
3000b064: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b068: 1a00001d bne 3000b0e4 <rtems_aio_init+0xc0> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
3000b06c: e59f00a8 ldr r0, [pc, #168] ; 3000b11c <rtems_aio_init+0xf8><== NOT EXECUTED 3000b070: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b074: eb0001b4 bl 3000b74c <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
3000b078: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000b07c: 1a00001f bne 3000b100 <rtems_aio_init+0xdc> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000b080: e59f2098 ldr r2, [pc, #152] ; 3000b120 <rtems_aio_init+0xfc><== NOT EXECUTED
head->previous = NULL;
3000b084: e3a03000 mov r3, #0 <== NOT EXECUTED 3000b088: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED 3000b08c: e5843058 str r3, [r4, #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;
3000b090: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED
aio_request_queue.idle_threads = 0;
3000b094: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
3000b098: e59f3084 ldr r3, [pc, #132] ; 3000b124 <rtems_aio_init+0x100><== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000b09c: e282000c add r0, r2, #12 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3000b0a0: e242c004 sub ip, r2, #4 <== NOT EXECUTED 3000b0a4: e2821008 add r1, r2, #8 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000b0a8: e5840054 str r0, [r4, #84] ; 0x54 <== NOT EXECUTED 3000b0ac: e5842048 str r2, [r4, #72] ; 0x48 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3000b0b0: e584c050 str ip, [r4, #80] ; 0x50 <== NOT EXECUTED 3000b0b4: e584105c str r1, [r4, #92] ; 0x5c <== NOT EXECUTED 3000b0b8: e5843060 str r3, [r4, #96] ; 0x60 <== NOT EXECUTED
return result;
}
3000b0bc: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b0c0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
3000b0c4: e59f404c ldr r4, [pc, #76] ; 3000b118 <rtems_aio_init+0xf4><== NOT EXECUTED
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
3000b0c8: e59f0044 ldr r0, [pc, #68] ; 3000b114 <rtems_aio_init+0xf0><== NOT EXECUTED 3000b0cc: eb000350 bl 3000be14 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
3000b0d0: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b0d4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b0d8: eb000290 bl 3000bb20 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
3000b0dc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b0e0: 0affffe1 beq 3000b06c <rtems_aio_init+0x48> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000b0e4: e2840008 add r0, r4, #8 <== NOT EXECUTED 3000b0e8: eb000349 bl 3000be14 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
3000b0ec: e59f0028 ldr r0, [pc, #40] ; 3000b11c <rtems_aio_init+0xf8><== NOT EXECUTED 3000b0f0: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b0f4: eb000194 bl 3000b74c <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
3000b0f8: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000b0fc: 0affffdf beq 3000b080 <rtems_aio_init+0x5c> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
3000b100: e59f0010 ldr r0, [pc, #16] ; 3000b118 <rtems_aio_init+0xf4><== NOT EXECUTED 3000b104: eb000235 bl 3000b9e0 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000b108: e59f0004 ldr r0, [pc, #4] ; 3000b114 <rtems_aio_init+0xf0> <== NOT EXECUTED 3000b10c: eb000340 bl 3000be14 <pthread_attr_destroy> <== NOT EXECUTED 3000b110: eaffffda b 3000b080 <rtems_aio_init+0x5c> <== NOT EXECUTED
3000afcc <rtems_aio_insert_prio>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000afcc: e1a02000 mov r2, r0 <== NOT EXECUTED 3000afd0: e4923004 ldr r3, [r2], #4 <== NOT EXECUTED
* NONE
*/
static void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
3000afd4: 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)) {
3000afd8: e1530002 cmp r3, r2 <== NOT EXECUTED 3000afdc: 0a00000f beq 3000b020 <rtems_aio_insert_prio+0x54> <== 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 &&
3000afe0: e5910014 ldr r0, [r1, #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;
3000afe4: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED
while (req->aiocbp->aio_reqprio > prio &&
3000afe8: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED 3000afec: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED 3000aff0: e1510000 cmp r1, r0 <== NOT EXECUTED 3000aff4: ba000002 blt 3000b004 <rtems_aio_insert_prio+0x38> <== NOT EXECUTED 3000aff8: ea000006 b 3000b018 <rtems_aio_insert_prio+0x4c> <== NOT EXECUTED 3000affc: e1520003 cmp r2, r3 <== NOT EXECUTED 3000b000: 0a000004 beq 3000b018 <rtems_aio_insert_prio+0x4c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000b004: 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;
3000b008: e5931014 ldr r1, [r3, #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 &&
3000b00c: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED 3000b010: e1510000 cmp r1, r0 <== NOT EXECUTED 3000b014: bafffff8 blt 3000affc <rtems_aio_insert_prio+0x30> <== NOT EXECUTED 3000b018: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 3000b01c: e1a0100c mov r1, ip <== NOT EXECUTED 3000b020: ea0009be b 3000d720 <_Chain_Insert> <== NOT EXECUTED
3000b208 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
3000b208: 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;
3000b20c: 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 ));
3000b210: e280600c add r6, r0, #12 <== 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))
3000b214: e1540006 cmp r4, r6 <== NOT EXECUTED
3000b218: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
3000b21c: e3a0808c mov r8, #140 ; 0x8c <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000b220: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000b224: ea000000 b 3000b22c <rtems_aio_remove_fd+0x24> <== 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);
3000b228: e1a04005 mov r4, r5 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000b22c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b230: eb000925 bl 3000d6cc <_Chain_Extract> <== NOT EXECUTED
req->aiocbp->error_code = ECANCELED;
3000b234: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000b238: e5945000 ldr r5, [r4] <== NOT EXECUTED
req->aiocbp->return_value = -1;
free (req);
3000b23c: 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;
3000b240: e5838030 str r8, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000b244: e5837034 str r7, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
3000b248: ebffef04 bl 30006e60 <free> <== 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))
3000b24c: e1550006 cmp r5, r6 <== NOT EXECUTED
3000b250: 1afffff4 bne 3000b228 <rtems_aio_remove_fd+0x20> <== NOT EXECUTED
3000b254: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000b258 <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)
{
3000b258: 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;
3000b25c: e4904004 ldr r4, [r0], #4 <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
3000b260: e1540000 cmp r4, r0 <== NOT EXECUTED
return AIO_ALLDONE;
3000b264: 03a00002 moveq r0, #2 <== NOT EXECUTED
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
3000b268: 1a000003 bne 3000b27c <rtems_aio_remove_req+0x24> <== NOT EXECUTED
3000b26c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000b270: 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) {
3000b274: e1500004 cmp r0, r4 <== NOT EXECUTED 3000b278: 0a00000d beq 3000b2b4 <rtems_aio_remove_req+0x5c> <== NOT EXECUTED 3000b27c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000b280: e1530001 cmp r3, r1 <== NOT EXECUTED 3000b284: 1afffff9 bne 3000b270 <rtems_aio_remove_req+0x18> <== NOT EXECUTED 3000b288: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b28c: eb00090e bl 3000d6cc <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
3000b290: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000b294: e3a0208c mov r2, #140 ; 0x8c <== NOT EXECUTED 3000b298: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
current->aiocbp->return_value = -1;
3000b29c: e3e02000 mvn r2, #0 <== NOT EXECUTED
free (current);
3000b2a0: e1a00004 mov r0, r4 <== NOT EXECUTED
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
3000b2a4: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
free (current);
3000b2a8: ebffeeec bl 30006e60 <free> <== NOT EXECUTED
}
return AIO_CANCELED;
3000b2ac: e3a00000 mov r0, #0 <== NOT EXECUTED
3000b2b0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
3000b2b4: e3a00001 mov r0, #1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
3000b2b8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b128 <rtems_aio_search_fd>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000b128: e5903000 ldr r3, [r0] <== NOT EXECUTED
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
3000b12c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000b130: e1a04001 mov r4, r1 <== 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)) {
3000b134: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
3000b138: e1a05000 mov r5, r0 <== 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)) {
3000b13c: e1510004 cmp r1, r4 <== NOT EXECUTED 3000b140: aa00002c bge 3000b1f8 <rtems_aio_search_fd+0xd0> <== 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 ));
3000b144: e2800004 add r0, r0, #4 <== NOT EXECUTED 3000b148: e1530000 cmp r3, r0 <== NOT EXECUTED 3000b14c: 1a000002 bne 3000b15c <rtems_aio_search_fd+0x34> <== NOT EXECUTED 3000b150: ea00002a b 3000b200 <rtems_aio_search_fd+0xd8> <== NOT EXECUTED 3000b154: e1570000 cmp r7, r0 <== NOT EXECUTED 3000b158: 0a000020 beq 3000b1e0 <rtems_aio_search_fd+0xb8> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000b15c: e5937000 ldr r7, [r3] <== NOT EXECUTED 3000b160: e5971014 ldr r1, [r7, #20] <== NOT EXECUTED 3000b164: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b168: e1510004 cmp r1, r4 <== NOT EXECUTED 3000b16c: bafffff8 blt 3000b154 <rtems_aio_search_fd+0x2c> <== NOT EXECUTED
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
3000b170: e1540001 cmp r4, r1 <== NOT EXECUTED
r_chain->new_fd = 0;
3000b174: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000b178: 05873018 streq r3, [r7, #24] <== NOT EXECUTED 3000b17c: 01a06007 moveq r6, r7 <== NOT EXECUTED
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
3000b180: 0a000014 beq 3000b1d8 <rtems_aio_search_fd+0xb0> <== NOT EXECUTED
r_chain->new_fd = 0;
else {
if (create == 0)
3000b184: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b188: 0a000017 beq 3000b1ec <rtems_aio_search_fd+0xc4> <== NOT EXECUTED
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
3000b18c: e3a00024 mov r0, #36 ; 0x24 <== NOT EXECUTED 3000b190: ebfff04e bl 300072d0 <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 );
3000b194: e280300c add r3, r0, #12 <== NOT EXECUTED
head->next = tail;
3000b198: e5803008 str r3, [r0, #8] <== NOT EXECUTED
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
3000b19c: e5951000 ldr r1, [r5] <== 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 );
3000b1a0: e2852004 add r2, r5, #4 <== 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 );
3000b1a4: e2803008 add r3, r0, #8 <== NOT EXECUTED 3000b1a8: e1510002 cmp r1, r2 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
3000b1ac: e3a02000 mov r2, #0 <== NOT EXECUTED
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
3000b1b0: e1a06000 mov r6, r0 <== NOT EXECUTED
tail->previous = head;
3000b1b4: e5803010 str r3, [r0, #16] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3000b1b8: e580200c str r2, [r0, #12] <== NOT EXECUTED 3000b1bc: 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);
3000b1c0: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b1c4: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b1c8: eb000954 bl 3000d720 <_Chain_Insert> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
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;
3000b1cc: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b1d0: e5863018 str r3, [r6, #24] <== NOT EXECUTED
r_chain->fildes = fildes;
3000b1d4: e5864014 str r4, [r6, #20] <== NOT EXECUTED
}
}
return r_chain;
}
3000b1d8: e1a00006 mov r0, r6 <== NOT EXECUTED
3000b1dc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
3000b1e0: e3520000 cmp r2, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000b1e4: e1a07000 mov r7, r0 <== NOT EXECUTED 3000b1e8: 1affffe7 bne 3000b18c <rtems_aio_search_fd+0x64> <== NOT EXECUTED
r_chain = NULL;
3000b1ec: e1a06002 mov r6, r2 <== NOT EXECUTED
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
3000b1f0: e1a00006 mov r0, r6 <== NOT EXECUTED
3000b1f4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== 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)) {
3000b1f8: e1a07003 mov r7, r3 <== NOT EXECUTED 3000b1fc: eaffffdb b 3000b170 <rtems_aio_search_fd+0x48> <== NOT EXECUTED 3000b200: e1a07003 mov r7, r3 <== NOT EXECUTED 3000b204: eaffffde b 3000b184 <rtems_aio_search_fd+0x5c> <== NOT EXECUTED
30012950 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
30012950: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
30012954: e2505000 subs r5, r0, #0
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
30012958: e24dd008 sub sp, sp, #8 3001295c: e1a04001 mov r4, r1 30012960: e1a06003 mov r6, r3
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30012964: 03a00003 moveq r0, #3
)
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
30012968: 1a000001 bne 30012974 <rtems_barrier_create+0x24>
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3001296c: e28dd008 add sp, sp, #8
30012970: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30012974: e3530000 cmp r3, #0
return RTEMS_INVALID_ADDRESS;
30012978: 03a00009 moveq r0, #9
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
3001297c: 0afffffa beq 3001296c <rtems_barrier_create+0x1c>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
30012980: 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;
30012984: 03a03001 moveq r3, #1 30012988: 058d3000 streq r3, [sp]
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
3001298c: 1a000016 bne 300129ec <rtems_barrier_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;
30012990: e59f3078 ldr r3, [pc, #120] ; 30012a10 <rtems_barrier_create+0xc0>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
30012994: e58d2004 str r2, [sp, #4] 30012998: e5932000 ldr r2, [r3]
++level;
3001299c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
300129a0: 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 );
300129a4: e59f8068 ldr r8, [pc, #104] ; 30012a14 <rtems_barrier_create+0xc4> 300129a8: e1a00008 mov r0, r8 300129ac: ebffeb95 bl 3000d808 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
300129b0: e2507000 subs r7, r0, #0
300129b4: 0a000012 beq 30012a04 <rtems_barrier_create+0xb4>
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
300129b8: e2870014 add r0, r7, #20 300129bc: e1a0100d mov r1, sp
if ( !the_barrier ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
300129c0: e5874010 str r4, [r7, #16]
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
300129c4: eb000216 bl 30013224 <_CORE_barrier_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
300129c8: e5973008 ldr r3, [r7, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300129cc: e598201c ldr r2, [r8, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300129d0: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300129d4: e7827721 str r7, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300129d8: e587500c str r5, [r7, #12]
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
300129dc: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
300129e0: ebfff065 bl 3000eb7c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300129e4: e3a00000 mov r0, #0 300129e8: eaffffdf b 3001296c <rtems_barrier_create+0x1c>
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 )
300129ec: e3520000 cmp r2, #0 <== 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;
300129f0: e3a03000 mov r3, #0 <== NOT EXECUTED 300129f4: e58d3000 str r3, [sp] <== NOT EXECUTED
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
300129f8: 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 )
300129fc: 0affffda beq 3001296c <rtems_barrier_create+0x1c> <== NOT EXECUTED 30012a00: eaffffe2 b 30012990 <rtems_barrier_create+0x40> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
30012a04: ebfff05c bl 3000eb7c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30012a08: e3a00005 mov r0, #5 <== NOT EXECUTED 30012a0c: eaffffd6 b 3001296c <rtems_barrier_create+0x1c> <== NOT EXECUTED
3000c170 <rtems_build_id>:
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000c170: e1a00c00 lsl r0, r0, #24 <== NOT EXECUTED 3000c174: e1800d81 orr r0, r0, r1, lsl #27 <== NOT EXECUTED
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000c178: e1800003 orr r0, r0, r3 <== NOT EXECUTED
uint32_t node,
uint32_t index
)
{
return _Objects_Build_id( api, class, node, index );
}
3000c17c: e1800802 orr r0, r0, r2, lsl #16 <== NOT EXECUTED 3000c180: e12fff1e bx lr <== NOT EXECUTED
3000c184 <rtems_build_name>:
char C1,
char C2,
char C3,
char C4
)
{
3000c184: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000c188: e1a02402 lsl r2, r2, #8 <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000c18c: e20118ff and r1, r1, #16711680 ; 0xff0000 <== NOT EXECUTED 3000c190: e1811c00 orr r1, r1, r0, lsl #24 <== NOT EXECUTED 3000c194: e2022cff and r2, r2, #65280 ; 0xff00 <== NOT EXECUTED
char C1,
char C2,
char C3,
char C4
)
{
3000c198: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000c19c: e1811002 orr r1, r1, r2 <== NOT EXECUTED
}
3000c1a0: e1810003 orr r0, r1, r3 <== NOT EXECUTED 3000c1a4: e12fff1e bx lr <== NOT EXECUTED
3000b588 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000b588: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000b58c: e1a04002 mov r4, r2 <== NOT EXECUTED
3000b590: 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 );
3000b594: eb000164 bl 3000bb2c <_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 ) {
3000b598: e3500000 cmp r0, #0 <== NOT EXECUTED
3000b59c: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000b5a0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b5a4: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000b5a8: 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 );
3000b5ac: eafffd77 b 3000ab90 <rtems_event_send> <== NOT EXECUTED
3000b5b0 <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
3000b5b0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000b5b4: 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 );
3000b5b8: e1a01003 mov r1, r3 <== NOT EXECUTED 3000b5bc: e1a05002 mov r5, r2 <== NOT EXECUTED 3000b5c0: eb000175 bl 3000bb9c <_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 ) {
3000b5c4: e3500000 cmp r0, #0 <== NOT EXECUTED
3000b5c8: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000b5cc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b5d0: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000b5d4: 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 );
3000b5d8: eafffd6c b 3000ab90 <rtems_event_send> <== NOT EXECUTED
3000b5dc <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
3000b5dc: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000b5e0: e1a07000 mov r7, r0 <== NOT EXECUTED
3000b5e4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000b5e8: e1a06001 mov r6, r1 <== NOT EXECUTED
3000b5ec: e1a05002 mov r5, r2 <== NOT EXECUTED
3000b5f0: e1a08003 mov r8, r3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
3000b5f4: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b5f8: eb00017c bl 3000bbf0 <_Chain_Get> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000b5fc: e2504000 subs r4, r0, #0 <== NOT EXECUTED
) {
rtems_event_set out;
sc = rtems_event_receive(
3000b600: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b604: e1a0300d mov r3, sp <== NOT EXECUTED 3000b608: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b60c: e1a00006 mov r0, r6 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000b610: 1a000005 bne 3000b62c <rtems_chain_get_with_wait+0x50> <== NOT EXECUTED
) {
rtems_event_set out;
sc = rtems_event_receive(
3000b614: ebfffcfa bl 3000aa04 <rtems_event_receive> <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
3000b618: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b61c: 0afffff4 beq 3000b5f4 <rtems_chain_get_with_wait+0x18> <== NOT EXECUTED
timeout,
&out
);
}
*node_ptr = node;
3000b620: e5884000 str r4, [r8] <== NOT EXECUTED
return sc;
}
3000b624: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b628: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000b62c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b630: eafffffa b 3000b620 <rtems_chain_get_with_wait+0x44> <== NOT EXECUTED
3000b634 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000b634: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000b638: e1a04002 mov r4, r2 <== NOT EXECUTED
3000b63c: 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 );
3000b640: eb00019a bl 3000bcb0 <_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) {
3000b644: e3500000 cmp r0, #0 <== NOT EXECUTED
3000b648: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000b64c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b650: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000b654: 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 );
3000b658: eafffd4c b 3000ab90 <rtems_event_send> <== NOT EXECUTED
3000b238 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
3000b238: e92d4010 push {r4, lr} <== NOT EXECUTED
if ( !time_buffer )
3000b23c: e2514000 subs r4, r1, #0 <== NOT EXECUTED 3000b240: 0a00000c beq 3000b278 <rtems_clock_get+0x40> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
3000b244: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b248: 0a00000d beq 3000b284 <rtems_clock_get+0x4c> <== NOT EXECUTED
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
3000b24c: e3500001 cmp r0, #1 <== NOT EXECUTED 3000b250: 0a00000e beq 3000b290 <rtems_clock_get+0x58> <== NOT EXECUTED
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
3000b254: e3500002 cmp r0, #2 <== NOT EXECUTED 3000b258: 0a00000f beq 3000b29c <rtems_clock_get+0x64> <== NOT EXECUTED
*interval = rtems_clock_get_ticks_since_boot();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
3000b25c: e3500003 cmp r0, #3 <== NOT EXECUTED 3000b260: 0a000011 beq 3000b2ac <rtems_clock_get+0x74> <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
3000b264: e3500004 cmp r0, #4 <== NOT EXECUTED
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
3000b268: 13a0300a movne r3, #10 <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
3000b26c: 0a000012 beq 3000b2bc <rtems_clock_get+0x84> <== NOT EXECUTED
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
3000b270: e1a00003 mov r0, r3 <== NOT EXECUTED
3000b274: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
3000b278: e3a03009 mov r3, #9 <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
3000b27c: e1a00003 mov r0, r3 <== NOT EXECUTED
3000b280: e8bd8010 pop {r4, pc} <== 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 );
3000b284: 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;
}
3000b288: 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 );
3000b28c: ea00002e b 3000b34c <rtems_clock_get_tod> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
3000b290: 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;
}
3000b294: 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);
3000b298: ea00000a b 3000b2c8 <rtems_clock_get_seconds_since_epoch> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
3000b29c: eb000026 bl 3000b33c <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b2a0: e3a03000 mov r3, #0 <== NOT EXECUTED
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
3000b2a4: e5840000 str r0, [r4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b2a8: eafffff0 b 3000b270 <rtems_clock_get+0x38> <== NOT EXECUTED
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
3000b2ac: eb00001a bl 3000b31c <rtems_clock_get_ticks_per_second> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b2b0: e3a03000 mov r3, #0 <== NOT EXECUTED
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
3000b2b4: e5840000 str r0, [r4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b2b8: eaffffec b 3000b270 <rtems_clock_get+0x38> <== NOT EXECUTED
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
3000b2bc: e1a00004 mov r0, r4 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
}
3000b2c0: 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 );
3000b2c4: ea00005a b 3000b434 <rtems_clock_get_tod_timeval> <== NOT EXECUTED
3000b1d0 <rtems_clock_get_seconds_since_epoch>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
3000b1d0: e92d4010 push {r4, lr}
if ( !the_interval )
3000b1d4: e2504000 subs r4, r0, #0
return RTEMS_INVALID_ADDRESS;
3000b1d8: 03a03009 moveq r3, #9
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000b1dc: 0a000004 beq 3000b1f4 <rtems_clock_get_seconds_since_epoch+0x24>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
3000b1e0: e59f3034 ldr r3, [pc, #52] ; 3000b21c <rtems_clock_get_seconds_since_epoch+0x4c> 3000b1e4: e5d32014 ldrb r2, [r3, #20] 3000b1e8: e3520000 cmp r2, #0
return RTEMS_NOT_DEFINED;
3000b1ec: 03a0300b moveq r3, #11
)
{
if ( !the_interval )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
3000b1f0: 1a000001 bne 3000b1fc <rtems_clock_get_seconds_since_epoch+0x2c>
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
return RTEMS_SUCCESSFUL;
}
3000b1f4: e1a00003 mov r0, r3 <== NOT EXECUTED
3000b1f8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
3000b1fc: e8930003 ldm r3, {r0, r1}
3000b200: e59f2018 ldr r2, [pc, #24] ; 3000b220 <rtems_clock_get_seconds_since_epoch+0x50>
3000b204: e3a03000 mov r3, #0
3000b208: eb004c99 bl 3001e474 <__divdi3>
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
return RTEMS_SUCCESSFUL;
3000b20c: e3a03000 mov r3, #0 3000b210: e5840000 str r0, [r4]
}
3000b214: e1a00003 mov r0, r3
3000b218: e8bd8010 pop {r4, pc}
3000a1e4 <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 /
3000a1e4: e59f3010 ldr r3, [pc, #16] ; 3000a1fc <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)
{
3000a1e8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return TOD_MICROSECONDS_PER_SECOND /
3000a1ec: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3000a1f0: e59f0008 ldr r0, [pc, #8] ; 3000a200 <rtems_clock_get_ticks_per_second+0x1c><== NOT EXECUTED 3000a1f4: eb00458c bl 3001b82c <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick();
}
3000a1f8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a204 <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;
3000a204: e59f3004 ldr r3, [pc, #4] ; 3000a210 <rtems_clock_get_ticks_since_boot+0xc><== NOT EXECUTED 3000a208: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
3000a20c: e12fff1e bx lr <== NOT EXECUTED
30018efc <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
30018efc: e92d40d0 push {r4, r6, r7, lr} <== NOT EXECUTED
if ( !time )
30018f00: e2504000 subs r4, r0, #0 <== NOT EXECUTED
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
30018f04: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
if ( !time )
return RTEMS_INVALID_ADDRESS;
30018f08: 03a03009 moveq r3, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
30018f0c: 0a000004 beq 30018f24 <rtems_clock_get_tod_timeval+0x28> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
30018f10: e59f1068 ldr r1, [pc, #104] ; 30018f80 <rtems_clock_get_tod_timeval+0x84><== NOT EXECUTED 30018f14: e5d13014 ldrb r3, [r1, #20] <== NOT EXECUTED 30018f18: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30018f1c: 03a0300b moveq r3, #11 <== NOT EXECUTED
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
30018f20: 1a000002 bne 30018f30 <rtems_clock_get_tod_timeval+0x34> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
30018f24: e1a00003 mov r0, r3 <== NOT EXECUTED
30018f28: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30018f2c: e8bd80d0 pop {r4, r6, r7, pc} <== NOT EXECUTED
)
{
Timestamp_Control snapshot_as_timestamp;
Timestamp_Control *snapshot_as_timestamp_ptr;
snapshot_as_timestamp_ptr =
30018f30: e1a0000d mov r0, sp <== NOT EXECUTED 30018f34: ebffd2b8 bl 3000da1c <_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);
30018f38: e59f2044 ldr r2, [pc, #68] ; 30018f84 <rtems_clock_get_tod_timeval+0x88><== NOT EXECUTED
30018f3c: e89000c0 ldm r0, {r6, r7} <== NOT EXECUTED
30018f40: e3a03000 mov r3, #0 <== NOT EXECUTED
30018f44: e1a00006 mov r0, r6 <== NOT EXECUTED
30018f48: e1a01007 mov r1, r7 <== NOT EXECUTED
30018f4c: ebffb270 bl 30005914 <__divdi3> <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
30018f50: e59f202c ldr r2, [pc, #44] ; 30018f84 <rtems_clock_get_tod_timeval+0x88><== NOT EXECUTED 30018f54: e3a03000 mov r3, #0 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timeval(
const Timestamp64_Control *_timestamp,
struct timeval *_timeval
)
{
_timeval->tv_sec = (time_t) (*_timestamp / 1000000000U);
30018f58: e5840000 str r0, [r4] <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
30018f5c: e1a01007 mov r1, r7 <== NOT EXECUTED 30018f60: e1a00006 mov r0, r6 <== NOT EXECUTED 30018f64: eb004f59 bl 3002ccd0 <__moddi3> <== NOT EXECUTED 30018f68: e3a03000 mov r3, #0 <== NOT EXECUTED 30018f6c: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 30018f70: ebffb267 bl 30005914 <__divdi3> <== NOT EXECUTED
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
30018f74: e3a03000 mov r3, #0 <== NOT EXECUTED 30018f78: e5840004 str r0, [r4, #4] <== NOT EXECUTED 30018f7c: eaffffe8 b 30018f24 <rtems_clock_get_tod_timeval+0x28> <== NOT EXECUTED
3002a03c <rtems_clock_get_uptime>:
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
3002a03c: e3500000 cmp r0, #0 <== NOT EXECUTED
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
3002a040: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !uptime )
3002a044: 0a000002 beq 3002a054 <rtems_clock_get_uptime+0x18> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
3002a048: eb00025c bl 3002a9c0 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3002a04c: e3a00000 mov r0, #0 <== NOT EXECUTED
3002a050: 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;
3002a054: e3a00009 mov r0, #9 <== NOT EXECUTED
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
3002a058: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30017988 <rtems_clock_get_uptime_seconds>:
#endif
#include <rtems/rtems/clock.h>
time_t rtems_clock_get_uptime_seconds( void )
{
30017988: 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 (
3001798c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30017990: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30017994: 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;
30017998: e59f2018 ldr r2, [pc, #24] ; 300179b8 <rtems_clock_get_uptime_seconds+0x30><== NOT EXECUTED
3001799c: e2821008 add r1, r2, #8 <== NOT EXECUTED
300179a0: 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 (
300179a4: 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);
300179a8: e59f200c ldr r2, [pc, #12] ; 300179bc <rtems_clock_get_uptime_seconds+0x34><== NOT EXECUTED 300179ac: e3a03000 mov r3, #0 <== NOT EXECUTED 300179b0: eb005ed5 bl 3002f50c <__divdi3> <== NOT EXECUTED
_ISR_Enable( level );
_Timestamp_To_timespec( &snapshot_as_timestamp, &snapshot_as_timespec );
return snapshot_as_timespec.tv_sec;
}
300179b4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300179c0 <rtems_clock_get_uptime_timeval>:
#endif
#include <rtems/rtems/clock.h>
void rtems_clock_get_uptime_timeval( struct timeval *uptime )
{
300179c0: e92d40d0 push {r4, r6, r7, lr} <== NOT EXECUTED
300179c4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
300179c8: e1a04000 mov r4, r0 <== NOT EXECUTED
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
300179cc: e59f104c ldr r1, [pc, #76] ; 30017a20 <rtems_clock_get_uptime_timeval+0x60><== NOT EXECUTED 300179d0: e1a0000d mov r0, sp <== NOT EXECUTED 300179d4: eb0012ad bl 3001c490 <_TOD_Get_with_nanoseconds> <== NOT EXECUTED
Timestamp_Control snapshot_as_timestamp;
_TOD_Get_uptime( &snapshot_as_timestamp );
_Timestamp_To_timeval( &snapshot_as_timestamp, uptime );
300179d8: 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);
300179dc: e59f2040 ldr r2, [pc, #64] ; 30017a24 <rtems_clock_get_uptime_timeval+0x64><== NOT EXECUTED 300179e0: e3a03000 mov r3, #0 <== NOT EXECUTED 300179e4: e1a00006 mov r0, r6 <== NOT EXECUTED 300179e8: e1a01007 mov r1, r7 <== NOT EXECUTED 300179ec: eb005ec6 bl 3002f50c <__divdi3> <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
300179f0: e59f202c ldr r2, [pc, #44] ; 30017a24 <rtems_clock_get_uptime_timeval+0x64><== NOT EXECUTED 300179f4: e3a03000 mov r3, #0 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timeval(
const Timestamp64_Control *_timestamp,
struct timeval *_timeval
)
{
_timeval->tv_sec = (time_t) (*_timestamp / 1000000000U);
300179f8: e5840000 str r0, [r4] <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
300179fc: e1a01007 mov r1, r7 <== NOT EXECUTED 30017a00: e1a00006 mov r0, r6 <== NOT EXECUTED 30017a04: eb005ffb bl 3002f9f8 <__moddi3> <== NOT EXECUTED 30017a08: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 30017a0c: e3a03000 mov r3, #0 <== NOT EXECUTED 30017a10: eb005ebd bl 3002f50c <__divdi3> <== NOT EXECUTED 30017a14: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
30017a18: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30017a1c: e8bd80d0 pop {r4, r6, r7, pc} <== NOT EXECUTED
3000a230 <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 )
{
3000a230: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_TOD_Tickle_ticks();
3000a234: eb00057a bl 3000b824 <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
3000a238: e59f0034 ldr r0, [pc, #52] ; 3000a274 <rtems_clock_tick+0x44> 3000a23c: eb000f66 bl 3000dfdc <_Watchdog_Tickle>
* scheduler which support standard RTEMS features, this includes
* time-slicing management.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Tick( void )
{
_Scheduler.Operations.tick();
3000a240: e59f3030 ldr r3, [pc, #48] ; 3000a278 <rtems_clock_tick+0x48> 3000a244: e1a0e00f mov lr, pc 3000a248: e593f038 ldr pc, [r3, #56] ; 0x38
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
3000a24c: e59f3028 ldr r3, [pc, #40] ; 3000a27c <rtems_clock_tick+0x4c> 3000a250: e5d33004 ldrb r3, [r3, #4]
_Watchdog_Tickle_ticks();
_Scheduler_Tick();
if ( _Thread_Is_context_switch_necessary() &&
3000a254: e3530000 cmp r3, #0
3000a258: 0a000003 beq 3000a26c <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 )
3000a25c: e59f301c ldr r3, [pc, #28] ; 3000a280 <rtems_clock_tick+0x50><== NOT EXECUTED 3000a260: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a264: e3530000 cmp r3, #0 <== NOT EXECUTED
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
3000a268: 0b000b46 bleq 3000cf88 <_Thread_Dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
3000a26c: e3a00000 mov r0, #0
3000a270: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30014a20 <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
30014a20: e92d4070 push {r4, r5, r6, lr}
rtems_status_code sc;
if ( event_out != NULL ) {
30014a24: e2535000 subs r5, r3, #0
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
30014a28: e1a0c000 mov ip, r0 30014a2c: e24dd010 sub sp, sp, #16
} else {
*event_out = event->pending_events;
sc = RTEMS_SUCCESSFUL;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
30014a30: 03a00009 moveq r0, #9
rtems_event_set *event_out
)
{
rtems_status_code sc;
if ( event_out != NULL ) {
30014a34: 0a000007 beq 30014a58 <rtems_event_system_receive+0x38>
Thread_Control *executing = _Thread_Executing;
30014a38: e59f4058 ldr r4, [pc, #88] ; 30014a98 <rtems_event_system_receive+0x78>
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
30014a3c: e35c0000 cmp ip, #0
)
{
rtems_status_code sc;
if ( event_out != NULL ) {
Thread_Control *executing = _Thread_Executing;
30014a40: e5944008 ldr r4, [r4, #8]
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
30014a44: e59460f0 ldr r6, [r4, #240] ; 0xf0
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
30014a48: 1a000004 bne 30014a60 <rtems_event_system_receive+0x40>
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
30014a4c: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
30014a50: e1a0000c mov r0, ip <== NOT EXECUTED
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
30014a54: e5853000 str r3, [r5] <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
30014a58: e28dd010 add sp, sp, #16
30014a5c: e8bd8070 pop {r4, r5, r6, pc}
*
* 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;
30014a60: e59fc034 ldr ip, [pc, #52] ; 30014a9c <rtems_event_system_receive+0x7c> 30014a64: e59ce000 ldr lr, [ip]
++level;
30014a68: e28ee001 add lr, lr, #1
_Thread_Dispatch_disable_level = level;
30014a6c: e58ce000 str lr, [ip]
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
_Thread_Disable_dispatch();
_Event_Seize(
30014a70: e59fc028 ldr ip, [pc, #40] ; 30014aa0 <rtems_event_system_receive+0x80>
rtems_status_code sc;
if ( event_out != NULL ) {
Thread_Control *executing = _Thread_Executing;
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
30014a74: e2866004 add r6, r6, #4
if ( !_Event_sets_Is_empty( event_in ) ) {
_Thread_Disable_dispatch();
_Event_Seize(
30014a78: e58dc008 str ip, [sp, #8]
30014a7c: e3a0c701 mov ip, #262144 ; 0x40000
30014a80: e58dc00c str ip, [sp, #12]
30014a84: e88d0050 stm sp, {r4, r6}
30014a88: ebffdbf6 bl 3000ba68 <_Event_Seize>
executing,
event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
30014a8c: ebffe7c3 bl 3000e9a0 <_Thread_Enable_dispatch>
sc = executing->Wait.return_code;
30014a90: e5940034 ldr r0, [r4, #52] ; 0x34 30014a94: eaffffef b 30014a58 <rtems_event_system_receive+0x38>
3001091c <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3001091c: e92d40f0 push {r4, r5, r6, r7, lr}
Extension_Control *the_extension;
if ( !id )
30010920: e2525000 subs r5, r2, #0
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
30010924: e1a04000 mov r4, r0 30010928: e24dd004 sub sp, sp, #4
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3001092c: 03a00009 moveq r0, #9
rtems_id *id
)
{
Extension_Control *the_extension;
if ( !id )
30010930: 0a000002 beq 30010940 <rtems_extension_create+0x24>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
30010934: e3540000 cmp r4, #0
return RTEMS_INVALID_NAME;
30010938: 03a00003 moveq r0, #3
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
3001093c: 1a000001 bne 30010948 <rtems_extension_create+0x2c>
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30010940: e28dd004 add sp, sp, #4
30010944: e8bd80f0 pop {r4, r5, r6, r7, pc}
*
* 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;
30010948: e59f3074 ldr r3, [pc, #116] ; 300109c4 <rtems_extension_create+0xa8> 3001094c: e5932000 ldr r2, [r3]
++level;
30010950: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
30010954: 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 );
30010958: e59f7068 ldr r7, [pc, #104] ; 300109c8 <rtems_extension_create+0xac> 3001095c: e58d1000 str r1, [sp] 30010960: e1a00007 mov r0, r7 30010964: eb00039b bl 300117d8 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
30010968: e2506000 subs r6, r0, #0 3001096c: e59d1000 ldr r1, [sp]
30010970: 0a000010 beq 300109b8 <rtems_extension_create+0x9c>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
30010974: e286c024 add ip, r6, #36 ; 0x24
30010978: e1a0e001 mov lr, r1
3001097c: e8be000f ldm lr!, {r0, r1, r2, r3}
30010980: e8ac000f stmia ip!, {r0, r1, r2, r3}
30010984: e89e000f ldm lr, {r0, r1, r2, r3}
30010988: e88c000f stm ip, {r0, r1, r2, r3}
_User_extensions_Add_set( extension );
3001098c: e2860010 add r0, r6, #16 30010990: eb000b40 bl 30013698 <_User_extensions_Add_set>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30010994: e5963008 ldr r3, [r6, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30010998: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3001099c: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300109a0: e7826721 str r6, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300109a4: e586400c str r4, [r6, #12]
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
300109a8: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
300109ac: eb0008ad bl 30012c68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300109b0: e3a00000 mov r0, #0 300109b4: eaffffe1 b 30010940 <rtems_extension_create+0x24>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
_Thread_Enable_dispatch();
300109b8: eb0008aa bl 30012c68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
300109bc: e3a00005 mov r0, #5 <== NOT EXECUTED 300109c0: eaffffde b 30010940 <rtems_extension_create+0x24> <== NOT EXECUTED
3000d008 <rtems_extension_ident>:
rtems_status_code rtems_extension_ident(
rtems_name name,
rtems_id *id
)
{
3000d008: e1a02000 mov r2, r0 <== NOT EXECUTED
3000d00c: e1a03001 mov r3, r1 <== NOT EXECUTED
3000d010: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
status = _Objects_Name_to_id_u32(
3000d014: e1a01002 mov r1, r2 <== NOT EXECUTED 3000d018: e59f0010 ldr r0, [pc, #16] ; 3000d030 <rtems_extension_ident+0x28><== NOT EXECUTED 3000d01c: e3e02102 mvn r2, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000d020: eb000501 bl 3000e42c <_Objects_Name_to_id_u32> <== NOT EXECUTED
name,
OBJECTS_SEARCH_LOCAL_NODE,
id
);
return _Status_Object_name_errors_to_status[ status ];
3000d024: e59f3008 ldr r3, [pc, #8] ; 3000d034 <rtems_extension_ident+0x2c><== NOT EXECUTED
}
3000d028: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
3000d02c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ce14 <rtems_get_version_string>:
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
}
3000ce14: e59f0000 ldr r0, [pc] ; 3000ce1c <rtems_get_version_string+0x8><== NOT EXECUTED 3000ce18: e12fff1e bx lr <== NOT EXECUTED
3000b270 <rtems_interrupt_disable>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b270: e10f0000 mrs r0, CPSR <== NOT EXECUTED 3000b274: e3803080 orr r3, r0, #128 ; 0x80 <== NOT EXECUTED 3000b278: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_level previous_level;
_ISR_Disable( previous_level );
return previous_level;
}
3000b27c: e12fff1e bx lr <== NOT EXECUTED
3000b280 <rtems_interrupt_enable>:
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b280: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
void rtems_interrupt_enable(
rtems_interrupt_level previous_level
)
{
_ISR_Enable( previous_level );
}
3000b284: e12fff1e bx lr <== NOT EXECUTED
3000b288 <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 (
3000b288: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000b28c: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3000b290: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
void rtems_interrupt_flash(
rtems_interrupt_level previous_level
)
{
_ISR_Flash( previous_level );
}
3000b294: e12fff1e bx lr <== NOT EXECUTED
3000b298 <rtems_interrupt_is_in_progress>:
#undef rtems_interrupt_is_in_progress
bool rtems_interrupt_is_in_progress( void )
{
return _ISR_Is_in_progress();
3000b298: e59f300c ldr r3, [pc, #12] ; 3000b2ac <rtems_interrupt_is_in_progress+0x14><== NOT EXECUTED 3000b29c: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
3000b2a0: e2900000 adds r0, r0, #0 <== NOT EXECUTED 3000b2a4: 13a00001 movne r0, #1 <== NOT EXECUTED 3000b2a8: e12fff1e bx lr <== NOT EXECUTED
3000b2b0 <rtems_interrupt_level_body>:
Modes_Control rtems_interrupt_level_body(
uint32_t level
)
{
return RTEMS_INTERRUPT_LEVEL(level);
}
3000b2b0: e2000080 and r0, r0, #128 ; 0x80 <== NOT EXECUTED 3000b2b4: e12fff1e bx lr <== NOT EXECUTED
30012494 <rtems_io_close>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30012494: e59fc044 ldr ip, [pc, #68] ; 300124e0 <rtems_io_close+0x4c>
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30012498: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001249c: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300124a0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300124a4: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
300124a8: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300124ac: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
300124b0: e59fc02c ldr ip, [pc, #44] ; 300124e4 <rtems_io_close+0x50> 300124b4: e0833083 add r3, r3, r3, lsl #1 300124b8: e59cc000 ldr ip, [ip] 300124bc: e08c3183 add r3, ip, r3, lsl #3 300124c0: e5933008 ldr r3, [r3, #8]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
300124c4: e3530000 cmp r3, #0
300124c8: 0a000002 beq 300124d8 <rtems_io_close+0x44>
300124cc: e1a0e00f mov lr, pc
300124d0: e12fff13 bx r3
300124d4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
300124d8: e1a00003 mov r0, r3 <== NOT EXECUTED
}
300124dc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300124e8 <rtems_io_control>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300124e8: e59fc044 ldr ip, [pc, #68] ; 30012534 <rtems_io_control+0x4c>
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300124ec: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300124f0: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300124f4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300124f8: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
300124fc: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30012500: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
30012504: e59fc02c ldr ip, [pc, #44] ; 30012538 <rtems_io_control+0x50> 30012508: e0833083 add r3, r3, r3, lsl #1 3001250c: e59cc000 ldr ip, [ip] 30012510: e08c3183 add r3, ip, r3, lsl #3 30012514: e5933014 ldr r3, [r3, #20]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30012518: e3530000 cmp r3, #0
3001251c: 0a000002 beq 3001252c <rtems_io_control+0x44>
30012520: e1a0e00f mov lr, pc
30012524: e12fff13 bx r3
30012528: e49df004 pop {pc} ; (ldr pc, [sp], #4)
3001252c: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30012530: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3001253c <rtems_io_open>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001253c: e59fc044 ldr ip, [pc, #68] ; 30012588 <rtems_io_open+0x4c>
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30012540: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30012544: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30012548: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001254c: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30012550: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30012554: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
30012558: e59fc02c ldr ip, [pc, #44] ; 3001258c <rtems_io_open+0x50> 3001255c: e0833083 add r3, r3, r3, lsl #1 30012560: e59cc000 ldr ip, [ip] 30012564: e08c3183 add r3, ip, r3, lsl #3 30012568: e5933004 ldr r3, [r3, #4]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
3001256c: e3530000 cmp r3, #0
30012570: 0a000002 beq 30012580 <rtems_io_open+0x44>
30012574: e1a0e00f mov lr, pc
30012578: e12fff13 bx r3
3001257c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30012580: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30012584: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30012590 <rtems_io_read>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30012590: e59fc044 ldr ip, [pc, #68] ; 300125dc <rtems_io_read+0x4c>
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30012594: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30012598: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
3001259c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300125a0: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
300125a4: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300125a8: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
300125ac: e59fc02c ldr ip, [pc, #44] ; 300125e0 <rtems_io_read+0x50> 300125b0: e0833083 add r3, r3, r3, lsl #1 300125b4: e59cc000 ldr ip, [ip] 300125b8: e08c3183 add r3, ip, r3, lsl #3 300125bc: e593300c ldr r3, [r3, #12]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
300125c0: e3530000 cmp r3, #0
300125c4: 0a000002 beq 300125d4 <rtems_io_read+0x44>
300125c8: e1a0e00f mov lr, pc
300125cc: e12fff13 bx r3
300125d0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
300125d4: e1a00003 mov r0, r3 <== NOT EXECUTED
}
300125d8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c7e8 <rtems_io_register_driver>:
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000c7e8: e59fc154 ldr ip, [pc, #340] ; 3000c944 <rtems_io_register_driver+0x15c>
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;
3000c7ec: e59f3154 ldr r3, [pc, #340] ; 3000c948 <rtems_io_register_driver+0x160>
if ( rtems_interrupt_is_in_progress() )
3000c7f0: e59cc000 ldr ip, [ip]
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
)
{
3000c7f4: e92d4030 push {r4, r5, lr}
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000c7f8: e35c0000 cmp ip, #0
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
)
{
3000c7fc: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
3000c800: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
3000c804: 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() )
3000c808: 18bd8030 popne {r4, r5, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
3000c80c: e3520000 cmp r2, #0
3000c810: 0a00000c beq 3000c848 <rtems_io_register_driver+0x60>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
3000c814: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
3000c818: e5820000 str r0, [r2]
if ( driver_table == NULL )
3000c81c: 0a000009 beq 3000c848 <rtems_io_register_driver+0x60>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000c820: e591c000 ldr ip, [r1] 3000c824: e35c0000 cmp ip, #0
3000c828: 0a000003 beq 3000c83c <rtems_io_register_driver+0x54>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
3000c82c: e1500004 cmp r0, r4
3000c830: 8a000006 bhi 3000c850 <rtems_io_register_driver+0x68>
return RTEMS_INVALID_NUMBER;
3000c834: e3a0000a mov r0, #10 <== NOT EXECUTED
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
3000c838: e8bd8030 pop {r4, r5, pc} <== 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;
3000c83c: e591c004 ldr ip, [r1, #4] 3000c840: e35c0000 cmp ip, #0
3000c844: 1afffff8 bne 3000c82c <rtems_io_register_driver+0x44>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
3000c848: e3a00009 mov r0, #9 <== NOT EXECUTED
3000c84c: e8bd8030 pop {r4, r5, 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;
3000c850: e59f00f4 ldr r0, [pc, #244] ; 3000c94c <rtems_io_register_driver+0x164> 3000c854: e590c000 ldr ip, [r0]
++level;
3000c858: e28cc001 add ip, ip, #1
_Thread_Dispatch_disable_level = level;
3000c85c: e580c000 str ip, [r0]
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
3000c860: e3540000 cmp r4, #0
3000c864: 1a000021 bne 3000c8f0 <rtems_io_register_driver+0x108>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
3000c868: e593c000 ldr ip, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
3000c86c: e35c0000 cmp ip, #0
3000c870: 0a00002a beq 3000c920 <rtems_io_register_driver+0x138>
3000c874: e59fe0d4 ldr lr, [pc, #212] ; 3000c950 <rtems_io_register_driver+0x168> 3000c878: e59e3000 ldr r3, [lr] 3000c87c: ea000003 b 3000c890 <rtems_io_register_driver+0xa8> 3000c880: e2844001 add r4, r4, #1 3000c884: e154000c cmp r4, ip 3000c888: e2833018 add r3, r3, #24
3000c88c: 0a000023 beq 3000c920 <rtems_io_register_driver+0x138>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000c890: e5930000 ldr r0, [r3] 3000c894: e3500000 cmp r0, #0
3000c898: 1afffff8 bne 3000c880 <rtems_io_register_driver+0x98>
3000c89c: e5930004 ldr r0, [r3, #4] 3000c8a0: e3500000 cmp r0, #0
3000c8a4: 1afffff5 bne 3000c880 <rtems_io_register_driver+0x98>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
3000c8a8: e15c0004 cmp ip, r4
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000c8ac: e5824000 str r4, [r2] 3000c8b0: 11a03084 lslne r3, r4, #1
if ( m != n )
3000c8b4: 0a00001a beq 3000c924 <rtems_io_register_driver+0x13c>
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
3000c8b8: e59e2000 ldr r2, [lr]
3000c8bc: e0833004 add r3, r3, r4
3000c8c0: e082c183 add ip, r2, r3, lsl #3
3000c8c4: e1a0e001 mov lr, r1
3000c8c8: e8be000f ldm lr!, {r0, r1, r2, r3}
3000c8cc: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000c8d0: e89e0003 ldm lr, {r0, r1}
3000c8d4: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
3000c8d8: eb000830 bl 3000e9a0 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
3000c8dc: e3a01000 mov r1, #0 3000c8e0: e1a00004 mov r0, r4 3000c8e4: e1a02001 mov r2, r1
}
3000c8e8: e8bd4030 pop {r4, r5, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
3000c8ec: ea002169 b 30014e98 <rtems_io_initialize>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
3000c8f0: e59fe058 ldr lr, [pc, #88] ; 3000c950 <rtems_io_register_driver+0x168><== NOT EXECUTED 3000c8f4: e1a03084 lsl r3, r4, #1 <== NOT EXECUTED 3000c8f8: e59ec000 ldr ip, [lr] <== NOT EXECUTED 3000c8fc: e0830004 add r0, r3, r4 <== NOT EXECUTED 3000c900: e1a00180 lsl r0, r0, #3 <== 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;
3000c904: e79c5000 ldr r5, [ip, r0] <== NOT EXECUTED
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
3000c908: e08c0000 add r0, ip, r0 <== 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;
3000c90c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000c910: 0a000006 beq 3000c930 <rtems_io_register_driver+0x148> <== NOT EXECUTED
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
3000c914: eb000821 bl 3000e9a0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3000c918: e3a0000c mov r0, #12 <== NOT EXECUTED
3000c91c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000c920: e5824000 str r4, [r2] <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
3000c924: eb00081d bl 3000e9a0 <_Thread_Enable_dispatch> <== NOT EXECUTED
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
3000c928: 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;
3000c92c: e8bd8030 pop {r4, r5, pc} <== 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;
3000c930: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED 3000c934: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c938: 1afffff5 bne 3000c914 <rtems_io_register_driver+0x12c> <== NOT EXECUTED
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
3000c93c: e5824000 str r4, [r2] <== NOT EXECUTED 3000c940: eaffffdc b 3000c8b8 <rtems_io_register_driver+0xd0> <== NOT EXECUTED
3000c954 <rtems_io_unregister_driver>:
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000c954: e59f3060 ldr r3, [pc, #96] ; 3000c9bc <rtems_io_unregister_driver+0x68>
#include <string.h>
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
3000c958: e92d4010 push {r4, lr}
if ( rtems_interrupt_is_in_progress() )
3000c95c: e5934000 ldr r4, [r3] 3000c960: e3540000 cmp r4, #0
return RTEMS_CALLED_FROM_ISR;
3000c964: 13a00012 movne r0, #18
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000c968: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
3000c96c: e59f304c ldr r3, [pc, #76] ; 3000c9c0 <rtems_io_unregister_driver+0x6c> 3000c970: e5933000 ldr r3, [r3] 3000c974: e1530000 cmp r3, r0
3000c978: 8a000001 bhi 3000c984 <rtems_io_unregister_driver+0x30>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
3000c97c: e3a0000d mov r0, #13 <== NOT EXECUTED
}
3000c980: e8bd8010 pop {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;
3000c984: e59f3038 ldr r3, [pc, #56] ; 3000c9c4 <rtems_io_unregister_driver+0x70> 3000c988: e5932000 ldr r2, [r3]
++level;
3000c98c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000c990: e5832000 str r2, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
3000c994: e59f302c ldr r3, [pc, #44] ; 3000c9c8 <rtems_io_unregister_driver+0x74>
&_IO_Driver_address_table[major],
3000c998: e0800080 add r0, r0, r0, lsl #1
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
3000c99c: e5933000 ldr r3, [r3] 3000c9a0: e1a01004 mov r1, r4 3000c9a4: e3a02018 mov r2, #24 3000c9a8: e0830180 add r0, r3, r0, lsl #3 3000c9ac: eb002c60 bl 30017b34 <memset>
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
3000c9b0: eb0007fa bl 3000e9a0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c9b4: e1a00004 mov r0, r4
3000c9b8: e8bd8010 pop {r4, pc}
300125e4 <rtems_io_write>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300125e4: e59fc044 ldr ip, [pc, #68] ; 30012630 <rtems_io_write+0x4c>
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300125e8: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300125ec: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300125f0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300125f4: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
300125f8: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300125fc: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
30012600: e59fc02c ldr ip, [pc, #44] ; 30012634 <rtems_io_write+0x50> 30012604: e0833083 add r3, r3, r3, lsl #1 30012608: e59cc000 ldr ip, [ip] 3001260c: e08c3183 add r3, ip, r3, lsl #3 30012610: e5933010 ldr r3, [r3, #16]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30012614: e3530000 cmp r3, #0
30012618: 0a000002 beq 30012628 <rtems_io_write+0x44>
3001261c: e1a0e00f mov lr, pc
30012620: e12fff13 bx r3
30012624: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30012628: e1a00003 mov r0, r3 <== NOT EXECUTED
}
3001262c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000d390 <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)
{
3000d390: 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 )
3000d394: e2506000 subs r6, r0, #0 <== NOT EXECUTED
3000d398: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000d39c: e59f7054 ldr r7, [pc, #84] ; 3000d3f8 <rtems_iterate_over_all_threads+0x68><== NOT EXECUTED
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
3000d3a0: e287800c add r8, r7, #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 ];
3000d3a4: e5b73004 ldr r3, [r7, #4]! <== NOT EXECUTED 3000d3a8: e5935004 ldr r5, [r3, #4] <== NOT EXECUTED
if ( !information )
3000d3ac: e3550000 cmp r5, #0 <== NOT EXECUTED 3000d3b0: 0a00000d beq 3000d3ec <rtems_iterate_over_all_threads+0x5c><== NOT EXECUTED
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000d3b4: e1d521b0 ldrh r2, [r5, #16] <== NOT EXECUTED 3000d3b8: e3520000 cmp r2, #0 <== NOT EXECUTED 3000d3bc: 0a00000a beq 3000d3ec <rtems_iterate_over_all_threads+0x5c><== NOT EXECUTED 3000d3c0: e3a04001 mov r4, #1 <== NOT EXECUTED
the_thread = (Thread_Control *)information->local_table[ i ];
3000d3c4: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3000d3c8: e7930104 ldr r0, [r3, r4, lsl #2] <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000d3cc: e2844001 add r4, r4, #1 <== NOT EXECUTED
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
3000d3d0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d3d4: 0a000002 beq 3000d3e4 <rtems_iterate_over_all_threads+0x54><== NOT EXECUTED
continue;
(*routine)(the_thread);
3000d3d8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000d3dc: e12fff16 bx r6 <== NOT EXECUTED 3000d3e0: e1d521b0 ldrh r2, [r5, #16] <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000d3e4: e1520004 cmp r2, r4 <== NOT EXECUTED 3000d3e8: 2afffff5 bcs 3000d3c4 <rtems_iterate_over_all_threads+0x34><== NOT EXECUTED
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
3000d3ec: e1570008 cmp r7, r8 <== NOT EXECUTED
3000d3f0: 1affffeb bne 3000d3a4 <rtems_iterate_over_all_threads+0x14><== NOT EXECUTED
3000d3f4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30018258 <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
30018258: e92d40f0 push {r4, r5, r6, r7, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
3001825c: e2516000 subs r6, r1, #0
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
30018260: e24dd00c sub sp, sp, #12 30018264: e1a05000 mov r5, r0 30018268: e1a07002 mov r7, r2 3001826c: e1a04003 mov r4, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
30018270: 0a000015 beq 300182cc <rtems_message_queue_broadcast+0x74>
return RTEMS_INVALID_ADDRESS;
if ( !count )
30018274: e3530000 cmp r3, #0
30018278: 0a000013 beq 300182cc <rtems_message_queue_broadcast+0x74>
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
3001827c: e59f0054 ldr r0, [pc, #84] ; 300182d8 <rtems_message_queue_broadcast+0x80> 30018280: e1a01005 mov r1, r5 30018284: e28d2008 add r2, sp, #8 30018288: eb0015e5 bl 3001da24 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
3001828c: e59dc008 ldr ip, [sp, #8] 30018290: e35c0000 cmp ip, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018294: 13a00004 movne r0, #4
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30018298: 1a00000c bne 300182d0 <rtems_message_queue_broadcast+0x78>
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
3001829c: e1a01006 mov r1, r6 300182a0: e1a02007 mov r2, r7 300182a4: e1a03005 mov r3, r5 300182a8: e2800014 add r0, r0, #20 300182ac: e58dc000 str ip, [sp] 300182b0: e58d4004 str r4, [sp, #4] 300182b4: eb000e78 bl 3001bc9c <_CORE_message_queue_Broadcast> 300182b8: e1a04000 mov r4, r0
NULL,
#endif
count
);
_Thread_Enable_dispatch();
300182bc: eb0019a1 bl 3001e948 <_Thread_Enable_dispatch>
return
300182c0: e1a00004 mov r0, r4 300182c4: eb0000d6 bl 30018624 <_Message_queue_Translate_core_message_queue_return_code> 300182c8: ea000000 b 300182d0 <rtems_message_queue_broadcast+0x78>
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
300182cc: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300182d0: e28dd00c add sp, sp, #12
300182d4: e8bd80f0 pop {r4, r5, r6, r7, pc}
30012738 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30012738: e92d41f0 push {r4, r5, r6, r7, r8, lr}
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
size_t max_packet_payload_size;
#endif
if ( !rtems_is_name_valid( name ) )
3001273c: e2507000 subs r7, r0, #0
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30012740: e24dd008 sub sp, sp, #8 30012744: e1a05001 mov r5, r1 30012748: e1a06002 mov r6, r2 3001274c: e59d4020 ldr r4, [sp, #32]
bool is_global;
size_t max_packet_payload_size;
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30012750: 03a00003 moveq r0, #3
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
size_t max_packet_payload_size;
#endif
if ( !rtems_is_name_valid( name ) )
30012754: 1a000001 bne 30012760 <rtems_message_queue_create+0x28>
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30012758: e28dd008 add sp, sp, #8
3001275c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30012760: e3540000 cmp r4, #0
return RTEMS_INVALID_ADDRESS;
30012764: 03a00009 moveq r0, #9
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30012768: 0afffffa beq 30012758 <rtems_message_queue_create+0x20>
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
3001276c: e3510000 cmp r1, #0
return RTEMS_INVALID_NUMBER;
30012770: 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 )
30012774: 0afffff7 beq 30012758 <rtems_message_queue_create+0x20>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
30012778: e3520000 cmp r2, #0
return RTEMS_INVALID_SIZE;
3001277c: 03a00008 moveq r0, #8
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
30012780: 0afffff4 beq 30012758 <rtems_message_queue_create+0x20>
*
* 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;
30012784: e59f2098 ldr r2, [pc, #152] ; 30012824 <rtems_message_queue_create+0xec> 30012788: e5921000 ldr r1, [r2]
++level;
3001278c: e2811001 add r1, r1, #1
_Thread_Dispatch_disable_level = level;
30012790: e5821000 str r1, [r2]
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
30012794: e58d3000 str r3, [sp] 30012798: eb00192f bl 30018c5c <_Message_queue_Allocate>
if ( !the_message_queue ) {
3001279c: e2508000 subs r8, r0, #0 300127a0: e59d3000 ldr r3, [sp]
300127a4: 0a00001b beq 30012818 <rtems_message_queue_create+0xe0>
#endif
the_message_queue->attribute_set = attribute_set;
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
300127a8: e3130004 tst r3, #4 300127ac: 03a02000 moveq r2, #0 300127b0: 13a02001 movne r2, #1
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
300127b4: e28d1008 add r1, sp, #8 300127b8: e5212004 str r2, [r1, #-4]! 300127bc: e5883010 str r3, [r8, #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(
300127c0: e2880014 add r0, r8, #20 300127c4: e1a02005 mov r2, r5 300127c8: e1a03006 mov r3, r6 300127cc: eb0004e6 bl 30013b6c <_CORE_message_queue_Initialize> 300127d0: e3500000 cmp r0, #0
300127d4: 1a000005 bne 300127f0 <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 );
300127d8: e59f0048 ldr r0, [pc, #72] ; 30012828 <rtems_message_queue_create+0xf0><== NOT EXECUTED 300127dc: e1a01008 mov r1, r8 <== NOT EXECUTED 300127e0: eb0008d9 bl 30014b4c <_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();
300127e4: eb000cf8 bl 30015bcc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
300127e8: e3a0000d mov r0, #13 <== NOT EXECUTED 300127ec: eaffffd9 b 30012758 <rtems_message_queue_create+0x20> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300127f0: e59f2030 ldr r2, [pc, #48] ; 30012828 <rtems_message_queue_create+0xf0>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
300127f4: e5983008 ldr r3, [r8, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300127f8: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300127fc: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30012800: e7828721 str r8, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30012804: e588700c str r7, [r8, #12]
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
30012808: e5843000 str r3, [r4]
name,
0
);
#endif
_Thread_Enable_dispatch();
3001280c: eb000cee bl 30015bcc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30012810: e3a00000 mov r0, #0 30012814: eaffffcf b 30012758 <rtems_message_queue_create+0x20>
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
30012818: eb000ceb bl 30015bcc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3001281c: e3a00005 mov r0, #5 <== NOT EXECUTED 30012820: eaffffcc b 30012758 <rtems_message_queue_create+0x20> <== NOT EXECUTED
3001848c <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
3001848c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
30018490: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
30018494: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30018498: e1a01000 mov r1, r0 <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
3001849c: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
300184a0: 0a00000a beq 300184d0 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED 300184a4: e59f002c ldr r0, [pc, #44] ; 300184d8 <rtems_message_queue_get_number_pending+0x4c><== NOT EXECUTED 300184a8: e1a0200d mov r2, sp <== NOT EXECUTED 300184ac: eb00155c bl 3001da24 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300184b0: e59d5000 ldr r5, [sp] <== NOT EXECUTED 300184b4: e3550000 cmp r5, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300184b8: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300184bc: 1a000003 bne 300184d0 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
300184c0: e590305c ldr r3, [r0, #92] ; 0x5c <== NOT EXECUTED 300184c4: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
300184c8: eb00191e bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300184cc: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300184d0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300184d4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30012860 <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
30012860: e92d4070 push {r4, r5, r6, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
30012864: e2515000 subs r5, r1, #0
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
30012868: e24dd00c sub sp, sp, #12 3001286c: e1a01000 mov r1, r0 30012870: e1a04002 mov r4, r2 30012874: e1a06003 mov r6, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
30012878: 0a000018 beq 300128e0 <rtems_message_queue_receive+0x80>
return RTEMS_INVALID_ADDRESS;
if ( !size )
3001287c: e3520000 cmp r2, #0
30012880: 0a000016 beq 300128e0 <rtems_message_queue_receive+0x80>
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
30012884: e59f0060 ldr r0, [pc, #96] ; 300128ec <rtems_message_queue_receive+0x8c> 30012888: e28d2008 add r2, sp, #8 3001288c: eb000905 bl 30014ca8 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30012890: e59d3008 ldr r3, [sp, #8] 30012894: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30012898: 13a00004 movne r0, #4
if ( !size )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
3001289c: 1a000010 bne 300128e4 <rtems_message_queue_receive+0x84>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
300128a0: e59dc01c ldr ip, [sp, #28]
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
300128a4: e2066001 and r6, r6, #1 300128a8: e5901008 ldr r1, [r0, #8] 300128ac: e1a03004 mov r3, r4 300128b0: e2800014 add r0, r0, #20 300128b4: e1a02005 mov r2, r5 300128b8: e2266001 eor r6, r6, #1 300128bc: e58dc004 str ip, [sp, #4] 300128c0: e58d6000 str r6, [sp] 300128c4: eb0004db bl 30013c38 <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
300128c8: eb000cbf bl 30015bcc <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
_Thread_Executing->Wait.return_code
300128cc: e59f301c ldr r3, [pc, #28] ; 300128f0 <rtems_message_queue_receive+0x90> 300128d0: e5933008 ldr r3, [r3, #8]
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
300128d4: e5930034 ldr r0, [r3, #52] ; 0x34 300128d8: eb000025 bl 30012974 <_Message_queue_Translate_core_message_queue_return_code> 300128dc: ea000000 b 300128e4 <rtems_message_queue_receive+0x84>
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
300128e0: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300128e4: e28dd00c add sp, sp, #12
300128e8: e8bd8070 pop {r4, r5, r6, pc}
3000a654 <rtems_object_api_maximum_class>:
int rtems_object_api_maximum_class(
int api
)
{
return _Objects_API_maximum_class(api);
3000a654: ea0005fc b 3000be4c <_Objects_API_maximum_class> <== NOT EXECUTED
3000a658 <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 )
3000a658: e2400001 sub r0, r0, #1 <== NOT EXECUTED
int api
)
{
if ( _Objects_Is_api_valid( api ) )
return 1;
return -1;
3000a65c: e3500003 cmp r0, #3 <== NOT EXECUTED
}
3000a660: 33a00001 movcc r0, #1 <== NOT EXECUTED 3000a664: 23e00000 mvncs r0, #0 <== NOT EXECUTED 3000a668: e12fff1e bx lr <== NOT EXECUTED
3000a66c <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
3000a66c: e3500001 cmp r0, #1 <== NOT EXECUTED
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
3000a670: 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 )
3000a674: 0a00000d beq 3000a6b0 <rtems_object_get_api_class_name+0x44><== NOT EXECUTED
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
3000a678: e3500002 cmp r0, #2 <== NOT EXECUTED 3000a67c: 0a000004 beq 3000a694 <rtems_object_get_api_class_name+0x28><== NOT EXECUTED
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
3000a680: e3500003 cmp r0, #3 <== NOT EXECUTED
api_assoc = rtems_object_api_posix_assoc;
3000a684: 059f003c ldreq r0, [pc, #60] ; 3000a6c8 <rtems_object_get_api_class_name+0x5c><== 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 )
3000a688: 0a000002 beq 3000a698 <rtems_object_get_api_class_name+0x2c><== NOT EXECUTED
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
3000a68c: e59f0038 ldr r0, [pc, #56] ; 3000a6cc <rtems_object_get_api_class_name+0x60><== NOT EXECUTED
3000a690: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
3000a694: e59f0034 ldr r0, [pc, #52] ; 3000a6d0 <rtems_object_get_api_class_name+0x64><== 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 );
3000a698: eb00128b bl 3000f0cc <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( class_assoc )
3000a69c: e3500000 cmp r0, #0 <== NOT EXECUTED
return class_assoc->name;
3000a6a0: 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 )
3000a6a4: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
return class_assoc->name;
return "BAD CLASS";
3000a6a8: e59f0024 ldr r0, [pc, #36] ; 3000a6d4 <rtems_object_get_api_class_name+0x68><== NOT EXECUTED
}
3000a6ac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== 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;
3000a6b0: e59f0020 ldr r0, [pc, #32] ; 3000a6d8 <rtems_object_get_api_class_name+0x6c><== 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 );
3000a6b4: eb001284 bl 3000f0cc <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( class_assoc )
3000a6b8: e3500000 cmp r0, #0 <== NOT EXECUTED
return class_assoc->name;
3000a6bc: 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 )
3000a6c0: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
3000a6c4: eafffff7 b 3000a6a8 <rtems_object_get_api_class_name+0x3c> <== NOT EXECUTED
3000a6dc <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
3000a6dc: e1a01000 mov r1, r0 <== NOT EXECUTED
3000a6e0: 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 );
3000a6e4: e59f0010 ldr r0, [pc, #16] ; 3000a6fc <rtems_object_get_api_name+0x20><== NOT EXECUTED 3000a6e8: eb001277 bl 3000f0cc <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( api_assoc )
3000a6ec: e3500000 cmp r0, #0 <== NOT EXECUTED
return api_assoc->name;
3000a6f0: 15900000 ldrne r0, [r0] <== NOT EXECUTED
return "BAD CLASS";
3000a6f4: 059f0004 ldreq r0, [pc, #4] ; 3000a700 <rtems_object_get_api_name+0x24><== NOT EXECUTED
}
3000a6f8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c290 <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
)
{
3000c290: e92d4010 push {r4, lr} <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000c294: e2524000 subs r4, r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000c298: 03a00009 moveq r0, #9 <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000c29c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
3000c2a0: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000c2a4: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000c2a8: eb000734 bl 3000df80 <_Objects_Get_information> <== NOT EXECUTED
if ( !obj_info )
3000c2ac: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c2b0: 0a000018 beq 3000c318 <rtems_object_get_class_information+0x88><== 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; info->maximum = obj_info->maximum;
3000c2b4: 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;
3000c2b8: e590c008 ldr ip, [r0, #8] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000c2bc: e590200c ldr r2, [r0, #12] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000c2c0: e5d03012 ldrb r3, [r0, #18] <== NOT EXECUTED
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000c2c4: e3510000 cmp r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
3000c2c8: e584c000 str ip, [r4] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000c2cc: e5842004 str r2, [r4, #4] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000c2d0: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED
info->maximum = obj_info->maximum;
3000c2d4: e5841008 str r1, [r4, #8] <== NOT EXECUTED
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000c2d8: 01a0c001 moveq ip, r1 <== NOT EXECUTED 3000c2dc: 0a00000a beq 3000c30c <rtems_object_get_class_information+0x7c><== NOT EXECUTED 3000c2e0: e3a02001 mov r2, #1 <== NOT EXECUTED 3000c2e4: e590001c ldr r0, [r0, #28] <== NOT EXECUTED 3000c2e8: e1a03002 mov r3, r2 <== NOT EXECUTED 3000c2ec: e3a0c000 mov ip, #0 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000c2f0: e7902102 ldr r2, [r0, r2, 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++ )
3000c2f4: e2833001 add r3, r3, #1 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000c2f8: e3520000 cmp r2, #0 <== NOT EXECUTED
unallocated++;
3000c2fc: 028cc001 addeq ip, ip, #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++ )
3000c300: e1510003 cmp r1, r3 <== NOT EXECUTED 3000c304: e1a02003 mov r2, r3 <== NOT EXECUTED 3000c308: 2afffff8 bcs 3000c2f0 <rtems_object_get_class_information+0x60><== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
3000c30c: e584c010 str ip, [r4, #16] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c310: e3a00000 mov r0, #0 <== NOT EXECUTED
3000c314: 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;
3000c318: e3a0000a mov r0, #10 <== NOT EXECUTED
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
3000c31c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30018954 <rtems_object_get_name>:
Objects_Id id,
size_t length,
char *name
)
{
return _Objects_Get_name_as_string( id, length, name );
30018954: ea00035f b 300196d8 <_Objects_Get_name_as_string> <== NOT EXECUTED
3000c324 <rtems_object_id_api_maximum>:
#undef rtems_object_id_api_maximum
int rtems_object_id_api_maximum(void)
{
return OBJECTS_APIS_LAST;
}
3000c324: e3a00003 mov r0, #3 <== NOT EXECUTED 3000c328: e12fff1e bx lr <== NOT EXECUTED
3000c32c <rtems_object_id_api_minimum>:
#undef rtems_object_id_api_minimum
int rtems_object_id_api_minimum(void)
{
return OBJECTS_INTERNAL_API;
}
3000c32c: e3a00001 mov r0, #1 <== NOT EXECUTED 3000c330: e12fff1e bx lr <== NOT EXECUTED
3000c334 <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);
3000c334: e1a00c20 lsr r0, r0, #24 <== NOT EXECUTED
int rtems_object_id_get_api(
rtems_id id
)
{
return _Objects_Get_API( id );
}
3000c338: e2000007 and r0, r0, #7 <== NOT EXECUTED 3000c33c: e12fff1e bx lr <== NOT EXECUTED
3000c340 <rtems_object_id_get_class>:
int rtems_object_id_get_class(
rtems_id id
)
{
return _Objects_Get_class( id );
}
3000c340: e1a00da0 lsr r0, r0, #27 <== NOT EXECUTED 3000c344: e12fff1e bx lr <== NOT EXECUTED
3000c348 <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 );
3000c348: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
}
3000c34c: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 3000c350: e12fff1e bx lr <== NOT EXECUTED
3000c354 <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;
3000c354: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
int rtems_object_id_get_node(
rtems_id id
)
{
return _Objects_Get_node( id );
}
3000c358: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 3000c35c: e12fff1e bx lr <== NOT EXECUTED
3000a708 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
3000a708: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000a70c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
3000a710: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
3000a714: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000a718: 0a00000f beq 3000a75c <rtems_object_set_name+0x54> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000a71c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a720: 059f3058 ldreq r3, [pc, #88] ; 3000a780 <rtems_object_set_name+0x78><== NOT EXECUTED 3000a724: 11a05000 movne r5, r0 <== NOT EXECUTED 3000a728: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED 3000a72c: 05935008 ldreq r5, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3000a730: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a734: eb0006a3 bl 3000c1c8 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
3000a738: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000a73c: 0a000005 beq 3000a758 <rtems_object_set_name+0x50> <== NOT EXECUTED
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
3000a740: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a744: e1a0200d mov r2, sp <== NOT EXECUTED 3000a748: eb000723 bl 3000c3dc <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000a74c: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000a750: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a754: 0a000002 beq 3000a764 <rtems_object_set_name+0x5c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a758: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000a75c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a760: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
3000a764: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a768: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a76c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a770: eb000776 bl 3000c550 <_Objects_Set_name> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a774: eb000af5 bl 3000d350 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a778: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a77c: eafffff6 b 3000a75c <rtems_object_set_name+0x54> <== NOT EXECUTED
3000bd0c <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000bd0c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
3000bd10: e2506000 subs r6, r0, #0
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000bd14: e24dd008 sub sp, sp, #8 3000bd18: e1a04001 mov r4, r1 3000bd1c: e59d502c ldr r5, [sp, #44] ; 0x2c
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000bd20: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
3000bd24: 1a000001 bne 3000bd30 <rtems_partition_create+0x24>
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000bd28: e28dd008 add sp, sp, #8
3000bd2c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
3000bd30: e3510000 cmp r1, #0
3000bd34: 0a000006 beq 3000bd54 <rtems_partition_create+0x48>
return RTEMS_INVALID_ADDRESS;
if ( !id )
3000bd38: e3550000 cmp r5, #0
3000bd3c: 0a000004 beq 3000bd54 <rtems_partition_create+0x48>
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
3000bd40: e3520000 cmp r2, #0 3000bd44: 13530000 cmpne r3, #0
3000bd48: 1a000003 bne 3000bd5c <rtems_partition_create+0x50>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
3000bd4c: e3a00008 mov r0, #8 <== NOT EXECUTED 3000bd50: eafffff4 b 3000bd28 <rtems_partition_create+0x1c> <== NOT EXECUTED
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
3000bd54: e3a00009 mov r0, #9 <== NOT EXECUTED 3000bd58: eafffff2 b 3000bd28 <rtems_partition_create+0x1c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
3000bd5c: e1520003 cmp r2, r3
3000bd60: 3afffff9 bcc 3000bd4c <rtems_partition_create+0x40>
3000bd64: e3130003 tst r3, #3
3000bd68: 1afffff7 bne 3000bd4c <rtems_partition_create+0x40>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
3000bd6c: e2118007 ands r8, r1, #7
3000bd70: 1afffff7 bne 3000bd54 <rtems_partition_create+0x48>
*
* 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;
3000bd74: e59f109c ldr r1, [pc, #156] ; 3000be18 <rtems_partition_create+0x10c> 3000bd78: e5910000 ldr r0, [r1]
++level;
3000bd7c: e2800001 add r0, r0, #1
_Thread_Dispatch_disable_level = level;
3000bd80: e5810000 str r0, [r1]
* 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 );
3000bd84: e59fa090 ldr sl, [pc, #144] ; 3000be1c <rtems_partition_create+0x110> 3000bd88: e58d2004 str r2, [sp, #4] 3000bd8c: e1a0000a mov r0, sl 3000bd90: e58d3000 str r3, [sp] 3000bd94: eb000708 bl 3000d9bc <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
3000bd98: e2507000 subs r7, r0, #0 3000bd9c: e59d2004 ldr r2, [sp, #4] 3000bda0: e59d3000 ldr r3, [sp]
3000bda4: 0a000018 beq 3000be0c <rtems_partition_create+0x100>
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
3000bda8: e59d1028 ldr r1, [sp, #40] ; 0x28
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
3000bdac: e5872014 str r2, [r7, #20]
the_partition->buffer_size = buffer_size;
3000bdb0: e5873018 str r3, [r7, #24]
the_partition->attribute_set = attribute_set;
3000bdb4: e587101c str r1, [r7, #28]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
3000bdb8: e5874010 str r4, [r7, #16]
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
3000bdbc: e1a01003 mov r1, r3
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
3000bdc0: e5878020 str r8, [r7, #32]
_Chain_Initialize( &the_partition->Memory, starting_address,
3000bdc4: e1a00002 mov r0, r2 3000bdc8: e58d3000 str r3, [sp] 3000bdcc: eb004675 bl 3001d7a8 <__aeabi_uidiv> 3000bdd0: e2879024 add r9, r7, #36 ; 0x24 3000bdd4: e1a02000 mov r2, r0 3000bdd8: e1a01004 mov r1, r4 3000bddc: e1a00009 mov r0, r9 3000bde0: e59d3000 ldr r3, [sp] 3000bde4: eb00046a bl 3000cf94 <_Chain_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bde8: e59a201c ldr r2, [sl, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000bdec: e5973008 ldr r3, [r7, #8] 3000bdf0: e1d710b8 ldrh r1, [r7, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bdf4: e7827101 str r7, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000bdf8: e587600c str r6, [r7, #12]
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
3000bdfc: e5853000 str r3, [r5]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
3000be00: eb000c00 bl 3000ee08 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000be04: e1a00008 mov r0, r8 3000be08: eaffffc6 b 3000bd28 <rtems_partition_create+0x1c>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
3000be0c: eb000bfd bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000be10: e3a00005 mov r0, #5 <== NOT EXECUTED 3000be14: eaffffc3 b 3000bd28 <rtems_partition_create+0x1c> <== NOT EXECUTED
300187c8 <rtems_partition_delete>:
#include <rtems/score/sysstate.h>
rtems_status_code rtems_partition_delete(
rtems_id id
)
{
300187c8: e92d4030 push {r4, r5, lr}
300187cc: e24dd004 sub sp, sp, #4
300187d0: e1a01000 mov r1, r0
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
300187d4: e1a0200d mov r2, sp 300187d8: e59f0054 ldr r0, [pc, #84] ; 30018834 <rtems_partition_delete+0x6c> 300187dc: eb001490 bl 3001da24 <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
300187e0: e59d3000 ldr r3, [sp] 300187e4: e1a04000 mov r4, r0 300187e8: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300187ec: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
300187f0: 1a000004 bne 30018808 <rtems_partition_delete+0x40>
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
300187f4: e5945020 ldr r5, [r4, #32] 300187f8: e3550000 cmp r5, #0
300187fc: 0a000003 beq 30018810 <rtems_partition_delete+0x48>
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
30018800: eb001850 bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
30018804: e3a0000c mov r0, #12 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018808: e28dd004 add sp, sp, #4
3001880c: e8bd8030 pop {r4, r5, pc}
the_partition = _Partition_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
_Objects_Close( &_Partition_Information, &the_partition->Object );
30018810: e59f001c ldr r0, [pc, #28] ; 30018834 <rtems_partition_delete+0x6c> 30018814: e1a01004 mov r1, r4 30018818: eb001361 bl 3001d5a4 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Partition_Free (
Partition_Control *the_partition
)
{
_Objects_Free( &_Partition_Information, &the_partition->Object );
3001881c: e59f0010 ldr r0, [pc, #16] ; 30018834 <rtems_partition_delete+0x6c> 30018820: e1a01004 mov r1, r4 30018824: eb001419 bl 3001d890 <_Objects_Free>
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
30018828: eb001846 bl 3001e948 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3001882c: e1a00005 mov r0, r5 30018830: eafffff4 b 30018808 <rtems_partition_delete+0x40>
300188e4 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
300188e4: e92d4070 push {r4, r5, r6, lr}
300188e8: e1a03000 mov r3, r0
300188ec: e24dd004 sub sp, sp, #4
300188f0: e1a04001 mov r4, r1
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
300188f4: e59f008c ldr r0, [pc, #140] ; 30018988 <rtems_partition_return_buffer+0xa4> 300188f8: e1a01003 mov r1, r3 300188fc: e1a0200d mov r2, sp 30018900: eb001447 bl 3001da24 <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30018904: e59d3000 ldr r3, [sp] 30018908: e1a05000 mov r5, r0 3001890c: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018910: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30018914: 1a000016 bne 30018974 <rtems_partition_return_buffer+0x90>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
30018918: e5950010 ldr r0, [r5, #16] 3001891c: e5953014 ldr r3, [r5, #20] 30018920: e0803003 add r3, r0, r3
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
30018924: e1540003 cmp r4, r3 30018928: 83a03000 movhi r3, #0 3001892c: 93a03001 movls r3, #1 30018930: e1540000 cmp r4, r0 30018934: 33a03000 movcc r3, #0
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
30018938: e3530000 cmp r3, #0
3001893c: 0a00000e beq 3001897c <rtems_partition_return_buffer+0x98>
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
30018940: e0600004 rsb r0, r0, r4 30018944: e5951018 ldr r1, [r5, #24] 30018948: eb00582d bl 3002ea04 <__umodsi3>
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
3001894c: e2506000 subs r6, r0, #0
30018950: 1a000009 bne 3001897c <rtems_partition_return_buffer+0x98>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
30018954: e2850024 add r0, r5, #36 ; 0x24 30018958: e1a01004 mov r1, r4 3001895c: eb000c9d bl 3001bbd8 <_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;
30018960: e5953020 ldr r3, [r5, #32] 30018964: e2433001 sub r3, r3, #1 30018968: e5853020 str r3, [r5, #32]
_Thread_Enable_dispatch();
3001896c: eb0017f5 bl 3001e948 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30018970: e1a00006 mov r0, r6
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018974: e28dd004 add sp, sp, #4
30018978: e8bd8070 pop {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();
3001897c: eb0017f1 bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30018980: e3a00009 mov r0, #9 <== NOT EXECUTED 30018984: eafffffa b 30018974 <rtems_partition_return_buffer+0x90> <== NOT EXECUTED
30017ca0 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
30017ca0: e92d40f0 push {r4, r5, r6, r7, lr}
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
30017ca4: e2504000 subs r4, r0, #0
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
30017ca8: e24dd00c sub sp, sp, #12 30017cac: e59d5020 ldr r5, [sp, #32]
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30017cb0: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
30017cb4: 1a000001 bne 30017cc0 <rtems_port_create+0x20>
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30017cb8: e28dd00c add sp, sp, #12
30017cbc: e8bd80f0 pop {r4, r5, r6, r7, pc}
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30017cc0: e3550000 cmp r5, #0
30017cc4: 0a000002 beq 30017cd4 <rtems_port_create+0x34>
#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(
30017cc8: e1826001 orr r6, r2, r1
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
30017ccc: e2166007 ands r6, r6, #7
30017cd0: 0a000001 beq 30017cdc <rtems_port_create+0x3c>
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
30017cd4: e3a00009 mov r0, #9 <== NOT EXECUTED 30017cd8: eafffff6 b 30017cb8 <rtems_port_create+0x18> <== 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;
30017cdc: e59f0074 ldr r0, [pc, #116] ; 30017d58 <rtems_port_create+0xb8> 30017ce0: e590c000 ldr ip, [r0]
++level;
30017ce4: e28cc001 add ip, ip, #1
_Thread_Dispatch_disable_level = level;
30017ce8: e580c000 str ip, [r0]
* of free port control blocks.
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
30017cec: e59f7068 ldr r7, [pc, #104] ; 30017d5c <rtems_port_create+0xbc> 30017cf0: e58d1008 str r1, [sp, #8] 30017cf4: e1a00007 mov r0, r7 30017cf8: e58d2004 str r2, [sp, #4] 30017cfc: e58d3000 str r3, [sp] 30017d00: eb001604 bl 3001d518 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
30017d04: e3500000 cmp r0, #0 30017d08: e59d1008 ldr r1, [sp, #8] 30017d0c: e59d2004 ldr r2, [sp, #4] 30017d10: e59d3000 ldr r3, [sp]
30017d14: 0a00000c beq 30017d4c <rtems_port_create+0xac>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30017d18: e590c008 ldr ip, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017d1c: e597e01c ldr lr, [r7, #28]
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
the_port->external_base = external_start;
the_port->length = length - 1;
30017d20: e2433001 sub r3, r3, #1
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30017d24: e1a0780c lsl r7, ip, #16
if ( !the_port ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
30017d28: e5801010 str r1, [r0, #16]
the_port->external_base = external_start;
30017d2c: e5802014 str r2, [r0, #20]
the_port->length = length - 1;
30017d30: e5803018 str r3, [r0, #24]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017d34: e78e0727 str r0, [lr, r7, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30017d38: e580400c str r4, [r0, #12]
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
30017d3c: e585c000 str ip, [r5]
_Thread_Enable_dispatch();
30017d40: eb001b00 bl 3001e948 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30017d44: e1a00006 mov r0, r6 30017d48: eaffffda b 30017cb8 <rtems_port_create+0x18>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
_Thread_Enable_dispatch();
30017d4c: eb001afd bl 3001e948 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
30017d50: e3a00005 mov r0, #5 30017d54: eaffffd7 b 30017cb8 <rtems_port_create+0x18>
3001898c <rtems_rate_monotonic_cancel>:
#include <rtems/score/thread.h>
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
3001898c: e92d4030 push {r4, r5, lr}
30018990: e24dd004 sub sp, sp, #4
30018994: e1a01000 mov r1, r0
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
30018998: e1a0200d mov r2, sp 3001899c: e59f0064 ldr r0, [pc, #100] ; 30018a08 <rtems_rate_monotonic_cancel+0x7c> 300189a0: eb00141f bl 3001da24 <_Objects_Get>
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300189a4: e59d4000 ldr r4, [sp] 300189a8: e1a05000 mov r5, r0 300189ac: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300189b0: 13a00004 movne r0, #4
{
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300189b4: 1a000006 bne 300189d4 <rtems_rate_monotonic_cancel+0x48>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
300189b8: e59f304c ldr r3, [pc, #76] ; 30018a0c <rtems_rate_monotonic_cancel+0x80> 300189bc: e5952040 ldr r2, [r5, #64] ; 0x40 300189c0: e5933008 ldr r3, [r3, #8] 300189c4: e1520003 cmp r2, r3
300189c8: 0a000003 beq 300189dc <rtems_rate_monotonic_cancel+0x50>
_Thread_Enable_dispatch();
300189cc: eb0017dd bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
300189d0: e3a00017 mov r0, #23 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300189d4: e28dd004 add sp, sp, #4
300189d8: e8bd8030 pop {r4, r5, pc}
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
(void) _Watchdog_Remove( &the_period->Timer );
300189dc: e2850010 add r0, r5, #16 300189e0: eb001bcb bl 3001f914 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Scheduler_Release_job(
Thread_Control *the_thread,
uint32_t length
)
{
_Scheduler.Operations.release_job(the_thread, length);
300189e4: e5950040 ldr r0, [r5, #64] ; 0x40 300189e8: e1a01004 mov r1, r4 300189ec: e59f301c ldr r3, [pc, #28] ; 30018a10 <rtems_rate_monotonic_cancel+0x84>
the_period->state = RATE_MONOTONIC_INACTIVE;
300189f0: e5854038 str r4, [r5, #56] ; 0x38 300189f4: e1a0e00f mov lr, pc 300189f8: e593f034 ldr pc, [r3, #52] ; 0x34
_Scheduler_Release_job(the_period->owner, 0);
_Thread_Enable_dispatch();
300189fc: eb0017d1 bl 3001e948 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30018a00: e1a00004 mov r0, r4 30018a04: eafffff2 b 300189d4 <rtems_rate_monotonic_cancel+0x48>
3000be20 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000be20: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000be24: e2506000 subs r6, r0, #0
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000be28: e1a05001 mov r5, r1
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000be2c: 03a00003 moveq r0, #3
rtems_id *id
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000be30: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_NAME;
if ( !id )
3000be34: e3510000 cmp r1, #0
3000be38: 0a000024 beq 3000bed0 <rtems_rate_monotonic_create+0xb0>
*
* 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;
3000be3c: e59f30a0 ldr r3, [pc, #160] ; 3000bee4 <rtems_rate_monotonic_create+0xc4> 3000be40: e5932000 ldr r2, [r3]
++level;
3000be44: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000be48: 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 *)
3000be4c: e59f8094 ldr r8, [pc, #148] ; 3000bee8 <rtems_rate_monotonic_create+0xc8> 3000be50: e1a00008 mov r0, r8 3000be54: eb0006d8 bl 3000d9bc <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
3000be58: e2504000 subs r4, r0, #0
3000be5c: 0a00001d beq 3000bed8 <rtems_rate_monotonic_create+0xb8>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000be60: e59f3084 ldr r3, [pc, #132] ; 3000beec <rtems_rate_monotonic_create+0xcc>
the_period->state = RATE_MONOTONIC_INACTIVE;
3000be64: e3a07000 mov r7, #0
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000be68: 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 );
3000be6c: e1a01007 mov r1, r7 3000be70: e3a02038 mov r2, #56 ; 0x38
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000be74: e5843040 str r3, [r4, #64] ; 0x40
the_period->state = RATE_MONOTONIC_INACTIVE;
3000be78: e5847038 str r7, [r4, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000be7c: e5847018 str r7, [r4, #24]
the_watchdog->routine = routine;
3000be80: e584702c str r7, [r4, #44] ; 0x2c
the_watchdog->id = id;
3000be84: e5847030 str r7, [r4, #48] ; 0x30
the_watchdog->user_data = user_data;
3000be88: e5847034 str r7, [r4, #52] ; 0x34
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000be8c: e2840054 add r0, r4, #84 ; 0x54 3000be90: eb0024ae bl 30015150 <memset>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000be94: e5943008 ldr r3, [r4, #8]
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
3000be98: e59f0050 ldr r0, [pc, #80] ; 3000bef0 <rtems_rate_monotonic_create+0xd0>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000be9c: e598201c ldr r2, [r8, #28] 3000bea0: e59f104c ldr r1, [pc, #76] ; 3000bef4 <rtems_rate_monotonic_create+0xd4>
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000bea4: e1a0c803 lsl ip, r3, #16 3000bea8: e584005c str r0, [r4, #92] ; 0x5c 3000beac: e5841060 str r1, [r4, #96] ; 0x60 3000beb0: e5840074 str r0, [r4, #116] ; 0x74 3000beb4: e5841078 str r1, [r4, #120] ; 0x78
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000beb8: e782472c str r4, [r2, ip, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000bebc: e584600c str r6, [r4, #12]
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
3000bec0: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000bec4: eb000bcf bl 3000ee08 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000bec8: e1a00007 mov r0, r7
3000becc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000bed0: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000bed4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
3000bed8: eb000bca bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000bedc: e3a00005 mov r0, #5 <== NOT EXECUTED
3000bee0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30036e20 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
30036e20: e92d4370 push {r4, r5, r6, r8, r9, lr} <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
30036e24: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
30036e28: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30036e2c: e1a01000 mov r1, r0 <== NOT EXECUTED
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
30036e30: 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 )
30036e34: 0a000060 beq 30036fbc <rtems_rate_monotonic_get_statistics+0x19c><== NOT EXECUTED 30036e38: e59f0184 ldr r0, [pc, #388] ; 30036fc4 <rtems_rate_monotonic_get_statistics+0x1a4><== NOT EXECUTED 30036e3c: e1a0200d mov r2, sp <== NOT EXECUTED 30036e40: ebff5702 bl 3000ca50 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30036e44: e59d6000 ldr r6, [sp] <== NOT EXECUTED 30036e48: e1a05000 mov r5, r0 <== NOT EXECUTED 30036e4c: e3560000 cmp r6, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30036e50: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30036e54: 1a000058 bne 30036fbc <rtems_rate_monotonic_get_statistics+0x19c><== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
30036e58: e5950054 ldr r0, [r5, #84] ; 0x54 <== NOT EXECUTED
dst->missed_count = src->missed_count;
30036e5c: e5951058 ldr r1, [r5, #88] ; 0x58 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30036e60: e285905c add r9, r5, #92 ; 0x5c <== NOT EXECUTED
30036e64: e8990300 ldm r9, {r8, r9} <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30036e68: e59f2158 ldr r2, [pc, #344] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
dst->missed_count = src->missed_count;
30036e6c: e8840003 stm r4, {r0, r1} <== NOT EXECUTED
30036e70: e3a03000 mov r3, #0 <== NOT EXECUTED
30036e74: e1a00008 mov r0, r8 <== NOT EXECUTED
30036e78: e1a01009 mov r1, r9 <== NOT EXECUTED
30036e7c: eb0076f0 bl 30054a44 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036e80: e59f2140 ldr r2, [pc, #320] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036e84: 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);
30036e88: e5840008 str r0, [r4, #8] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036e8c: e1a01009 mov r1, r9 <== NOT EXECUTED 30036e90: e1a00008 mov r0, r8 <== NOT EXECUTED 30036e94: eb007825 bl 30054f30 <__moddi3> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30036e98: e2859064 add r9, r5, #100 ; 0x64 <== NOT EXECUTED
30036e9c: e8990300 ldm r9, {r8, r9} <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30036ea0: e59f2120 ldr r2, [pc, #288] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036ea4: e3a03000 mov r3, #0 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036ea8: 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);
30036eac: e1a01009 mov r1, r9 <== NOT EXECUTED 30036eb0: e1a00008 mov r0, r8 <== NOT EXECUTED 30036eb4: eb0076e2 bl 30054a44 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036eb8: e59f2108 ldr r2, [pc, #264] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036ebc: 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);
30036ec0: e5840010 str r0, [r4, #16] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036ec4: e1a01009 mov r1, r9 <== NOT EXECUTED
30036ec8: e1a00008 mov r0, r8 <== NOT EXECUTED
30036ecc: eb007817 bl 30054f30 <__moddi3> <== NOT EXECUTED
30036ed0: e285906c add r9, r5, #108 ; 0x6c <== NOT EXECUTED
30036ed4: e8990300 ldm r9, {r8, r9} <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30036ed8: e59f20e8 ldr r2, [pc, #232] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036edc: e3a03000 mov r3, #0 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036ee0: 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);
30036ee4: e1a01009 mov r1, r9 <== NOT EXECUTED 30036ee8: e1a00008 mov r0, r8 <== NOT EXECUTED 30036eec: eb0076d4 bl 30054a44 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036ef0: e59f20d0 ldr r2, [pc, #208] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036ef4: 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);
30036ef8: e5840018 str r0, [r4, #24] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036efc: e1a01009 mov r1, r9 <== NOT EXECUTED
30036f00: e1a00008 mov r0, r8 <== NOT EXECUTED
30036f04: eb007809 bl 30054f30 <__moddi3> <== NOT EXECUTED
30036f08: e2859074 add r9, r5, #116 ; 0x74 <== NOT EXECUTED
30036f0c: e8990300 ldm r9, {r8, r9} <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30036f10: e59f20b0 ldr r2, [pc, #176] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036f14: e3a03000 mov r3, #0 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036f18: 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);
30036f1c: e1a01009 mov r1, r9 <== NOT EXECUTED 30036f20: e1a00008 mov r0, r8 <== NOT EXECUTED 30036f24: eb0076c6 bl 30054a44 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036f28: e59f2098 ldr r2, [pc, #152] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036f2c: 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);
30036f30: e5840020 str r0, [r4, #32] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036f34: e1a01009 mov r1, r9 <== NOT EXECUTED
30036f38: e1a00008 mov r0, r8 <== NOT EXECUTED
30036f3c: eb0077fb bl 30054f30 <__moddi3> <== NOT EXECUTED
30036f40: e285907c add r9, r5, #124 ; 0x7c <== NOT EXECUTED
30036f44: e8990300 ldm r9, {r8, r9} <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30036f48: e59f2078 ldr r2, [pc, #120] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036f4c: e3a03000 mov r3, #0 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036f50: 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);
30036f54: e1a01009 mov r1, r9 <== NOT EXECUTED 30036f58: e1a00008 mov r0, r8 <== NOT EXECUTED 30036f5c: eb0076b8 bl 30054a44 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036f60: e59f2060 ldr r2, [pc, #96] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036f64: 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);
30036f68: e5840028 str r0, [r4, #40] ; 0x28 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036f6c: e1a01009 mov r1, r9 <== NOT EXECUTED
30036f70: e1a00008 mov r0, r8 <== NOT EXECUTED
30036f74: eb0077ed bl 30054f30 <__moddi3> <== NOT EXECUTED
30036f78: e2859084 add r9, r5, #132 ; 0x84 <== NOT EXECUTED
30036f7c: e8990300 ldm r9, {r8, r9} <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30036f80: e59f2040 ldr r2, [pc, #64] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036f84: e3a03000 mov r3, #0 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036f88: 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);
30036f8c: e1a01009 mov r1, r9 <== NOT EXECUTED 30036f90: e1a00008 mov r0, r8 <== NOT EXECUTED 30036f94: eb0076aa bl 30054a44 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036f98: e59f2028 ldr r2, [pc, #40] ; 30036fc8 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30036f9c: 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);
30036fa0: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30036fa4: e1a01009 mov r1, r9 <== NOT EXECUTED 30036fa8: e1a00008 mov r0, r8 <== NOT EXECUTED 30036fac: eb0077df bl 30054f30 <__moddi3> <== NOT EXECUTED 30036fb0: 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();
30036fb4: ebff5a4d bl 3000d8f0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30036fb8: e1a00006 mov r0, r6 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30036fbc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30036fc0: e8bd8370 pop {r4, r5, r6, r8, r9, pc} <== NOT EXECUTED
30036fcc <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
30036fcc: 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 )
30036fd0: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
30036fd4: e24dd014 sub sp, sp, #20 <== NOT EXECUTED 30036fd8: e1a01000 mov r1, r0 <== NOT EXECUTED
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
return RTEMS_INVALID_ADDRESS;
30036fdc: 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 )
30036fe0: 0a000013 beq 30037034 <rtems_rate_monotonic_get_status+0x68><== NOT EXECUTED 30036fe4: e28d2010 add r2, sp, #16 <== NOT EXECUTED 30036fe8: e59f00dc ldr r0, [pc, #220] ; 300370cc <rtems_rate_monotonic_get_status+0x100><== NOT EXECUTED 30036fec: ebff5697 bl 3000ca50 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30036ff0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30036ff4: e1a02000 mov r2, r0 <== NOT EXECUTED 30036ff8: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30036ffc: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !status )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30037000: 1a00000b bne 30037034 <rtems_rate_monotonic_get_status+0x68><== NOT EXECUTED
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
30037004: e5921040 ldr r1, [r2, #64] ; 0x40 <== NOT EXECUTED
status->state = the_period->state;
30037008: e5923038 ldr r3, [r2, #56] ; 0x38 <== NOT EXECUTED
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
3003700c: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED
status->state = the_period->state;
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
30037010: 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;
status->state = the_period->state;
30037014: e884000c stm r4, {r2, r3} <== NOT EXECUTED
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
30037018: 1a000007 bne 3003703c <rtems_rate_monotonic_get_status+0x70><== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
3003701c: e5843008 str r3, [r4, #8] <== NOT EXECUTED 30037020: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Timespec_Set_to_zero( &status->executed_since_last_period );
30037024: e5843010 str r3, [r4, #16] <== NOT EXECUTED 30037028: e5843014 str r3, [r4, #20] <== NOT EXECUTED
status->since_last_period = since_last_period;
status->executed_since_last_period = executed;
#endif
}
_Thread_Enable_dispatch();
3003702c: ebff5a2f bl 3000d8f0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30037030: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30037034: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30037038: e8bd80d0 pop {r4, r6, r7, pc} <== NOT EXECUTED
} else {
/*
* Grab the current status.
*/
valid_status =
3003703c: e28d1008 add r1, sp, #8 <== NOT EXECUTED 30037040: e1a0200d mov r2, sp <== NOT EXECUTED 30037044: eb000022 bl 300370d4 <_Rate_monotonic_Get_status> <== NOT EXECUTED
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
30037048: e3500000 cmp r0, #0 <== NOT EXECUTED 3003704c: 0a00001b beq 300370c0 <rtems_rate_monotonic_get_status+0xf4><== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
30037050: e28d7008 add r7, sp, #8 <== NOT EXECUTED
30037054: 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);
30037058: e59f2070 ldr r2, [pc, #112] ; 300370d0 <rtems_rate_monotonic_get_status+0x104><== NOT EXECUTED 3003705c: e3a03000 mov r3, #0 <== NOT EXECUTED 30037060: e1a00006 mov r0, r6 <== NOT EXECUTED 30037064: e1a01007 mov r1, r7 <== NOT EXECUTED 30037068: eb007675 bl 30054a44 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3003706c: e59f205c ldr r2, [pc, #92] ; 300370d0 <rtems_rate_monotonic_get_status+0x104><== NOT EXECUTED 30037070: 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);
30037074: e5840008 str r0, [r4, #8] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30037078: e1a01007 mov r1, r7 <== NOT EXECUTED 3003707c: e1a00006 mov r0, r6 <== NOT EXECUTED 30037080: eb0077aa bl 30054f30 <__moddi3> <== NOT EXECUTED
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
30037084: 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);
30037088: e59f2040 ldr r2, [pc, #64] ; 300370d0 <rtems_rate_monotonic_get_status+0x104><== NOT EXECUTED 3003708c: e3a03000 mov r3, #0 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30037090: 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);
30037094: e1a01007 mov r1, r7 <== NOT EXECUTED 30037098: e1a00006 mov r0, r6 <== NOT EXECUTED 3003709c: eb007668 bl 30054a44 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
300370a0: e59f2028 ldr r2, [pc, #40] ; 300370d0 <rtems_rate_monotonic_get_status+0x104><== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
300370a4: e5840010 str r0, [r4, #16] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
300370a8: e3a03000 mov r3, #0 <== NOT EXECUTED 300370ac: e1a00006 mov r0, r6 <== NOT EXECUTED 300370b0: e1a01007 mov r1, r7 <== NOT EXECUTED 300370b4: eb00779d bl 30054f30 <__moddi3> <== NOT EXECUTED 300370b8: e5840014 str r0, [r4, #20] <== NOT EXECUTED 300370bc: eaffffda b 3003702c <rtems_rate_monotonic_get_status+0x60> <== NOT EXECUTED
valid_status =
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
_Thread_Enable_dispatch();
300370c0: ebff5a0a bl 3000d8f0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
300370c4: e3a0000b mov r0, #11 <== NOT EXECUTED 300370c8: eaffffd9 b 30037034 <rtems_rate_monotonic_get_status+0x68> <== NOT EXECUTED
300372f8 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
300372f8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
300372fc: e1a04000 mov r4, r0
30037300: e24dd008 sub sp, sp, #8
30037304: e1a05001 mov r5, r1
30037308: e59f0190 ldr r0, [pc, #400] ; 300374a0 <rtems_rate_monotonic_period+0x1a8>
3003730c: e1a01004 mov r1, r4
30037310: e28d2004 add r2, sp, #4
30037314: ebff55cd bl 3000ca50 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30037318: e59d3004 ldr r3, [sp, #4] 3003731c: e1a06000 mov r6, r0 30037320: e3530000 cmp r3, #0
30037324: 1a000007 bne 30037348 <rtems_rate_monotonic_period+0x50>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
30037328: e59f7174 ldr r7, [pc, #372] ; 300374a4 <rtems_rate_monotonic_period+0x1ac>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
3003732c: e5902040 ldr r2, [r0, #64] ; 0x40 30037330: e5973008 ldr r3, [r7, #8] 30037334: e1520003 cmp r2, r3
30037338: 0a000005 beq 30037354 <rtems_rate_monotonic_period+0x5c>
_Thread_Enable_dispatch();
3003733c: ebff596b bl 3000d8f0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
30037340: e3a00017 mov r0, #23 <== NOT EXECUTED 30037344: ea000000 b 3003734c <rtems_rate_monotonic_period+0x54> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30037348: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3003734c: e28dd008 add sp, sp, #8
30037350: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
30037354: e3550000 cmp r5, #0
30037358: 0a00001c beq 300373d0 <rtems_rate_monotonic_period+0xd8>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3003735c: e10f8000 mrs r8, CPSR 30037360: e3883080 orr r3, r8, #128 ; 0x80 30037364: e129f003 msr CPSR_fc, r3
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
30037368: e5903038 ldr r3, [r0, #56] ; 0x38 3003736c: e3530000 cmp r3, #0
30037370: 0a00001c beq 300373e8 <rtems_rate_monotonic_period+0xf0>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
30037374: e3530002 cmp r3, #2
30037378: 0a00002d beq 30037434 <rtems_rate_monotonic_period+0x13c>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
3003737c: e3530004 cmp r3, #4 <== NOT EXECUTED 30037380: 1afffff0 bne 30037348 <rtems_rate_monotonic_period+0x50> <== NOT EXECUTED
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
30037384: ebffff7d bl 30037180 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30037388: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
3003738c: e3a03002 mov r3, #2 <== NOT EXECUTED 30037390: e59f0110 ldr r0, [pc, #272] ; 300374a8 <rtems_rate_monotonic_period+0x1b0><== NOT EXECUTED 30037394: e2861010 add r1, r6, #16 <== NOT EXECUTED 30037398: e5863038 str r3, [r6, #56] ; 0x38 <== NOT EXECUTED
the_period->next_length = length;
3003739c: e586503c str r5, [r6, #60] ; 0x3c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
300373a0: e586501c str r5, [r6, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
300373a4: ebff5c62 bl 3000e534 <_Watchdog_Insert> <== NOT EXECUTED 300373a8: e5960040 ldr r0, [r6, #64] ; 0x40 <== NOT EXECUTED 300373ac: e596103c ldr r1, [r6, #60] ; 0x3c <== NOT EXECUTED 300373b0: e59f30f4 ldr r3, [pc, #244] ; 300374ac <rtems_rate_monotonic_period+0x1b4><== NOT EXECUTED 300373b4: e1a0e00f mov lr, pc <== NOT EXECUTED 300373b8: 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;
300373bc: e3a00006 mov r0, #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();
300373c0: e58d0000 str r0, [sp] 300373c4: ebff5949 bl 3000d8f0 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
300373c8: e59d0000 ldr r0, [sp] 300373cc: eaffffde b 3003734c <rtems_rate_monotonic_period+0x54>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
300373d0: e5903038 ldr r3, [r0, #56] ; 0x38 300373d4: e3530004 cmp r3, #4 300373d8: 959f20d0 ldrls r2, [pc, #208] ; 300374b0 <rtems_rate_monotonic_period+0x1b8> 300373dc: 81a00005 movhi r0, r5 300373e0: 97920103 ldrls r0, [r2, r3, lsl #2] 300373e4: eafffff5 b 300373c0 <rtems_rate_monotonic_period+0xc8> 300373e8: e129f008 msr CPSR_fc, r8
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
the_period->next_length = length;
300373ec: e586503c str r5, [r6, #60] ; 0x3c
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
300373f0: ebffff9b bl 30037264 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
300373f4: e3a03002 mov r3, #2 300373f8: e5863038 str r3, [r6, #56] ; 0x38
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
300373fc: e59f30b0 ldr r3, [pc, #176] ; 300374b4 <rtems_rate_monotonic_period+0x1bc>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30037400: e3a07000 mov r7, #0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30037404: e59f009c ldr r0, [pc, #156] ; 300374a8 <rtems_rate_monotonic_period+0x1b0> 30037408: e2861010 add r1, r6, #16
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3003740c: e586302c str r3, [r6, #44] ; 0x2c
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30037410: e5867018 str r7, [r6, #24]
the_watchdog->routine = routine; the_watchdog->id = id;
30037414: e5864030 str r4, [r6, #48] ; 0x30
the_watchdog->user_data = user_data;
30037418: e5867034 str r7, [r6, #52] ; 0x34
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3003741c: e586501c str r5, [r6, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30037420: ebff5c43 bl 3000e534 <_Watchdog_Insert>
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
30037424: e58d7000 str r7, [sp] 30037428: ebff5930 bl 3000d8f0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3003742c: e59d0000 ldr r0, [sp] 30037430: eaffffc5 b 3003734c <rtems_rate_monotonic_period+0x54>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
30037434: ebffff51 bl 30037180 <_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;
30037438: e3a03001 mov r3, #1 3003743c: e5863038 str r3, [r6, #56] ; 0x38
the_period->next_length = length;
30037440: e586503c str r5, [r6, #60] ; 0x3c 30037444: e129f008 msr CPSR_fc, r8
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
30037448: e5973008 ldr r3, [r7, #8] 3003744c: e5962008 ldr r2, [r6, #8]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
30037450: e1a00003 mov r0, r3
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
30037454: e5832020 str r2, [r3, #32]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
30037458: e3a01901 mov r1, #16384 ; 0x4000 3003745c: ebff5b4f bl 3000e1a0 <_Thread_Set_state>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30037460: e10f2000 mrs r2, CPSR 30037464: e3823080 orr r3, r2, #128 ; 0x80 30037468: 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;
3003746c: e3a01002 mov r1, #2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
30037470: e5963038 ldr r3, [r6, #56] ; 0x38
the_period->state = RATE_MONOTONIC_ACTIVE;
30037474: 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 (
30037478: 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 )
3003747c: e3530003 cmp r3, #3
30037480: 0a000002 beq 30037490 <rtems_rate_monotonic_period+0x198>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
30037484: ebff5919 bl 3000d8f0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30037488: e3a00000 mov r0, #0 <== NOT EXECUTED 3003748c: eaffffae b 3003734c <rtems_rate_monotonic_period+0x54> <== NOT EXECUTED
/*
* 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 )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
30037490: e5970008 ldr r0, [r7, #8] <== NOT EXECUTED 30037494: e3a01901 mov r1, #16384 ; 0x4000 <== NOT EXECUTED 30037498: ebff581f bl 3000d51c <_Thread_Clear_state> <== NOT EXECUTED 3003749c: eafffff8 b 30037484 <rtems_rate_monotonic_period+0x18c> <== NOT EXECUTED
3002a480 <rtems_rate_monotonic_report_statistics>:
}
}
void rtems_rate_monotonic_report_statistics( void )
{
rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
3002a480: e59f1004 ldr r1, [pc, #4] ; 3002a48c <rtems_rate_monotonic_report_statistics+0xc><== NOT EXECUTED 3002a484: e3a00000 mov r0, #0 <== NOT EXECUTED 3002a488: eaffff75 b 3002a264 <rtems_rate_monotonic_report_statistics_with_plugin><== NOT EXECUTED
3002a264 <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3002a264: 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 )
3002a268: e2515000 subs r5, r1, #0 <== NOT EXECUTED
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3002a26c: e24dd070 sub sp, sp, #112 ; 0x70 <== NOT EXECUTED 3002a270: e1a07000 mov r7, 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 )
3002a274: 0a000040 beq 3002a37c <rtems_rate_monotonic_report_statistics_with_plugin+0x118><== NOT EXECUTED
return;
(*print)( context, "Period information by period\n" );
3002a278: e59f11d4 ldr r1, [pc, #468] ; 3002a454 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f0><== NOT EXECUTED 3002a27c: e1a0e00f mov lr, pc <== NOT EXECUTED 3002a280: e12fff15 bx r5 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
3002a284: e59f11cc ldr r1, [pc, #460] ; 3002a458 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f4><== NOT EXECUTED 3002a288: e1a00007 mov r0, r7 <== NOT EXECUTED 3002a28c: e1a0e00f mov lr, pc <== NOT EXECUTED 3002a290: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context, "--- Wall times are in seconds ---\n" );
3002a294: e59f11c0 ldr r1, [pc, #448] ; 3002a45c <rtems_rate_monotonic_report_statistics_with_plugin+0x1f8><== NOT EXECUTED 3002a298: e1a00007 mov r0, r7 <== NOT EXECUTED 3002a29c: e1a0e00f mov lr, pc <== NOT EXECUTED 3002a2a0: e12fff15 bx r5 <== 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 ;
3002a2a4: e59f61b4 ldr r6, [pc, #436] ; 3002a460 <rtems_rate_monotonic_report_statistics_with_plugin+0x1fc><== NOT EXECUTED
Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED "
3002a2a8: e59f11b4 ldr r1, [pc, #436] ; 3002a464 <rtems_rate_monotonic_report_statistics_with_plugin+0x200><== NOT EXECUTED 3002a2ac: e1a00007 mov r0, r7 <== NOT EXECUTED 3002a2b0: e1a0e00f mov lr, pc <== NOT EXECUTED 3002a2b4: e12fff15 bx r5 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
3002a2b8: e1a00007 mov r0, r7 <== NOT EXECUTED 3002a2bc: e59f11a4 ldr r1, [pc, #420] ; 3002a468 <rtems_rate_monotonic_report_statistics_with_plugin+0x204><== NOT EXECUTED 3002a2c0: e1a0e00f mov lr, pc <== NOT EXECUTED 3002a2c4: e12fff15 bx r5 <== 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 ;
3002a2c8: e5964008 ldr r4, [r6, #8] <== NOT EXECUTED 3002a2cc: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 3002a2d0: e1540003 cmp r4, r3 <== NOT EXECUTED 3002a2d4: 8a000028 bhi 3002a37c <rtems_rate_monotonic_report_statistics_with_plugin+0x118><== NOT EXECUTED
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 );
(*print)( context,
3002a2d8: e59f818c ldr r8, [pc, #396] ; 3002a46c <rtems_rate_monotonic_report_statistics_with_plugin+0x208><== NOT EXECUTED 3002a2dc: ea000003 b 3002a2f0 <rtems_rate_monotonic_report_statistics_with_plugin+0x8c><== 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 ;
3002a2e0: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3002a2e4: e2844001 add r4, r4, #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 ;
3002a2e8: e1530004 cmp r3, r4 <== NOT EXECUTED 3002a2ec: 3a000022 bcc 3002a37c <rtems_rate_monotonic_report_statistics_with_plugin+0x118><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
3002a2f0: e1a00004 mov r0, r4 <== NOT EXECUTED 3002a2f4: e28d1010 add r1, sp, #16 <== NOT EXECUTED 3002a2f8: eb0032c8 bl 30036e20 <rtems_rate_monotonic_get_statistics> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL )
3002a2fc: e3500000 cmp r0, #0 <== NOT EXECUTED 3002a300: 1afffff6 bne 3002a2e0 <rtems_rate_monotonic_report_statistics_with_plugin+0x7c><== 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 );
3002a304: e28d1048 add r1, sp, #72 ; 0x48 <== NOT EXECUTED 3002a308: e1a00004 mov r0, r4 <== NOT EXECUTED 3002a30c: eb00332e bl 30036fcc <rtems_rate_monotonic_get_status> <== NOT EXECUTED
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
3002a310: e28d2068 add r2, sp, #104 ; 0x68 <== NOT EXECUTED 3002a314: e3a01005 mov r1, #5 <== NOT EXECUTED 3002a318: e59d0048 ldr r0, [sp, #72] ; 0x48 <== NOT EXECUTED 3002a31c: ebffa309 bl 30012f48 <rtems_object_get_name> <== NOT EXECUTED
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
3002a320: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED 3002a324: e1a02004 mov r2, r4 <== NOT EXECUTED 3002a328: e58d0000 str r0, [sp] <== NOT EXECUTED 3002a32c: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED 3002a330: e28d3068 add r3, sp, #104 ; 0x68 <== NOT EXECUTED 3002a334: e59f1134 ldr r1, [pc, #308] ; 3002a470 <rtems_rate_monotonic_report_statistics_with_plugin+0x20c><== NOT EXECUTED 3002a338: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3002a33c: e1a00007 mov r0, r7 <== NOT EXECUTED 3002a340: e1a0e00f mov lr, pc <== NOT EXECUTED 3002a344: e12fff15 bx r5 <== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3002a348: e59d3010 ldr r3, [sp, #16] <== 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 );
3002a34c: e28d0028 add r0, sp, #40 ; 0x28 <== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3002a350: e3530000 cmp r3, #0 <== 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 );
3002a354: e28d2060 add r2, sp, #96 ; 0x60 <== NOT EXECUTED
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
3002a358: e59f1114 ldr r1, [pc, #276] ; 3002a474 <rtems_rate_monotonic_report_statistics_with_plugin+0x210><== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3002a35c: 1a000008 bne 3002a384 <rtems_rate_monotonic_report_statistics_with_plugin+0x120><== NOT EXECUTED
(*print)( context, "\n" );
3002a360: e1a00007 mov r0, r7 <== NOT EXECUTED 3002a364: e1a0e00f mov lr, pc <== NOT EXECUTED 3002a368: e12fff15 bx r5 <== 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 ;
3002a36c: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3002a370: e2844001 add r4, r4, #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 ;
3002a374: e1530004 cmp r3, r4 <== NOT EXECUTED 3002a378: 2affffdc bcs 3002a2f0 <rtems_rate_monotonic_report_statistics_with_plugin+0x8c><== NOT EXECUTED
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
3002a37c: e28dd070 add sp, sp, #112 ; 0x70 <== NOT EXECUTED
3002a380: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== 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 );
3002a384: e1a01003 mov r1, r3 <== NOT EXECUTED 3002a388: eb00029a bl 3002adf8 <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
3002a38c: e59de024 ldr lr, [sp, #36] ; 0x24 <== NOT EXECUTED 3002a390: e59d1064 ldr r1, [sp, #100] ; 0x64 <== NOT EXECUTED 3002a394: e0cc0e98 smull r0, ip, r8, lr <== NOT EXECUTED 3002a398: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 3002a39c: e0c03198 smull r3, r0, r8, r1 <== NOT EXECUTED 3002a3a0: e1a0efce asr lr, lr, #31 <== NOT EXECUTED 3002a3a4: e0c3a298 smull sl, r3, r8, r2 <== NOT EXECUTED 3002a3a8: e06ec34c rsb ip, lr, ip, asr #6 <== NOT EXECUTED 3002a3ac: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3002a3b0: e59de020 ldr lr, [sp, #32] <== NOT EXECUTED 3002a3b4: e59dc060 ldr ip, [sp, #96] ; 0x60 <== NOT EXECUTED 3002a3b8: e1a01fc1 asr r1, r1, #31 <== NOT EXECUTED 3002a3bc: e0610340 rsb r0, r1, r0, asr #6 <== NOT EXECUTED 3002a3c0: e1a02fc2 asr r2, r2, #31 <== NOT EXECUTED 3002a3c4: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 3002a3c8: e0623343 rsb r3, r2, r3, asr #6 <== NOT EXECUTED 3002a3cc: e58de000 str lr, [sp] <== NOT EXECUTED 3002a3d0: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 3002a3d4: e58d000c str r0, [sp, #12] <== NOT EXECUTED 3002a3d8: e59f1098 ldr r1, [pc, #152] ; 3002a478 <rtems_rate_monotonic_report_statistics_with_plugin+0x214><== NOT EXECUTED 3002a3dc: e1a00007 mov r0, r7 <== NOT EXECUTED 3002a3e0: e1a0e00f mov lr, pc <== NOT EXECUTED 3002a3e4: e12fff15 bx r5 <== 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);
3002a3e8: e28d0040 add r0, sp, #64 ; 0x40 <== NOT EXECUTED 3002a3ec: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 3002a3f0: e28d2060 add r2, sp, #96 ; 0x60 <== NOT EXECUTED 3002a3f4: eb00027f bl 3002adf8 <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
3002a3f8: e59d2064 ldr r2, [sp, #100] ; 0x64 <== NOT EXECUTED
3002a3fc: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED
3002a400: e0c0a298 smull sl, r0, r8, r2 <== NOT EXECUTED
3002a404: e0cec198 smull ip, lr, r8, r1 <== NOT EXECUTED
3002a408: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
3002a40c: e1a02fc2 asr r2, r2, #31 <== NOT EXECUTED
3002a410: e0cca398 smull sl, ip, r8, r3 <== NOT EXECUTED
3002a414: e0622340 rsb r2, r2, r0, asr #6 <== NOT EXECUTED
3002a418: e1a01fc1 asr r1, r1, #31 <== NOT EXECUTED
3002a41c: e59d0038 ldr r0, [sp, #56] ; 0x38 <== NOT EXECUTED
3002a420: e061134e rsb r1, r1, lr, asr #6 <== NOT EXECUTED
3002a424: e88d0003 stm sp, {r0, r1} <== NOT EXECUTED
3002a428: e59d1060 ldr r1, [sp, #96] ; 0x60 <== NOT EXECUTED
3002a42c: e1a03fc3 asr r3, r3, #31 <== NOT EXECUTED
3002a430: e58d1008 str r1, [sp, #8] <== NOT EXECUTED
3002a434: e58d200c str r2, [sp, #12] <== NOT EXECUTED
3002a438: e1a00007 mov r0, r7 <== NOT EXECUTED
3002a43c: e59f1038 ldr r1, [pc, #56] ; 3002a47c <rtems_rate_monotonic_report_statistics_with_plugin+0x218><== NOT EXECUTED
3002a440: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED
3002a444: e063334c rsb r3, r3, ip, asr #6 <== NOT EXECUTED
3002a448: e1a0e00f mov lr, pc <== NOT EXECUTED
3002a44c: e12fff15 bx r5 <== NOT EXECUTED
3002a450: eaffffa2 b 3002a2e0 <rtems_rate_monotonic_report_statistics_with_plugin+0x7c><== NOT EXECUTED
3002a490 <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;
3002a490: e59f3040 ldr r3, [pc, #64] ; 3002a4d8 <rtems_rate_monotonic_reset_all_statistics+0x48><== NOT EXECUTED
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
3002a494: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3002a498: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3002a49c: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3002a4a0: 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 ;
3002a4a4: e59f5030 ldr r5, [pc, #48] ; 3002a4dc <rtems_rate_monotonic_reset_all_statistics+0x4c><== NOT EXECUTED 3002a4a8: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED 3002a4ac: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3002a4b0: e1540003 cmp r4, r3 <== NOT EXECUTED 3002a4b4: 8a000005 bhi 3002a4d0 <rtems_rate_monotonic_reset_all_statistics+0x40><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
3002a4b8: e1a00004 mov r0, r4 <== NOT EXECUTED 3002a4bc: eb000007 bl 3002a4e0 <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 ;
3002a4c0: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3002a4c4: 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 ;
3002a4c8: e1530004 cmp r3, r4 <== NOT EXECUTED 3002a4cc: 2afffff9 bcs 3002a4b8 <rtems_rate_monotonic_reset_all_statistics+0x28><== NOT EXECUTED
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
3002a4d0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
3002a4d4: eaff8d05 b 3000d8f0 <_Thread_Enable_dispatch> <== NOT EXECUTED
3002a4e0 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
3002a4e0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3002a4e4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3002a4e8: 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 *)
3002a4ec: e1a0200d mov r2, sp <== NOT EXECUTED 3002a4f0: e59f004c ldr r0, [pc, #76] ; 3002a544 <rtems_rate_monotonic_reset_statistics+0x64><== NOT EXECUTED 3002a4f4: ebff8955 bl 3000ca50 <_Objects_Get> <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3002a4f8: e59d4000 ldr r4, [sp] <== NOT EXECUTED 3002a4fc: e1a05000 mov r5, r0 <== NOT EXECUTED 3002a500: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3002a504: 13a00004 movne r0, #4 <== NOT EXECUTED
{
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3002a508: 1a00000b bne 3002a53c <rtems_rate_monotonic_reset_statistics+0x5c><== NOT EXECUTED
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
3002a50c: e1a01004 mov r1, r4 <== NOT EXECUTED 3002a510: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 3002a514: e2850054 add r0, r5, #84 ; 0x54 <== NOT EXECUTED 3002a518: eb004efd bl 3003e114 <memset> <== NOT EXECUTED 3002a51c: e59f2024 ldr r2, [pc, #36] ; 3002a548 <rtems_rate_monotonic_reset_statistics+0x68><== NOT EXECUTED 3002a520: e59f3024 ldr r3, [pc, #36] ; 3002a54c <rtems_rate_monotonic_reset_statistics+0x6c><== NOT EXECUTED 3002a524: e585205c str r2, [r5, #92] ; 0x5c <== NOT EXECUTED 3002a528: e5853060 str r3, [r5, #96] ; 0x60 <== NOT EXECUTED 3002a52c: e5852074 str r2, [r5, #116] ; 0x74 <== NOT EXECUTED 3002a530: e5853078 str r3, [r5, #120] ; 0x78 <== NOT EXECUTED
_Thread_Enable_dispatch();
3002a534: ebff8ced bl 3000d8f0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3002a538: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3002a53c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3002a540: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000ba74 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
3000ba74: e92d45f0 push {r4, r5, r6, r7, r8, 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;
3000ba78: e5906030 ldr r6, [r0, #48] ; 0x30 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
3000ba7c: e1a05001 mov r5, r1 <== NOT EXECUTED 3000ba80: 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;
3000ba84: e1a00001 mov r0, r1 <== NOT EXECUTED 3000ba88: e1a01006 mov r1, r6 <== NOT EXECUTED 3000ba8c: eb00448f bl 3001ccd0 <__umodsi3> <== NOT EXECUTED
if (excess > 0) {
3000ba90: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ba94: 01a06005 moveq r6, r5 <== NOT EXECUTED 3000ba98: 03a03001 moveq r3, #1 <== NOT EXECUTED 3000ba9c: 0a000004 beq 3000bab4 <rtems_rbheap_allocate+0x40> <== NOT EXECUTED
value += alignment - excess;
3000baa0: e0856006 add r6, r5, r6 <== NOT EXECUTED 3000baa4: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000baa8: e1550006 cmp r5, r6 <== NOT EXECUTED 3000baac: 83a03000 movhi r3, #0 <== NOT EXECUTED 3000bab0: 93a03001 movls r3, #1 <== 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) {
3000bab4: e3550000 cmp r5, #0 <== NOT EXECUTED 3000bab8: 03a05000 moveq r5, #0 <== NOT EXECUTED 3000babc: 12035001 andne r5, r3, #1 <== NOT EXECUTED 3000bac0: e3550000 cmp r5, #0 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
3000bac4: 01a00005 moveq r0, 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) {
3000bac8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000bacc: e1a02004 mov r2, r4 <== NOT EXECUTED 3000bad0: e4927004 ldr r7, [r2], #4 <== 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) {
3000bad4: e1570002 cmp r7, r2 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
3000bad8: 03a00000 moveq r0, #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) {
3000badc: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
3000bae0: e597801c ldr r8, [r7, #28] <== NOT EXECUTED 3000bae4: e1560008 cmp r6, r8 <== NOT EXECUTED 3000bae8: 8a00001a bhi 3000bb58 <rtems_rbheap_allocate+0xe4> <== 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) {
3000baec: e3570000 cmp r7, #0 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
3000baf0: 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) {
3000baf4: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
3000baf8: e1580006 cmp r8, r6 <== NOT EXECUTED 3000bafc: 9a00001c bls 3000bb74 <rtems_rbheap_allocate+0x100> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000bb00: e1a0a004 mov sl, r4 <== NOT EXECUTED 3000bb04: 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 );
3000bb08: 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))
3000bb0c: e1550003 cmp r5, r3 <== NOT EXECUTED 3000bb10: 0a00001f beq 3000bb94 <rtems_rbheap_allocate+0x120> <== 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;
3000bb14: e5953000 ldr r3, [r5] <== NOT EXECUTED
head->next = new_first;
3000bb18: e584300c str r3, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
3000bb1c: e583a004 str sl, [r3, #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;
3000bb20: e5972018 ldr r2, [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;
3000bb24: e0668008 rsb r8, r6, r8 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
3000bb28: e3a03000 mov r3, #0 <== NOT EXECUTED
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
3000bb2c: e0882002 add r2, r8, r2 <== NOT EXECUTED 3000bb30: e1a01005 mov r1, r5 <== NOT EXECUTED
rtems_rbheap_chunk *new_chunk = get_chunk(control);
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
3000bb34: e587801c str r8, [r7, #28] <== NOT EXECUTED
new_chunk->begin = free_chunk->begin + new_free_size;
3000bb38: e5852018 str r2, [r5, #24] <== NOT EXECUTED
new_chunk->size = aligned_size;
3000bb3c: e585601c str r6, [r5, #28] <== NOT EXECUTED 3000bb40: e5853004 str r3, [r5, #4] <== NOT EXECUTED 3000bb44: 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);
3000bb48: e2840018 add r0, r4, #24 <== NOT EXECUTED 3000bb4c: eb0006af bl 3000d610 <_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;
3000bb50: e5950018 ldr r0, [r5, #24] <== NOT EXECUTED
3000bb54: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000bb58: e5977000 ldr r7, [r7] <== 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) {
3000bb5c: e0523007 subs r3, r2, r7 <== NOT EXECUTED 3000bb60: 13a03001 movne r3, #1 <== NOT EXECUTED 3000bb64: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bb68: 1affffdc bne 3000bae0 <rtems_rbheap_allocate+0x6c> <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
3000bb6c: e1a00003 mov r0, r3 <== NOT EXECUTED
3000bb70: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
3000bb74: e3a03000 mov r3, #0 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000bb78: e8970006 ldm r7, {r1, r2} <== NOT EXECUTED
ptr = (void *) new_chunk->begin;
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
3000bb7c: e5970018 ldr r0, [r7, #24] <== NOT EXECUTED
next->previous = previous;
3000bb80: e5812004 str r2, [r1, #4] <== NOT EXECUTED
previous->next = next;
3000bb84: e5821000 str r1, [r2] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
3000bb88: e5873004 str r3, [r7, #4] <== NOT EXECUTED
3000bb8c: e5873000 str r3, [r7] <== NOT EXECUTED
3000bb90: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== 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);
3000bb94: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bb98: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bb9c: 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;
3000bba0: 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))
3000bba4: e1550003 cmp r5, r3 <== NOT EXECUTED 3000bba8: 0a000004 beq 3000bbc0 <rtems_rbheap_allocate+0x14c> <== 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;
3000bbac: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
3000bbb0: 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;
3000bbb4: e584200c str r2, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
3000bbb8: e582a004 str sl, [r2, #4] <== NOT EXECUTED 3000bbbc: eaffffd7 b 3000bb20 <rtems_rbheap_allocate+0xac> <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
3000bbc0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
}
return ptr;
}
3000bbc4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000bd48 <rtems_rbheap_extend_descriptors_never>:
}
void rtems_rbheap_extend_descriptors_never(rtems_rbheap_control *control)
{
/* Do nothing */
}
3000bd48: e12fff1e bx lr <== NOT EXECUTED
3000bd4c <rtems_rbheap_extend_descriptors_with_malloc>:
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
3000bd4c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000bd50: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
3000bd54: e3a00020 mov r0, #32 <== NOT EXECUTED 3000bd58: ebffed57 bl 300072bc <malloc> <== NOT EXECUTED
if (chunk != NULL) {
3000bd5c: e3500000 cmp r0, #0 <== NOT EXECUTED
3000bd60: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000bd64: e594300c ldr r3, [r4, #12] <== 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);
3000bd68: e284200c add r2, r4, #12 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000bd6c: e5802004 str r2, [r0, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000bd70: e584000c str r0, [r4, #12] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000bd74: 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;
3000bd78: e5803000 str r3, [r0] <== NOT EXECUTED
3000bd7c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000bbc8 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
3000bbc8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
3000bbcc: e3510000 cmp r1, #0 <== NOT EXECUTED
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
3000bbd0: e1a04000 mov r4, r0 <== NOT EXECUTED 3000bbd4: e24dd020 sub sp, sp, #32 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
3000bbd8: 01a00001 moveq r0, r1 <== NOT EXECUTED
if (ptr != NULL) {
3000bbdc: 0a000022 beq 3000bc6c <rtems_rbheap_free+0xa4> <== 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;
3000bbe0: e594501c ldr r5, [r4, #28] <== 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 };
3000bbe4: e3a06000 mov r6, #0 <== NOT EXECUTED
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
3000bbe8: e1550006 cmp r5, r6 <== NOT EXECUTED 3000bbec: e58d6000 str r6, [sp] <== NOT EXECUTED 3000bbf0: e58d6004 str r6, [sp, #4] <== NOT EXECUTED 3000bbf4: e58d6008 str r6, [sp, #8] <== NOT EXECUTED 3000bbf8: e58d600c str r6, [sp, #12] <== NOT EXECUTED 3000bbfc: e58d6010 str r6, [sp, #16] <== NOT EXECUTED 3000bc00: e58d6014 str r6, [sp, #20] <== NOT EXECUTED 3000bc04: e58d601c str r6, [sp, #28] <== NOT EXECUTED 3000bc08: e58d1018 str r1, [sp, #24] <== NOT EXECUTED 3000bc0c: 0a00001c beq 3000bc84 <rtems_rbheap_free+0xbc> <== NOT EXECUTED
compare_result = the_rbtree->compare_function(the_node, iter_node);
3000bc10: e1a01005 mov r1, r5 <== NOT EXECUTED 3000bc14: e28d0008 add r0, sp, #8 <== NOT EXECUTED 3000bc18: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bc1c: e594f028 ldr pc, [r4, #40] ; 0x28 <== NOT EXECUTED
if ( _RBTree_Is_equal( compare_result ) ) {
3000bc20: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bc24: 1a000003 bne 3000bc38 <rtems_rbheap_free+0x70> <== NOT EXECUTED
found = iter_node;
if ( the_rbtree->is_unique )
3000bc28: e5d4302c ldrb r3, [r4, #44] ; 0x2c <== NOT EXECUTED 3000bc2c: e1a06005 mov r6, r5 <== NOT EXECUTED 3000bc30: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bc34: 1a00000e bne 3000bc74 <rtems_rbheap_free+0xac> <== NOT EXECUTED
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
3000bc38: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bc3c: c3a00008 movgt r0, #8 <== NOT EXECUTED 3000bc40: d3a00004 movle r0, #4 <== NOT EXECUTED 3000bc44: e7905005 ldr r5, [r0, r5] <== NOT EXECUTED
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
3000bc48: e3550000 cmp r5, #0 <== NOT EXECUTED 3000bc4c: 1affffef bne 3000bc10 <rtems_rbheap_free+0x48> <== NOT EXECUTED
return rtems_rbheap_chunk_of_node(
3000bc50: e2465008 sub r5, 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) {
3000bc54: e3750008 cmn r5, #8 <== NOT EXECUTED 3000bc58: 0a000009 beq 3000bc84 <rtems_rbheap_free+0xbc> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
3000bc5c: e5163008 ldr r3, [r6, #-8] <== NOT EXECUTED 3000bc60: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bc64: 0a000008 beq 3000bc8c <rtems_rbheap_free+0xc4> <== 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;
3000bc68: e3a0000e mov r0, #14 <== NOT EXECUTED
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
3000bc6c: e28dd020 add sp, sp, #32 <== NOT EXECUTED
3000bc70: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
found = iter_node;
if ( the_rbtree->is_unique )
3000bc74: e1a06005 mov r6, r5 <== NOT EXECUTED
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
return rtems_rbheap_chunk_of_node(
3000bc78: e2465008 sub r5, 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) {
3000bc7c: e3750008 cmn r5, #8 <== NOT EXECUTED 3000bc80: 1afffff5 bne 3000bc5c <rtems_rbheap_free+0x94> <== NOT EXECUTED
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
}
} else {
sc = RTEMS_INVALID_ID;
3000bc84: e3a00004 mov r0, #4 <== NOT EXECUTED 3000bc88: eafffff7 b 3000bc6c <rtems_rbheap_free+0xa4> <== NOT EXECUTED 3000bc8c: e5951004 ldr r1, [r5, #4] <== NOT EXECUTED 3000bc90: e3510000 cmp r1, #0 <== NOT EXECUTED 3000bc94: 1afffff3 bne 3000bc68 <rtems_rbheap_free+0xa0> <== NOT EXECUTED
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
3000bc98: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bc9c: eb000716 bl 3000d8fc <_RBTree_Next_unprotected> <== NOT EXECUTED 3000bca0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bca4: e1a08000 mov r8, r0 <== NOT EXECUTED 3000bca8: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bcac: eb000712 bl 3000d8fc <_RBTree_Next_unprotected> <== NOT EXECUTED 3000bcb0: 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)) {
3000bcb4: 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;
3000bcb8: e2847018 add r7, r4, #24 <== NOT EXECUTED
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
3000bcbc: e2486008 sub r6, r8, #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)) {
3000bcc0: 0a000006 beq 3000bce0 <rtems_rbheap_free+0x118> <== NOT EXECUTED 3000bcc4: e5102008 ldr r2, [r0, #-8] <== NOT EXECUTED 3000bcc8: e3520000 cmp r2, #0 <== NOT EXECUTED 3000bccc: 0a000019 beq 3000bd38 <rtems_rbheap_free+0x170> <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ID;
}
}
return sc;
3000bcd0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bcd4: e1a01007 mov r1, r7 <== NOT EXECUTED 3000bcd8: e1a02005 mov r2, r5 <== NOT EXECUTED 3000bcdc: ebfffefb bl 3000b8d0 <check_and_merge.part.1> <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000bce0: e5943000 ldr r3, [r4] <== 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)) {
3000bce4: e3760008 cmn r6, #8 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000bce8: e5854004 str r4, [r5, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000bcec: e5845000 str r5, [r4] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000bcf0: e5835004 str r5, [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;
3000bcf4: e5853000 str r3, [r5] <== NOT EXECUTED
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
3000bcf8: 03a00000 moveq r0, #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)) {
3000bcfc: 0affffda beq 3000bc6c <rtems_rbheap_free+0xa4> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
3000bd00: e5183008 ldr r3, [r8, #-8] <== NOT EXECUTED 3000bd04: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bd08: 0a000006 beq 3000bd28 <rtems_rbheap_free+0x160> <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ID;
}
}
return sc;
3000bd0c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bd10: e1a01007 mov r1, r7 <== NOT EXECUTED 3000bd14: e1a02005 mov r2, r5 <== NOT EXECUTED 3000bd18: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bd1c: ebfffeeb bl 3000b8d0 <check_and_merge.part.1> <== NOT EXECUTED
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
3000bd20: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bd24: eaffffd0 b 3000bc6c <rtems_rbheap_free+0xa4> <== NOT EXECUTED 3000bd28: e5960004 ldr r0, [r6, #4] <== NOT EXECUTED 3000bd2c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bd30: 1afffff5 bne 3000bd0c <rtems_rbheap_free+0x144> <== NOT EXECUTED 3000bd34: eaffffcc b 3000bc6c <rtems_rbheap_free+0xa4> <== NOT EXECUTED 3000bd38: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000bd3c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000bd40: 1affffe2 bne 3000bcd0 <rtems_rbheap_free+0x108> <== NOT EXECUTED 3000bd44: eaffffe5 b 3000bce0 <rtems_rbheap_free+0x118> <== NOT EXECUTED
3000b930 <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
3000b930: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
3000b934: e2536000 subs r6, r3, #0 <== NOT EXECUTED
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
3000b938: e1a05000 mov r5, r0 <== NOT EXECUTED 3000b93c: e1a04001 mov r4, r1 <== NOT EXECUTED 3000b940: e59d7024 ldr r7, [sp, #36] ; 0x24 <== NOT EXECUTED
}
} else {
sc = RTEMS_INVALID_ADDRESS;
}
} else {
sc = RTEMS_INVALID_NUMBER;
3000b944: 03a0000a moveq r0, #10 <== NOT EXECUTED
void *handler_arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
3000b948: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
3000b94c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b950: e1a01006 mov r1, r6 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
3000b954: e0848002 add r8, r4, r2 <== NOT EXECUTED
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
3000b958: eb0044dc bl 3001ccd0 <__umodsi3> <== NOT EXECUTED
if (excess > 0) {
3000b95c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b960: 01a0a004 moveq sl, r4 <== NOT EXECUTED 3000b964: 03a03001 moveq r3, #1 <== NOT EXECUTED 3000b968: 1a000006 bne 3000b988 <rtems_rbheap_initialize+0x58> <== 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) {
3000b96c: e1540008 cmp r4, r8 <== NOT EXECUTED 3000b970: 23a04000 movcs r4, #0 <== NOT EXECUTED 3000b974: 32034001 andcc r4, r3, #1 <== NOT EXECUTED 3000b978: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b97c: 1a00000b bne 3000b9b0 <rtems_rbheap_initialize+0x80> <== NOT EXECUTED
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
3000b980: e3a00009 mov r0, #9 <== NOT EXECUTED
3000b984: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
value += alignment - excess;
3000b988: e084a006 add sl, r4, r6 <== NOT EXECUTED 3000b98c: e060a00a rsb sl, r0, sl <== NOT EXECUTED 3000b990: e154000a cmp r4, sl <== NOT EXECUTED 3000b994: 83a03000 movhi r3, #0 <== NOT EXECUTED 3000b998: 93a03001 movls r3, #1 <== 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) {
3000b99c: e1540008 cmp r4, r8 <== NOT EXECUTED 3000b9a0: 23a04000 movcs r4, #0 <== NOT EXECUTED 3000b9a4: 32034001 andcc r4, r3, #1 <== NOT EXECUTED 3000b9a8: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b9ac: 0afffff3 beq 3000b980 <rtems_rbheap_initialize+0x50> <== NOT EXECUTED
return value;
}
static uintptr_t align_down(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
3000b9b0: e1a00008 mov r0, r8 <== NOT EXECUTED 3000b9b4: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b9b8: eb0044c4 bl 3001ccd0 <__umodsi3> <== NOT EXECUTED
return value - excess;
3000b9bc: e0608008 rsb r8, r0, r8 <== 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) {
3000b9c0: e15a0008 cmp sl, r8 <== NOT EXECUTED 3000b9c4: 2affffed bcs 3000b980 <rtems_rbheap_initialize+0x50> <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3000b9c8: e3a04000 mov r4, #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 );
3000b9cc: e2859010 add r9, r5, #16 <== NOT EXECUTED 3000b9d0: e2853004 add r3, r5, #4 <== NOT EXECUTED
head->next = tail;
3000b9d4: e8850238 stm r5, {r3, r4, r5, r9} <== 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;
3000b9d8: e59f3090 ldr r3, [pc, #144] ; 3000ba70 <rtems_rbheap_initialize+0x140><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000b9dc: e285b00c add fp, r5, #12 <== NOT EXECUTED 3000b9e0: e5853028 str r3, [r5, #40] ; 0x28 <== NOT EXECUTED
the_rbtree->is_unique = is_unique;
3000b9e4: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b9e8: e5c5302c strb r3, [r5, #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;
3000b9ec: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3000b9f0: e5854010 str r4, [r5, #16] <== NOT EXECUTED
tail->previous = head;
3000b9f4: e585b014 str fp, [r5, #20] <== NOT EXECUTED
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
3000b9f8: e5854018 str r4, [r5, #24] <== NOT EXECUTED
the_rbtree->root = NULL;
3000b9fc: e585401c str r4, [r5, #28] <== NOT EXECUTED
the_rbtree->first[0] = NULL;
3000ba00: e5854020 str r4, [r5, #32] <== NOT EXECUTED
the_rbtree->first[1] = NULL;
3000ba04: e5854024 str r4, [r5, #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;
3000ba08: e5856030 str r6, [r5, #48] ; 0x30 <== NOT EXECUTED
control->handler_arg = handler_arg;
3000ba0c: e5853038 str r3, [r5, #56] ; 0x38 <== NOT EXECUTED
control->extend_descriptors = extend_descriptors;
3000ba10: e5857034 str r7, [r5, #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);
3000ba14: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ba18: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ba1c: e12fff17 bx r7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000ba20: e595100c ldr r1, [r5, #12] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
3000ba24: e1590001 cmp r9, r1 <== NOT EXECUTED 3000ba28: 0a00000e beq 3000ba68 <rtems_rbheap_initialize+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;
3000ba2c: e5912000 ldr r2, [r1] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000ba30: e5953000 ldr r3, [r5] <== NOT EXECUTED
after_node->next = the_node;
3000ba34: e1a00005 mov r0, r5 <== NOT EXECUTED
control->extend_descriptors = extend_descriptors;
first = get_chunk(control);
if (first != NULL) {
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
3000ba38: e06a8008 rsb r8, sl, r8 <== 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;
3000ba3c: e585200c str r2, [r5, #12] <== NOT EXECUTED
new_first->previous = head;
3000ba40: e582b004 str fp, [r2, #4] <== NOT EXECUTED
control->handler_arg = handler_arg;
control->extend_descriptors = extend_descriptors;
first = get_chunk(control);
if (first != NULL) {
first->begin = aligned_begin;
3000ba44: e581a018 str sl, [r1, #24] <== NOT EXECUTED
first->size = aligned_end - aligned_begin;
3000ba48: e581801c str r8, [r1, #28] <== NOT EXECUTED
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
3000ba4c: e4801018 str r1, [r0], #24 <== NOT EXECUTED
the_node->next = before_node;
3000ba50: e8810028 stm r1, {r3, r5} <== NOT EXECUTED
before_node->previous = the_node;
3000ba54: e5831004 str r1, [r3, #4] <== NOT EXECUTED
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
3000ba58: e2811008 add r1, r1, #8 <== NOT EXECUTED 3000ba5c: eb0006eb bl 3000d610 <_RBTree_Insert_unprotected> <== NOT EXECUTED
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
3000ba60: e1a00004 mov r0, r4 <== NOT EXECUTED
3000ba64: 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;
3000ba68: e3a0001a mov r0, #26 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
3000ba6c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000bef8 <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000bef8: 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 ) )
3000befc: e2508000 subs r8, r0, #0
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000bf00: e24dd004 sub sp, sp, #4 3000bf04: e1a04001 mov r4, r1 3000bf08: e1a06002 mov r6, r2 3000bf0c: e1a05003 mov r5, r3 3000bf10: e59d7028 ldr r7, [sp, #40] ; 0x28
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000bf14: 03a04003 moveq r4, #3
)
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
3000bf18: 1a000002 bne 3000bf28 <rtems_region_create+0x30>
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
3000bf1c: e1a00004 mov r0, r4
3000bf20: e28dd004 add sp, sp, #4
3000bf24: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
3000bf28: e3540000 cmp r4, #0
3000bf2c: 0a00001a beq 3000bf9c <rtems_region_create+0xa4>
return RTEMS_INVALID_ADDRESS;
if ( !id )
3000bf30: e59d202c ldr r2, [sp, #44] ; 0x2c 3000bf34: e3520000 cmp r2, #0
3000bf38: 0a000017 beq 3000bf9c <rtems_region_create+0xa4>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
3000bf3c: e59f90c0 ldr r9, [pc, #192] ; 3000c004 <rtems_region_create+0x10c>
* 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 );
3000bf40: e59fb0c0 ldr fp, [pc, #192] ; 3000c008 <rtems_region_create+0x110> 3000bf44: e5990000 ldr r0, [r9] 3000bf48: eb0003d1 bl 3000ce94 <_API_Mutex_Lock> 3000bf4c: e1a0000b mov r0, fp 3000bf50: eb000699 bl 3000d9bc <_Objects_Allocate>
the_region = _Region_Allocate();
if ( !the_region )
3000bf54: e250a000 subs sl, r0, #0
return_status = RTEMS_TOO_MANY;
3000bf58: 03a04005 moveq r4, #5
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
3000bf5c: 0a00000b beq 3000bf90 <rtems_region_create+0x98>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
3000bf60: e28a0068 add r0, sl, #104 ; 0x68 3000bf64: e1a01004 mov r1, r4 3000bf68: e1a02006 mov r2, r6 3000bf6c: e1a03005 mov r3, r5 3000bf70: eb0005d8 bl 3000d6d8 <_Heap_Initialize>
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
3000bf74: e3500000 cmp r0, #0
if ( !the_region )
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
3000bf78: e58a005c str r0, [sl, #92] ; 0x5c
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
3000bf7c: 1a000008 bne 3000bfa4 <rtems_region_create+0xac>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
3000bf80: e1a0000b mov r0, fp <== NOT EXECUTED 3000bf84: e1a0100a mov r1, sl <== NOT EXECUTED 3000bf88: eb000769 bl 3000dd34 <_Objects_Free> <== NOT EXECUTED
_Region_Free( the_region );
return_status = RTEMS_INVALID_SIZE;
3000bf8c: e3a04008 mov r4, #8 <== NOT EXECUTED
*id = the_region->Object.id;
return_status = RTEMS_SUCCESSFUL;
}
}
_RTEMS_Unlock_allocator();
3000bf90: e5990000 ldr r0, [r9] 3000bf94: eb0003da bl 3000cf04 <_API_Mutex_Unlock>
return return_status;
3000bf98: eaffffdf b 3000bf1c <rtems_region_create+0x24>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000bf9c: e3a04009 mov r4, #9 <== NOT EXECUTED 3000bfa0: eaffffdd b 3000bf1c <rtems_region_create+0x24> <== NOT EXECUTED
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;
3000bfa4: e3a0c000 mov ip, #0
_Thread_queue_Initialize(
3000bfa8: e3170004 tst r7, #4
return_status = RTEMS_INVALID_SIZE;
}
else {
the_region->starting_address = starting_address;
3000bfac: e58a4050 str r4, [sl, #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;
3000bfb0: e58ac064 str ip, [sl, #100] ; 0x64
}
else {
the_region->starting_address = starting_address;
the_region->length = length;
3000bfb4: e58a6054 str r6, [sl, #84] ; 0x54
the_region->page_size = page_size;
3000bfb8: e58a5058 str r5, [sl, #88] ; 0x58
the_region->attribute_set = attribute_set;
3000bfbc: e58a7060 str r7, [sl, #96] ; 0x60
the_region->number_of_used_blocks = 0;
_Thread_queue_Initialize(
3000bfc0: 03a01000 moveq r1, #0 3000bfc4: 13a01001 movne r1, #1 3000bfc8: e3a02040 mov r2, #64 ; 0x40 3000bfcc: e3a03006 mov r3, #6 3000bfd0: e28a0010 add r0, sl, #16 3000bfd4: e58dc000 str ip, [sp] 3000bfd8: eb000d6b bl 3000f58c <_Thread_queue_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000bfdc: e59a3008 ldr r3, [sl, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bfe0: e59b201c ldr r2, [fp, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000bfe4: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bfe8: e782a721 str sl, [r2, r1, lsr #14]
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
return_status = RTEMS_SUCCESSFUL;
3000bfec: e59dc000 ldr ip, [sp]
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
3000bff0: e59d202c ldr r2, [sp, #44] ; 0x2c
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000bff4: e58a800c str r8, [sl, #12]
return_status = RTEMS_SUCCESSFUL;
3000bff8: e1a0400c mov r4, ip
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
3000bffc: e5823000 str r3, [r2] 3000c000: eaffffe2 b 3000bf90 <rtems_region_create+0x98>
30019484 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
30019484: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uintptr_t amount_extended;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
30019488: e2518000 subs r8, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
3001948c: e1a05000 mov r5, r0 <== NOT EXECUTED 30019490: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30019494: e1a07002 mov r7, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
30019498: 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 )
3001949c: 0a00001b beq 30019510 <rtems_region_extend+0x8c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
300194a0: e59f4074 ldr r4, [pc, #116] ; 3001951c <rtems_region_extend+0x98><== NOT EXECUTED 300194a4: e5940000 ldr r0, [r4] <== NOT EXECUTED 300194a8: eb0009a2 bl 3001bb38 <_API_Mutex_Lock> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
300194ac: e1a01005 mov r1, r5 <== NOT EXECUTED 300194b0: e59f0068 ldr r0, [pc, #104] ; 30019520 <rtems_region_extend+0x9c><== NOT EXECUTED 300194b4: e1a0200d mov r2, sp <== NOT EXECUTED 300194b8: eb00114b bl 3001d9ec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
300194bc: e59d5000 ldr r5, [sp] <== NOT EXECUTED 300194c0: e1a06000 mov r6, r0 <== NOT EXECUTED 300194c4: e3550000 cmp r5, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
300194c8: 13a05004 movne r5, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Get( id, &location );
switch ( location ) {
300194cc: 1a00000d bne 30019508 <rtems_region_extend+0x84> <== NOT EXECUTED
case OBJECTS_LOCAL:
amount_extended = _Heap_Extend(
300194d0: e1a03005 mov r3, r5 <== NOT EXECUTED 300194d4: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 300194d8: e1a01008 mov r1, r8 <== NOT EXECUTED 300194dc: e1a02007 mov r2, r7 <== NOT EXECUTED 300194e0: eb000d1c bl 3001c958 <_Heap_Extend> <== NOT EXECUTED
starting_address,
length,
0
);
if ( amount_extended > 0 ) {
300194e4: 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;
300194e8: 03a05009 moveq r5, #9 <== NOT EXECUTED
starting_address,
length,
0
);
if ( amount_extended > 0 ) {
300194ec: 0a000005 beq 30019508 <rtems_region_extend+0x84> <== NOT EXECUTED
the_region->length += amount_extended;
300194f0: e5963054 ldr r3, [r6, #84] ; 0x54 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
300194f4: e596205c ldr r2, [r6, #92] ; 0x5c <== NOT EXECUTED
length,
0
);
if ( amount_extended > 0 ) {
the_region->length += amount_extended;
300194f8: e0833000 add r3, r3, r0 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
300194fc: e0820000 add r0, r2, r0 <== NOT EXECUTED
length,
0
);
if ( amount_extended > 0 ) {
the_region->length += amount_extended;
30019500: e5863054 str r3, [r6, #84] ; 0x54 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
30019504: e586005c str r0, [r6, #92] ; 0x5c <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30019508: e5940000 ldr r0, [r4] <== NOT EXECUTED 3001950c: eb0009a5 bl 3001bba8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30019510: e1a00005 mov r0, r5 <== NOT EXECUTED
30019514: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30019518: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30019524 <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30019524: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30019528: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
3001952c: e1a06000 mov r6, r0 <== NOT EXECUTED 30019530: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
30019534: 03a06009 moveq r6, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30019538: 0a00000c beq 30019570 <rtems_region_get_free_information+0x4c><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
3001953c: e59f5054 ldr r5, [pc, #84] ; 30019598 <rtems_region_get_free_information+0x74><== NOT EXECUTED 30019540: e5950000 ldr r0, [r5] <== NOT EXECUTED 30019544: eb00097b bl 3001bb38 <_API_Mutex_Lock> <== NOT EXECUTED 30019548: e1a01006 mov r1, r6 <== NOT EXECUTED 3001954c: e59f0048 ldr r0, [pc, #72] ; 3001959c <rtems_region_get_free_information+0x78><== NOT EXECUTED 30019550: e1a0200d mov r2, sp <== NOT EXECUTED 30019554: eb001124 bl 3001d9ec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30019558: e59d6000 ldr r6, [sp] <== NOT EXECUTED 3001955c: e3560000 cmp r6, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30019560: 13a06004 movne r6, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30019564: 0a000004 beq 3001957c <rtems_region_get_free_information+0x58><== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30019568: e5950000 ldr r0, [r5] <== NOT EXECUTED 3001956c: eb00098d bl 3001bba8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30019570: e1a00006 mov r0, r6 <== NOT EXECUTED
30019574: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30019578: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->Used.number = 0;
3001957c: e584600c str r6, [r4, #12] <== NOT EXECUTED
the_info->Used.total = 0;
30019580: e5846014 str r6, [r4, #20] <== NOT EXECUTED
the_info->Used.largest = 0;
30019584: e5846010 str r6, [r4, #16] <== NOT EXECUTED
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
30019588: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 3001958c: e1a01004 mov r1, r4 <== NOT EXECUTED 30019590: eb000e09 bl 3001cdbc <_Heap_Get_free_information> <== NOT EXECUTED
return_status = RTEMS_SUCCESSFUL;
break;
30019594: eafffff3 b 30019568 <rtems_region_get_free_information+0x44><== NOT EXECUTED
300195a0 <rtems_region_get_information>:
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
300195a0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
300195a4: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
300195a8: e1a06000 mov r6, r0 <== NOT EXECUTED 300195ac: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
300195b0: 03a06009 moveq r6, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
300195b4: 0a00000c beq 300195ec <rtems_region_get_information+0x4c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
300195b8: e59f4048 ldr r4, [pc, #72] ; 30019608 <rtems_region_get_information+0x68><== NOT EXECUTED 300195bc: e5940000 ldr r0, [r4] <== NOT EXECUTED 300195c0: eb00095c bl 3001bb38 <_API_Mutex_Lock> <== NOT EXECUTED 300195c4: e1a01006 mov r1, r6 <== NOT EXECUTED 300195c8: e59f003c ldr r0, [pc, #60] ; 3001960c <rtems_region_get_information+0x6c><== NOT EXECUTED 300195cc: e1a0200d mov r2, sp <== NOT EXECUTED 300195d0: eb001105 bl 3001d9ec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
300195d4: e59d6000 ldr r6, [sp] <== NOT EXECUTED 300195d8: e3560000 cmp r6, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
300195dc: 13a06004 movne r6, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
300195e0: 0a000004 beq 300195f8 <rtems_region_get_information+0x58> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
300195e4: e5940000 ldr r0, [r4] <== NOT EXECUTED 300195e8: eb00096e bl 3001bba8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
300195ec: e1a00006 mov r0, r6 <== NOT EXECUTED
300195f0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300195f4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Heap_Get_information( &the_region->Memory, the_info );
300195f8: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 300195fc: e1a01005 mov r1, r5 <== NOT EXECUTED 30019600: eb000e14 bl 3001ce58 <_Heap_Get_information> <== NOT EXECUTED
return_status = RTEMS_SUCCESSFUL;
break;
30019604: eafffff6 b 300195e4 <rtems_region_get_information+0x44> <== NOT EXECUTED
30019754 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
30019754: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30019758: e2516000 subs r6, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
3001975c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30019760: e1a07000 mov r7, r0 <== NOT EXECUTED 30019764: e1a04002 mov r4, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30019768: 0a000011 beq 300197b4 <rtems_region_get_segment_size+0x60> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !size )
3001976c: e3520000 cmp r2, #0 <== NOT EXECUTED 30019770: 0a00000f beq 300197b4 <rtems_region_get_segment_size+0x60> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30019774: e59f5068 ldr r5, [pc, #104] ; 300197e4 <rtems_region_get_segment_size+0x90><== NOT EXECUTED 30019778: e5950000 ldr r0, [r5] <== NOT EXECUTED 3001977c: eb0008ed bl 3001bb38 <_API_Mutex_Lock> <== NOT EXECUTED 30019780: e59f0060 ldr r0, [pc, #96] ; 300197e8 <rtems_region_get_segment_size+0x94><== NOT EXECUTED 30019784: e1a01007 mov r1, r7 <== NOT EXECUTED 30019788: e1a0200d mov r2, sp <== NOT EXECUTED 3001978c: eb001096 bl 3001d9ec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30019790: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30019794: e3530000 cmp r3, #0 <== NOT EXECUTED 30019798: 0a000009 beq 300197c4 <rtems_region_get_segment_size+0x70> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
3001979c: e3530001 cmp r3, #1 <== NOT EXECUTED 300197a0: 03a04004 moveq r4, #4 <== NOT EXECUTED 300197a4: 13a04000 movne r4, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
300197a8: e5950000 ldr r0, [r5] <== NOT EXECUTED 300197ac: eb0008fd bl 3001bba8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status;
300197b0: ea000000 b 300197b8 <rtems_region_get_segment_size+0x64> <== NOT EXECUTED
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
300197b4: e3a04009 mov r4, #9 <== NOT EXECUTED
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
300197b8: e1a00004 mov r0, r4 <== NOT EXECUTED
300197bc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300197c0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
300197c4: e1a02004 mov r2, r4 <== NOT EXECUTED 300197c8: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 300197cc: e1a01006 mov r1, r6 <== NOT EXECUTED 300197d0: eb000f10 bl 3001d418 <_Heap_Size_of_alloc_area> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
300197d4: e3500000 cmp r0, #0 <== NOT EXECUTED 300197d8: 03a04009 moveq r4, #9 <== NOT EXECUTED 300197dc: 13a04000 movne r4, #0 <== NOT EXECUTED 300197e0: eafffff0 b 300197a8 <rtems_region_get_segment_size+0x54> <== NOT EXECUTED
3001981c <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
3001981c: e92d41f0 push {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 )
30019820: e2535000 subs r5, r3, #0 <== NOT EXECUTED
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
30019824: e1a06000 mov r6, r0 <== NOT EXECUTED 30019828: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 3001982c: e1a08001 mov r8, r1 <== NOT EXECUTED 30019830: e1a07002 mov r7, r2 <== NOT EXECUTED
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
30019834: 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 )
30019838: 0a000018 beq 300198a0 <rtems_region_resize_segment+0x84> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
3001983c: e59f408c ldr r4, [pc, #140] ; 300198d0 <rtems_region_resize_segment+0xb4><== NOT EXECUTED 30019840: e5940000 ldr r0, [r4] <== NOT EXECUTED 30019844: eb0008bb bl 3001bb38 <_API_Mutex_Lock> <== NOT EXECUTED 30019848: e1a01006 mov r1, r6 <== NOT EXECUTED 3001984c: e59f0080 ldr r0, [pc, #128] ; 300198d4 <rtems_region_resize_segment+0xb8><== NOT EXECUTED 30019850: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30019854: eb001064 bl 3001d9ec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30019858: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3001985c: e1a06000 mov r6, r0 <== NOT EXECUTED 30019860: e3530000 cmp r3, #0 <== NOT EXECUTED 30019864: 1a00000f bne 300198a8 <rtems_region_resize_segment+0x8c> <== NOT EXECUTED
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
30019868: e1a02007 mov r2, r7 <== NOT EXECUTED 3001986c: e28d300c add r3, sp, #12 <== NOT EXECUTED 30019870: e28dc004 add ip, sp, #4 <== NOT EXECUTED 30019874: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30019878: e1a01008 mov r1, r8 <== NOT EXECUTED 3001987c: e58dc000 str ip, [sp] <== NOT EXECUTED 30019880: eb000e96 bl 3001d2e0 <_Heap_Resize_block> <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
30019884: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30019888: e2507000 subs r7, r0, #0 <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
3001988c: e5853000 str r3, [r5] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30019890: 1a000008 bne 300198b8 <rtems_region_resize_segment+0x9c> <== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
30019894: e1a00006 mov r0, r6 <== NOT EXECUTED 30019898: eb0020b4 bl 30021b70 <_Region_Process_queue> <== NOT EXECUTED
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
3001989c: e1a00007 mov r0, r7 <== NOT EXECUTED
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
300198a0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
300198a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
300198a8: e5940000 ldr r0, [r4] <== NOT EXECUTED 300198ac: eb0008bd bl 3001bba8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status;
300198b0: e3a00004 mov r0, #4 <== NOT EXECUTED 300198b4: eafffff9 b 300198a0 <rtems_region_resize_segment+0x84> <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
300198b8: e5940000 ldr r0, [r4] <== NOT EXECUTED 300198bc: eb0008b9 bl 3001bba8 <_API_Mutex_Unlock> <== NOT EXECUTED
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
return RTEMS_UNSATISFIED;
300198c0: e3570001 cmp r7, #1 <== NOT EXECUTED 300198c4: 13a00009 movne r0, #9 <== NOT EXECUTED 300198c8: 03a0000d moveq r0, #13 <== NOT EXECUTED 300198cc: eafffff3 b 300198a0 <rtems_region_resize_segment+0x84> <== NOT EXECUTED
300198d8 <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
300198d8: e92d40f0 push {r4, r5, r6, r7, lr}
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
300198dc: e59f4078 ldr r4, [pc, #120] ; 3001995c <rtems_region_return_segment+0x84>
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
300198e0: e24dd004 sub sp, sp, #4 300198e4: e1a06000 mov r6, r0
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
300198e8: e5940000 ldr r0, [r4]
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
300198ec: e1a05001 mov r5, r1
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
300198f0: eb000890 bl 3001bb38 <_API_Mutex_Lock> 300198f4: e1a01006 mov r1, r6 300198f8: e59f0060 ldr r0, [pc, #96] ; 30019960 <rtems_region_return_segment+0x88> 300198fc: e1a0200d mov r2, sp 30019900: eb001039 bl 3001d9ec <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
30019904: e59d6000 ldr r6, [sp] 30019908: e1a07000 mov r7, r0 3001990c: e3560000 cmp r6, #0
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30019910: 13a06004 movne r6, #4
register Region_Control *the_region;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30019914: 1a000005 bne 30019930 <rtems_region_return_segment+0x58>
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (
Region_Control *the_region,
void *the_segment
)
{
return _Heap_Free( &the_region->Memory, the_segment );
30019918: e2800068 add r0, r0, #104 ; 0x68 3001991c: e1a01005 mov r1, r5 30019920: eb000cb3 bl 3001cbf4 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
30019924: e3500000 cmp r0, #0
return_status = RTEMS_INVALID_ADDRESS;
30019928: 03a06009 moveq r6, #9
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
3001992c: 1a000004 bne 30019944 <rtems_region_return_segment+0x6c>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30019930: e5940000 ldr r0, [r4] <== NOT EXECUTED 30019934: eb00089b bl 3001bba8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30019938: e1a00006 mov r0, r6
3001993c: e28dd004 add sp, sp, #4
30019940: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
30019944: e5973064 ldr r3, [r7, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
30019948: e1a00007 mov r0, r7
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
3001994c: e2433001 sub r3, r3, #1 30019950: e5873064 str r3, [r7, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
30019954: eb002085 bl 30021b70 <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
30019958: eafffff6 b 30019938 <rtems_region_return_segment+0x60>
3000a614 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
3000a614: e92d41f0 push {r4, r5, r6, r7, r8, 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 ) )
3000a618: e2505000 subs r5, r0, #0
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
3000a61c: e24dd020 sub sp, sp, #32 3000a620: e1a04001 mov r4, r1 3000a624: 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;
3000a628: 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 ) )
3000a62c: 1a000001 bne 3000a638 <rtems_semaphore_create+0x24>
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000a630: e28dd020 add sp, sp, #32
3000a634: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
3000a638: e3560000 cmp r6, #0
return RTEMS_INVALID_ADDRESS;
3000a63c: 03a00009 moveq r0, #9
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
3000a640: 0afffffa beq 3000a630 <rtems_semaphore_create+0x1c>
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
3000a644: e21210c0 ands r1, r2, #192 ; 0xc0
3000a648: 1a000029 bne 3000a6f4 <rtems_semaphore_create+0xe0>
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 ) )
3000a64c: e2128030 ands r8, r2, #48 ; 0x30
3000a650: 0a000002 beq 3000a660 <rtems_semaphore_create+0x4c>
3000a654: e3540001 cmp r4, #1
return RTEMS_INVALID_NUMBER;
3000a658: 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 ) )
3000a65c: 8afffff3 bhi 3000a630 <rtems_semaphore_create+0x1c>
*
* 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;
3000a660: e59f1164 ldr r1, [pc, #356] ; 3000a7cc <rtems_semaphore_create+0x1b8> 3000a664: e5910000 ldr r0, [r1]
++level;
3000a668: e2800001 add r0, r0, #1
_Thread_Dispatch_disable_level = level;
3000a66c: e5810000 str r0, [r1]
* 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 );
3000a670: e59f0158 ldr r0, [pc, #344] ; 3000a7d0 <rtems_semaphore_create+0x1bc> 3000a674: e58d2004 str r2, [sp, #4] 3000a678: e58d3000 str r3, [sp] 3000a67c: eb0005af bl 3000bd40 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
3000a680: e2507000 subs r7, r0, #0 3000a684: e59d2004 ldr r2, [sp, #4] 3000a688: e59d3000 ldr r3, [sp]
3000a68c: 0a00003b beq 3000a780 <rtems_semaphore_create+0x16c>
the_semaphore->attribute_set = attribute_set;
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
3000a690: e3580000 cmp r8, #0
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
3000a694: e5872010 str r2, [r7, #16]
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
3000a698: 1a000020 bne 3000a720 <rtems_semaphore_create+0x10c>
* 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;
3000a69c: e3120004 tst r2, #4 3000a6a0: 03a03000 moveq r3, #0 3000a6a4: 13a03001 movne r3, #1
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
3000a6a8: e3e0c000 mvn ip, #0
* 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(
3000a6ac: e2870014 add r0, r7, #20 3000a6b0: e28d1018 add r1, sp, #24 3000a6b4: e1a02004 mov r2, r4
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
3000a6b8: e58dc018 str ip, [sp, #24] 3000a6bc: e58d301c str r3, [sp, #28]
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;
3000a6c0: e58d8008 str r8, [sp, #8]
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
3000a6c4: e58d8014 str r8, [sp, #20]
_CORE_semaphore_Initialize(
3000a6c8: eb000417 bl 3000b72c <_CORE_semaphore_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a6cc: e59f20fc ldr r2, [pc, #252] ; 3000a7d0 <rtems_semaphore_create+0x1bc>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000a6d0: e5973008 ldr r3, [r7, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a6d4: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000a6d8: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a6dc: e7827721 str r7, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000a6e0: e587500c str r5, [r7, #12]
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
3000a6e4: e5863000 str r3, [r6]
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
3000a6e8: eb000a92 bl 3000d138 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a6ec: e3a00000 mov r0, #0 3000a6f0: eaffffce b 3000a630 <rtems_semaphore_create+0x1c>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
3000a6f4: e2028030 and r8, r2, #48 ; 0x30
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
3000a6f8: e3580010 cmp r8, #16
3000a6fc: 0a000001 beq 3000a708 <rtems_semaphore_create+0xf4>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
3000a700: e3a0000b mov r0, #11 <== NOT EXECUTED 3000a704: eaffffc9 b 3000a630 <rtems_semaphore_create+0x1c> <== NOT EXECUTED
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
3000a708: e3120004 tst r2, #4
3000a70c: 0afffffb beq 3000a700 <rtems_semaphore_create+0xec>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
3000a710: e35100c0 cmp r1, #192 ; 0xc0
3000a714: 1affffce bne 3000a654 <rtems_semaphore_create+0x40>
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
3000a718: e3a0000b mov r0, #11 <== NOT EXECUTED 3000a71c: eaffffc3 b 3000a630 <rtems_semaphore_create+0x1c> <== NOT EXECUTED
/*
* 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;
3000a720: e3120004 tst r2, #4 3000a724: 03a01000 moveq r1, #0 3000a728: 13a01001 movne r1, #1
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
3000a72c: e3580010 cmp r8, #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;
3000a730: e58d1010 str r1, [sp, #16]
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
3000a734: 0a000014 beq 3000a78c <rtems_semaphore_create+0x178>
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;
3000a738: e3a03002 mov r3, #2 3000a73c: e58d3008 str r3, [sp, #8]
the_mutex_attr.only_owner_release = false;
3000a740: e3a03000 mov r3, #0 3000a744: e5cd300c strb r3, [sp, #12]
}
mutex_status = _CORE_mutex_Initialize(
3000a748: e2443001 sub r3, r4, #1 3000a74c: e2732000 rsbs r2, r3, #0 3000a750: e0a22003 adc r2, r2, r3 3000a754: e2870014 add r0, r7, #20 3000a758: e28d1008 add r1, sp, #8 3000a75c: eb000321 bl 3000b3e8 <_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 ) {
3000a760: e3500006 cmp r0, #6
3000a764: 1affffd8 bne 3000a6cc <rtems_semaphore_create+0xb8>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
3000a768: e59f0060 ldr r0, [pc, #96] ; 3000a7d0 <rtems_semaphore_create+0x1bc> 3000a76c: e1a01007 mov r1, r7 3000a770: eb000650 bl 3000c0b8 <_Objects_Free>
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
3000a774: eb000a6f bl 3000d138 <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
3000a778: e3a00013 mov r0, #19 3000a77c: eaffffab b 3000a630 <rtems_semaphore_create+0x1c>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
3000a780: eb000a6c bl 3000d138 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
3000a784: e3a00005 mov r0, #5 3000a788: eaffffa8 b 3000a630 <rtems_semaphore_create+0x1c>
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000a78c: e3a00000 mov r0, #0
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
3000a790: e3510001 cmp r1, #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;
3000a794: e58d3014 str r3, [sp, #20]
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000a798: e58d0008 str r0, [sp, #8]
the_mutex_attr.only_owner_release = false;
3000a79c: e5cd000c strb r0, [sp, #12]
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
3000a7a0: 1affffe8 bne 3000a748 <rtems_semaphore_create+0x134>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
3000a7a4: e3120040 tst r2, #64 ; 0x40
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
3000a7a8: 13a03002 movne r3, #2 3000a7ac: 158d3010 strne r3, [sp, #16]
the_mutex_attr.only_owner_release = true;
3000a7b0: 15cd100c strbne r1, [sp, #12]
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 ) ) {
3000a7b4: 1affffe3 bne 3000a748 <rtems_semaphore_create+0x134>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
3000a7b8: e3120080 tst r2, #128 ; 0x80
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
3000a7bc: 13a03003 movne r3, #3 3000a7c0: 158d3010 strne r3, [sp, #16]
the_mutex_attr.only_owner_release = true;
3000a7c4: 15cd100c strbne r1, [sp, #12] 3000a7c8: eaffffde b 3000a748 <rtems_semaphore_create+0x134>
3000a7d4 <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
3000a7d4: e92d4010 push {r4, lr}
3000a7d8: e24dd004 sub sp, sp, #4
3000a7dc: e1a01000 mov r1, r0
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
3000a7e0: e1a0200d mov r2, sp 3000a7e4: e59f0088 ldr r0, [pc, #136] ; 3000a874 <rtems_semaphore_delete+0xa0> 3000a7e8: eb000689 bl 3000c214 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
3000a7ec: e59d3000 ldr r3, [sp] 3000a7f0: e1a04000 mov r4, r0 3000a7f4: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a7f8: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
3000a7fc: 1a000009 bne 3000a828 <rtems_semaphore_delete+0x54>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
3000a800: e5941010 ldr r1, [r4, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
3000a804: e2111030 ands r1, r1, #48 ; 0x30
3000a808: 0a000008 beq 3000a830 <rtems_semaphore_delete+0x5c>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
3000a80c: e5943064 ldr r3, [r4, #100] ; 0x64 3000a810: e3530000 cmp r3, #0
3000a814: 1a000011 bne 3000a860 <rtems_semaphore_delete+0x8c>
3000a818: e3510020 cmp r1, #32
3000a81c: 0a00000f beq 3000a860 <rtems_semaphore_delete+0x8c>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
3000a820: eb000a44 bl 3000d138 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3000a824: e3a0000c mov r0, #12 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a828: e28dd004 add sp, sp, #4
3000a82c: e8bd8010 pop {r4, pc}
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
3000a830: e2840014 add r0, r4, #20 3000a834: e3a02002 mov r2, #2 3000a838: eb0003ba bl 3000b728 <_CORE_semaphore_Flush>
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
3000a83c: e59f0030 ldr r0, [pc, #48] ; 3000a874 <rtems_semaphore_delete+0xa0> 3000a840: e1a01004 mov r1, r4 3000a844: eb000560 bl 3000bdcc <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
3000a848: e59f0024 ldr r0, [pc, #36] ; 3000a874 <rtems_semaphore_delete+0xa0> 3000a84c: e1a01004 mov r1, r4 3000a850: eb000618 bl 3000c0b8 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
3000a854: eb000a37 bl 3000d138 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a858: e3a00000 mov r0, #0 3000a85c: eafffff1 b 3000a828 <rtems_semaphore_delete+0x54>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
_CORE_mutex_Flush(
3000a860: e2840014 add r0, r4, #20 3000a864: e3a01000 mov r1, #0 3000a868: e3a02004 mov r2, #4 3000a86c: eb0002dc bl 3000b3e4 <_CORE_mutex_Flush> 3000a870: eafffff1 b 3000a83c <rtems_semaphore_delete+0x68>
30014974 <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
30014974: e52de004 push {lr} ; (str lr, [sp, #-4]!)
30014978: e24dd004 sub sp, sp, #4
3001497c: e1a01000 mov r1, r0
30014980: e1a0200d mov r2, sp
30014984: e59f0048 ldr r0, [pc, #72] ; 300149d4 <rtems_semaphore_flush+0x60>
30014988: ebffe45c bl 3000db00 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
3001498c: e59d3000 ldr r3, [sp] 30014990: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30014994: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30014998: 1a000007 bne 300149bc <rtems_semaphore_flush+0x48>
3001499c: e5901010 ldr r1, [r0, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
_CORE_mutex_Flush(
300149a0: e2800014 add r0, r0, #20
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
300149a4: e2111030 ands r1, r1, #48 ; 0x30
300149a8: 1a000005 bne 300149c4 <rtems_semaphore_flush+0x50>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
300149ac: e3a02001 mov r2, #1 <== NOT EXECUTED 300149b0: ebffe197 bl 3000d014 <_CORE_semaphore_Flush> <== NOT EXECUTED
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
300149b4: ebffe7f9 bl 3000e9a0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300149b8: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300149bc: e28dd004 add sp, sp, #4
300149c0: e8bd8000 pop {pc}
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
_CORE_mutex_Flush(
300149c4: e1a01003 mov r1, r3 300149c8: e3a02001 mov r2, #1 300149cc: ebffe0bf bl 3000ccd0 <_CORE_mutex_Flush> 300149d0: eafffff7 b 300149b4 <rtems_semaphore_flush+0x40>
3000a878 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
3000a878: e92d40f0 push {r4, r5, r6, r7, lr}
3000a87c: e1a04000 mov r4, r0
3000a880: e24dd00c sub sp, sp, #12
Objects_Id id,
Objects_Locations *location,
ISR_Level *level
)
{
return (Semaphore_Control *)
3000a884: e28d3008 add r3, sp, #8 3000a888: e1a05001 mov r5, r1 3000a88c: e1a06002 mov r6, r2 3000a890: e59f00f4 ldr r0, [pc, #244] ; 3000a98c <rtems_semaphore_obtain+0x114> 3000a894: e1a01004 mov r1, r4 3000a898: e28d2004 add r2, sp, #4 3000a89c: eb000640 bl 3000c1a4 <_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 ) {
3000a8a0: e59d3004 ldr r3, [sp, #4] 3000a8a4: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a8a8: 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 ) {
3000a8ac: 1a00000f bne 3000a8f0 <rtems_semaphore_obtain+0x78>
3000a8b0: e5903010 ldr r3, [r0, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
3000a8b4: e2133030 ands r3, r3, #48 ; 0x30
3000a8b8: 1a00000e bne 3000a8f8 <rtems_semaphore_obtain+0x80>
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000a8bc: e59f70cc ldr r7, [pc, #204] ; 3000a990 <rtems_semaphore_obtain+0x118>
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
3000a8c0: e590105c ldr r1, [r0, #92] ; 0x5c
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000a8c4: e5972008 ldr r2, [r7, #8]
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
3000a8c8: e3510000 cmp r1, #0
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
3000a8cc: e5823034 str r3, [r2, #52] ; 0x34
if ( the_semaphore->count != 0 ) {
3000a8d0: 0a000015 beq 3000a92c <rtems_semaphore_obtain+0xb4>
the_semaphore->count -= 1;
3000a8d4: e2411001 sub r1, r1, #1 3000a8d8: e580105c str r1, [r0, #92] ; 0x5c 3000a8dc: e59d3008 ldr r3, [sp, #8] 3000a8e0: e129f003 msr CPSR_fc, r3
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
_Thread_Executing->Wait.return_code );
3000a8e4: e5973008 ldr r3, [r7, #8]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
3000a8e8: e5930034 ldr r0, [r3, #52] ; 0x34 3000a8ec: eb00004e bl 3000aa2c <_Semaphore_Translate_core_semaphore_return_code>
break;
}
return RTEMS_INVALID_ID;
}
3000a8f0: e28dd00c add sp, sp, #12
3000a8f4: e8bd80f0 pop {r4, r5, r6, r7, pc}
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
_CORE_mutex_Seize(
3000a8f8: e59dc008 ldr ip, [sp, #8]
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
3000a8fc: e2052001 and r2, r5, #1 3000a900: e1a03006 mov r3, r6 3000a904: e2800014 add r0, r0, #20 3000a908: e1a01004 mov r1, r4 3000a90c: e2222001 eor r2, r2, #1 3000a910: e58dc000 str ip, [sp] 3000a914: eb000303 bl 3000b528 <_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 );
3000a918: e59f3070 ldr r3, [pc, #112] ; 3000a990 <rtems_semaphore_obtain+0x118> 3000a91c: e5933008 ldr r3, [r3, #8]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
3000a920: e5930034 ldr r0, [r3, #52] ; 0x34 3000a924: eb00003c bl 3000aa1c <_Semaphore_Translate_core_mutex_return_code> 3000a928: eafffff0 b 3000a8f0 <rtems_semaphore_obtain+0x78>
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
3000a92c: e3150001 tst r5, #1
3000a930: 0a000004 beq 3000a948 <rtems_semaphore_obtain+0xd0>
3000a934: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000a938: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( *level_p );
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
3000a93c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a940: e5823034 str r3, [r2, #52] ; 0x34 <== NOT EXECUTED 3000a944: eaffffe6 b 3000a8e4 <rtems_semaphore_obtain+0x6c> <== 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;
3000a948: e59f3044 ldr r3, [pc, #68] ; 3000a994 <rtems_semaphore_obtain+0x11c> 3000a94c: e5931000 ldr r1, [r3]
++level;
3000a950: e2811001 add r1, r1, #1
_Thread_Dispatch_disable_level = level;
3000a954: e5831000 str r1, [r3]
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;
3000a958: e3a01001 mov r1, #1
return;
}
_Thread_Disable_dispatch();
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
3000a95c: e2803014 add r3, r0, #20 3000a960: e5801044 str r1, [r0, #68] ; 0x44 3000a964: e5823044 str r3, [r2, #68] ; 0x44
executing->Wait.id = id;
3000a968: e5824020 str r4, [r2, #32] 3000a96c: e59d2008 ldr r2, [sp, #8] 3000a970: e129f002 msr CPSR_fc, r2
_ISR_Enable( *level_p );
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
3000a974: e59f201c ldr r2, [pc, #28] ; 3000a998 <rtems_semaphore_obtain+0x120> 3000a978: e1a00003 mov r0, r3 3000a97c: e1a01006 mov r1, r6 3000a980: eb000b22 bl 3000d610 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
3000a984: eb0009eb bl 3000d138 <_Thread_Enable_dispatch> 3000a988: eaffffd5 b 3000a8e4 <rtems_semaphore_obtain+0x6c>
30019e28 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
30019e28: e92d4010 push {r4, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
30019e2c: e2514000 subs r4, r1, #0
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
30019e30: e24dd004 sub sp, sp, #4
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
30019e34: 03a0000a moveq r0, #10
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
30019e38: 1a000001 bne 30019e44 <rtems_signal_send+0x1c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30019e3c: e28dd004 add sp, sp, #4
30019e40: e8bd8010 pop {r4, pc}
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
30019e44: e1a0100d mov r1, sp 30019e48: eb0012c6 bl 3001e968 <_Thread_Get>
switch ( location ) {
30019e4c: e59d3000 ldr r3, [sp] 30019e50: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30019e54: 13a00004 movne r0, #4
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
30019e58: 1afffff7 bne 30019e3c <rtems_signal_send+0x14>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
30019e5c: e59030f0 ldr r3, [r0, #240] ; 0xf0
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
30019e60: e593200c ldr r2, [r3, #12] 30019e64: e3520000 cmp r2, #0
30019e68: 0a000014 beq 30019ec0 <rtems_signal_send+0x98>
if ( asr->is_enabled ) {
30019e6c: e5d32008 ldrb r2, [r3, #8] 30019e70: e3520000 cmp r2, #0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30019e74: e10f2000 mrs r2, CPSR 30019e78: e3821080 orr r1, r2, #128 ; 0x80 30019e7c: e129f001 msr CPSR_fc, r1
30019e80: 0a000011 beq 30019ecc <rtems_signal_send+0xa4>
)
{
ISR_Level _level;
_ISR_Disable( _level );
*signal_set |= signals;
30019e84: e5931014 ldr r1, [r3, #20] 30019e88: e1814004 orr r4, r1, r4 30019e8c: 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 (
30019e90: e129f002 msr CPSR_fc, r2
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
30019e94: e59f3044 ldr r3, [pc, #68] ; 30019ee0 <rtems_signal_send+0xb8> 30019e98: e5932000 ldr r2, [r3] 30019e9c: e3520000 cmp r2, #0
30019ea0: 0a000003 beq 30019eb4 <rtems_signal_send+0x8c>
30019ea4: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 30019ea8: e1500002 cmp r0, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
30019eac: 03a02001 moveq r2, #1 <== NOT EXECUTED 30019eb0: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
30019eb4: eb0012a3 bl 3001e948 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30019eb8: e3a00000 mov r0, #0 30019ebc: eaffffde b 30019e3c <rtems_signal_send+0x14>
}
_Thread_Enable_dispatch();
30019ec0: eb0012a0 bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30019ec4: e3a0000b mov r0, #11 <== NOT EXECUTED 30019ec8: eaffffdb b 30019e3c <rtems_signal_send+0x14> <== NOT EXECUTED 30019ecc: e5931018 ldr r1, [r3, #24] <== NOT EXECUTED 30019ed0: e1814004 orr r4, r1, r4 <== NOT EXECUTED 30019ed4: e5834018 str r4, [r3, #24] <== NOT EXECUTED 30019ed8: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 30019edc: eafffff4 b 30019eb4 <rtems_signal_send+0x8c> <== NOT EXECUTED
3000aa98 <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000aa98: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000aa9c: e24dd01c sub sp, sp, #28
3000aaa0: e59d9044 ldr r9, [sp, #68] ; 0x44
3000aaa4: e1a04000 mov r4, r0
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
3000aaa8: e3590000 cmp r9, #0
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
3000aaac: e1a05001 mov r5, r1 3000aab0: e1a0a002 mov sl, r2 3000aab4: e1a08003 mov r8, r3
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000aab8: 03a00009 moveq r0, #9
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
3000aabc: 0a000002 beq 3000aacc <rtems_task_create+0x34>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
3000aac0: e3540000 cmp r4, #0
return RTEMS_INVALID_NAME;
3000aac4: 03a00003 moveq r0, #3
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
3000aac8: 1a000001 bne 3000aad4 <rtems_task_create+0x3c>
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
3000aacc: e28dd01c add sp, sp, #28
3000aad0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
3000aad4: e59d3040 ldr r3, [sp, #64] ; 0x40 3000aad8: e3130902 tst r3, #32768 ; 0x8000
3000aadc: 1a000005 bne 3000aaf8 <rtems_task_create+0x60>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
3000aae0: e3510000 cmp r1, #0
3000aae4: 0a00002a beq 3000ab94 <rtems_task_create+0xfc>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
3000aae8: e59f30e4 ldr r3, [pc, #228] ; 3000abd4 <rtems_task_create+0x13c> 3000aaec: e5d33000 ldrb r3, [r3]
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
3000aaf0: e1510003 cmp r1, r3
3000aaf4: 8a000026 bhi 3000ab94 <rtems_task_create+0xfc>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
3000aaf8: e59f20d8 ldr r2, [pc, #216] ; 3000abd8 <rtems_task_create+0x140> 3000aafc: e5920000 ldr r0, [r2] 3000ab00: eb0001de bl 3000b280 <_API_Mutex_Lock>
* This function allocates a task control block from
* the inactive chain of free task control blocks.
*/
RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information );
3000ab04: e59f00d0 ldr r0, [pc, #208] ; 3000abdc <rtems_task_create+0x144> 3000ab08: eb00048c bl 3000bd40 <_Objects_Allocate>
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
3000ab0c: e2506000 subs r6, r0, #0
3000ab10: 0a00002a beq 3000abc0 <rtems_task_create+0x128>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
3000ab14: e3180c01 tst r8, #256 ; 0x100 3000ab18: e3a0b000 mov fp, #0 3000ab1c: 13a07000 movne r7, #0 3000ab20: 03a07001 moveq r7, #1 3000ab24: e3180c02 tst r8, #512 ; 0x200 3000ab28: 03a0e000 moveq lr, #0 3000ab2c: 13a0e001 movne lr, #1
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
3000ab30: e208c080 and ip, r8, #128 ; 0x80
3000ab34: e59f00a0 ldr r0, [pc, #160] ; 3000abdc <rtems_task_create+0x144>
3000ab38: e1a01006 mov r1, r6
3000ab3c: e1a0200b mov r2, fp
3000ab40: e1a0300a mov r3, sl
3000ab44: e58db000 str fp, [sp]
3000ab48: e98d40a0 stmib sp, {r5, r7, lr}
3000ab4c: e58db010 str fp, [sp, #16]
3000ab50: e58dc014 str ip, [sp, #20]
3000ab54: e58d4018 str r4, [sp, #24]
3000ab58: eb0009a3 bl 3000d1ec <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
3000ab5c: e150000b cmp r0, fp
3000ab60: 0a00000d beq 3000ab9c <rtems_task_create+0x104>
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
3000ab64: e59620f0 ldr r2, [r6, #240] ; 0xf0
#include <rtems/score/wkspace.h>
#include <rtems/score/apiext.h>
#include <rtems/score/sysstate.h>
#include <rtems/score/apimutex.h>
rtems_status_code rtems_task_create(
3000ab68: e3180b01 tst r8, #1024 ; 0x400 3000ab6c: 13a01000 movne r1, #0 3000ab70: 03a01001 moveq r1, #1
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
*id = the_thread->Object.id;
3000ab74: e5963008 ldr r3, [r6, #8]
#include <rtems/score/wkspace.h>
#include <rtems/score/apiext.h>
#include <rtems/score/sysstate.h>
#include <rtems/score/apimutex.h>
rtems_status_code rtems_task_create(
3000ab78: e5c21008 strb r1, [r2, #8]
);
}
#endif
_RTEMS_Unlock_allocator();
3000ab7c: e59f2054 ldr r2, [pc, #84] ; 3000abd8 <rtems_task_create+0x140> 3000ab80: e5920000 ldr r0, [r2]
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
*id = the_thread->Object.id;
3000ab84: e5893000 str r3, [r9]
);
}
#endif
_RTEMS_Unlock_allocator();
3000ab88: eb0001d8 bl 3000b2f0 <_API_Mutex_Unlock>
return RTEMS_SUCCESSFUL;
3000ab8c: e1a0000b mov r0, fp 3000ab90: eaffffcd b 3000aacc <rtems_task_create+0x34>
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
return RTEMS_INVALID_PRIORITY;
3000ab94: e3a00013 mov r0, #19 <== NOT EXECUTED 3000ab98: eaffffcb b 3000aacc <rtems_task_create+0x34> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
3000ab9c: e5960008 ldr r0, [r6, #8] 3000aba0: eb000561 bl 3000c12c <_Objects_Get_information_id> 3000aba4: e1a01006 mov r1, r6 3000aba8: eb000542 bl 3000c0b8 <_Objects_Free>
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Objects_MP_Free_global_object( the_global_object );
#endif
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
3000abac: e59f2024 ldr r2, [pc, #36] ; 3000abd8 <rtems_task_create+0x140> 3000abb0: e5920000 ldr r0, [r2] 3000abb4: eb0001cd bl 3000b2f0 <_API_Mutex_Unlock>
return RTEMS_UNSATISFIED;
3000abb8: e3a0000d mov r0, #13 3000abbc: eaffffc2 b 3000aacc <rtems_task_create+0x34>
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
3000abc0: e59f3010 ldr r3, [pc, #16] ; 3000abd8 <rtems_task_create+0x140> 3000abc4: e5930000 ldr r0, [r3] 3000abc8: eb0001c8 bl 3000b2f0 <_API_Mutex_Unlock>
return RTEMS_TOO_MANY;
3000abcc: e3a00005 mov r0, #5 3000abd0: eaffffbd b 3000aacc <rtems_task_create+0x34>
3000abe0 <rtems_task_delete>:
#include <rtems/score/apimutex.h>
rtems_status_code rtems_task_delete(
rtems_id id
)
{
3000abe0: e92d4070 push {r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
3000abe4: e59f4070 ldr r4, [pc, #112] ; 3000ac5c <rtems_task_delete+0x7c>
#include <rtems/score/apimutex.h>
rtems_status_code rtems_task_delete(
rtems_id id
)
{
3000abe8: e24dd004 sub sp, sp, #4 3000abec: e1a05000 mov r5, r0
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
3000abf0: e5940000 ldr r0, [r4] 3000abf4: eb0001a1 bl 3000b280 <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
3000abf8: e1a00005 mov r0, r5 3000abfc: e1a0100d mov r1, sp 3000ac00: eb000954 bl 3000d158 <_Thread_Get>
switch ( location ) {
3000ac04: e59d5000 ldr r5, [sp]
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
the_thread = _Thread_Get( id, &location );
3000ac08: e1a06000 mov r6, r0
switch ( location ) {
3000ac0c: e3550000 cmp r5, #0
3000ac10: 1a00000d bne 3000ac4c <rtems_task_delete+0x6c>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
3000ac14: e5900008 ldr r0, [r0, #8] 3000ac18: eb000543 bl 3000c12c <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
3000ac1c: e1a01006 mov r1, r6 3000ac20: eb000862 bl 3000cdb0 <_Thread_Close> 3000ac24: e5960008 ldr r0, [r6, #8] 3000ac28: eb00053f bl 3000c12c <_Objects_Get_information_id> 3000ac2c: e1a01006 mov r1, r6 3000ac30: eb000520 bl 3000c0b8 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
3000ac34: e5940000 ldr r0, [r4] 3000ac38: eb0001ac bl 3000b2f0 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
3000ac3c: eb00093d bl 3000d138 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ac40: e1a00005 mov r0, r5
break;
}
_RTEMS_Unlock_allocator();
return RTEMS_INVALID_ID;
}
3000ac44: e28dd004 add sp, sp, #4
3000ac48: e8bd8070 pop {r4, r5, r6, pc}
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
3000ac4c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000ac50: eb0001a6 bl 3000b2f0 <_API_Mutex_Unlock> <== NOT EXECUTED
return RTEMS_INVALID_ID;
3000ac54: e3a00004 mov r0, #4 <== NOT EXECUTED 3000ac58: eafffff9 b 3000ac44 <rtems_task_delete+0x64> <== NOT EXECUTED
3000c968 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c968: e92d4030 push {r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c96c: e59f30a8 ldr r3, [pc, #168] ; 3000ca1c <rtems_task_get_note+0xb4>
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c970: e1a0c000 mov ip, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c974: e5d33004 ldrb r3, [r3, #4]
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c978: e24dd008 sub sp, sp, #8
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c97c: e3530000 cmp r3, #0
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c980: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
3000c984: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c988: 1a000001 bne 3000c994 <rtems_task_get_note+0x2c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000c98c: e28dd008 add sp, sp, #8
3000c990: e8bd8030 pop {r4, r5, pc}
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000c994: e3520000 cmp r2, #0
return RTEMS_INVALID_ADDRESS;
3000c998: 03a00009 moveq r0, #9
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000c99c: 0afffffa beq 3000c98c <rtems_task_get_note+0x24>
/*
* 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 )
3000c9a0: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000c9a4: 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 )
3000c9a8: 8afffff7 bhi 3000c98c <rtems_task_get_note+0x24>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c9ac: e59f306c ldr r3, [pc, #108] ; 3000ca20 <rtems_task_get_note+0xb8> 3000c9b0: e35c0000 cmp ip, #0 3000c9b4: e5933008 ldr r3, [r3, #8]
3000c9b8: 0a000011 beq 3000ca04 <rtems_task_get_note+0x9c>
3000c9bc: e5931008 ldr r1, [r3, #8] 3000c9c0: e15c0001 cmp ip, r1
3000c9c4: 0a00000e beq 3000ca04 <rtems_task_get_note+0x9c>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
3000c9c8: e28d1004 add r1, sp, #4 3000c9cc: e58d2000 str r2, [sp] 3000c9d0: eb000a09 bl 3000f1fc <_Thread_Get>
switch ( location ) {
3000c9d4: e59d5004 ldr r5, [sp, #4] 3000c9d8: e59d2000 ldr r2, [sp] 3000c9dc: e3550000 cmp r5, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000c9e0: 13a00004 movne r0, #4
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000c9e4: 1affffe8 bne 3000c98c <rtems_task_get_note+0x24>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000c9e8: e59030f0 ldr r3, [r0, #240] ; 0xf0 3000c9ec: e2844008 add r4, r4, #8 3000c9f0: e7933104 ldr r3, [r3, r4, lsl #2] 3000c9f4: e5823000 str r3, [r2]
_Thread_Enable_dispatch();
3000c9f8: eb0009f7 bl 3000f1dc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c9fc: e1a00005 mov r0, r5 3000ca00: eaffffe1 b 3000c98c <rtems_task_get_note+0x24>
*/
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 ];
3000ca04: e59330f0 ldr r3, [r3, #240] ; 0xf0 <== NOT EXECUTED 3000ca08: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000ca0c: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000ca10: 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 ];
3000ca14: e5823000 str r3, [r2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000ca18: eaffffdb b 3000c98c <rtems_task_get_note+0x24> <== NOT EXECUTED
3000ac60 <rtems_task_ident>:
rtems_id *id
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
3000ac60: e2523000 subs r3, r2, #0
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
rtems_id *id
)
{
3000ac64: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3000ac68: e1a0c000 mov ip, r0
3000ac6c: e1a02001 mov r2, r1
Objects_Name_or_id_lookup_errors status;
if ( !id )
3000ac70: 0a00000c beq 3000aca8 <rtems_task_ident+0x48>
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
3000ac74: e3500000 cmp r0, #0
3000ac78: 1a000004 bne 3000ac90 <rtems_task_ident+0x30>
*id = _Thread_Executing->Object.id;
3000ac7c: e59f202c ldr r2, [pc, #44] ; 3000acb0 <rtems_task_ident+0x50> 3000ac80: e5922008 ldr r2, [r2, #8] 3000ac84: e5922008 ldr r2, [r2, #8] 3000ac88: e5832000 str r2, [r3]
return RTEMS_SUCCESSFUL;
3000ac8c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
3000ac90: e59f001c ldr r0, [pc, #28] ; 3000acb4 <rtems_task_ident+0x54> 3000ac94: e1a0100c mov r1, ip 3000ac98: eb0005ba bl 3000c388 <_Objects_Name_to_id_u32>
return _Status_Object_name_errors_to_status[ status ];
3000ac9c: e59f3014 ldr r3, [pc, #20] ; 3000acb8 <rtems_task_ident+0x58>
3000aca0: e7930100 ldr r0, [r3, r0, lsl #2]
3000aca4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000aca8: 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 ];
}
3000acac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3001a2b0 <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
3001a2b0: e92d4010 push {r4, lr} <== NOT EXECUTED
3001a2b4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3001a2b8: e1a0100d mov r1, sp <== NOT EXECUTED 3001a2bc: eb0011a9 bl 3001e968 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3001a2c0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3001a2c4: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a2c8: 13a00004 movne r0, #4 <== NOT EXECUTED
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3001a2cc: 1a000004 bne 3001a2e4 <rtems_task_is_suspended+0x34> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3001a2d0: e5904010 ldr r4, [r0, #16] <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
3001a2d4: e2144002 ands r4, r4, #2 <== NOT EXECUTED 3001a2d8: 0a000003 beq 3001a2ec <rtems_task_is_suspended+0x3c> <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3001a2dc: eb001199 bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
3001a2e0: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a2e4: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001a2e8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Enable_dispatch();
3001a2ec: eb001195 bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001a2f0: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a2f4: eafffffa b 3001a2e4 <rtems_task_is_suspended+0x34> <== NOT EXECUTED
30014aa4 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
30014aa4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
30014aa8: e2525000 subs r5, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
30014aac: e1a04000 mov r4, r0 30014ab0: e1a06001 mov r6, r1
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
30014ab4: 03a00009 moveq r0, #9
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
30014ab8: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
30014abc: e59f9148 ldr r9, [pc, #328] ; 30014c0c <rtems_task_mode+0x168> 30014ac0: e5997008 ldr r7, [r9, #8]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
30014ac4: e5d7a070 ldrb sl, [r7, #112] ; 0x70
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
30014ac8: e59780f0 ldr r8, [r7, #240] ; 0xf0
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
30014acc: e5973078 ldr r3, [r7, #120] ; 0x78
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
30014ad0: e35a0000 cmp sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
30014ad4: e5d8b008 ldrb fp, [r8, #8]
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
30014ad8: 03a0ac01 moveq sl, #256 ; 0x100 30014adc: 13a0a000 movne sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
30014ae0: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
30014ae4: 138aac02 orrne sl, sl, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
30014ae8: e35b0000 cmp fp, #0 30014aec: 03a0bb01 moveq fp, #1024 ; 0x400 30014af0: 13a0b000 movne fp, #0
old_mode |= _ISR_Get_level();
30014af4: ebffecc1 bl 3000fe00 <_CPU_ISR_Get_level>
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
30014af8: e18bb000 orr fp, fp, r0
old_mode |= _ISR_Get_level();
30014afc: e18ba00a orr sl, fp, sl
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
30014b00: e3160c01 tst r6, #256 ; 0x100
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
30014b04: e585a000 str sl, [r5]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
30014b08: 0a000003 beq 30014b1c <rtems_task_mode+0x78>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
30014b0c: e3140c01 tst r4, #256 ; 0x100 30014b10: 13a03000 movne r3, #0 30014b14: 03a03001 moveq r3, #1 30014b18: e5c73070 strb r3, [r7, #112] ; 0x70
if ( mask & RTEMS_TIMESLICE_MASK ) {
30014b1c: e3160c02 tst r6, #512 ; 0x200
30014b20: 1a000028 bne 30014bc8 <rtems_task_mode+0x124>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
30014b24: e3160080 tst r6, #128 ; 0x80
30014b28: 1a00002f bne 30014bec <rtems_task_mode+0x148>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
30014b2c: e2166b01 ands r6, r6, #1024 ; 0x400
30014b30: 0a000012 beq 30014b80 <rtems_task_mode+0xdc>
#include <rtems/score/tod.h>
#include <rtems/score/wkspace.h>
#include <rtems/score/apiext.h>
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_mode(
30014b34: e3140b01 tst r4, #1024 ; 0x400
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
30014b38: e5d82008 ldrb r2, [r8, #8]
#include <rtems/score/tod.h>
#include <rtems/score/wkspace.h>
#include <rtems/score/apiext.h>
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_mode(
30014b3c: 13a03000 movne r3, #0 30014b40: 03a03001 moveq r3, #1
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
30014b44: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
30014b48: 03a06000 moveq r6, #0
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
30014b4c: 0a00000b beq 30014b80 <rtems_task_mode+0xdc>
asr->is_enabled = is_asr_enabled;
30014b50: e5c83008 strb r3, [r8, #8]
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30014b54: e10f3000 mrs r3, CPSR 30014b58: e3832080 orr r2, r3, #128 ; 0x80 30014b5c: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
30014b60: e5981018 ldr r1, [r8, #24]
information->signals_pending = information->signals_posted;
30014b64: e5982014 ldr r2, [r8, #20]
information->signals_posted = _signals;
30014b68: e5881014 str r1, [r8, #20]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
30014b6c: e5882018 str r2, [r8, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30014b70: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
30014b74: e5986014 ldr r6, [r8, #20] 30014b78: e3560000 cmp r6, #0
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
30014b7c: 13a06001 movne r6, #1
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
30014b80: e59f3088 ldr r3, [pc, #136] ; 30014c10 <rtems_task_mode+0x16c> 30014b84: e5933000 ldr r3, [r3] 30014b88: e3530003 cmp r3, #3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
30014b8c: 13a00000 movne r0, #0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
30014b90: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
30014b94: e3560000 cmp r6, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
30014b98: e5993008 ldr r3, [r9, #8]
if ( are_signals_pending ||
30014b9c: 1a000015 bne 30014bf8 <rtems_task_mode+0x154>
30014ba0: e59f2064 ldr r2, [pc, #100] ; 30014c0c <rtems_task_mode+0x168> 30014ba4: e592200c ldr r2, [r2, #12] 30014ba8: e1530002 cmp r3, r2
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
30014bac: 01a00006 moveq r0, r6
30014bb0: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
30014bb4: e5d33070 ldrb r3, [r3, #112] ; 0x70 30014bb8: e3530000 cmp r3, #0
30014bbc: 1a00000d bne 30014bf8 <rtems_task_mode+0x154>
30014bc0: e1a00006 mov r0, r6 <== NOT EXECUTED
}
30014bc4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
*/
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
30014bc8: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
30014bcc: 159f3040 ldrne r3, [pc, #64] ; 30014c14 <rtems_task_mode+0x170>
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
30014bd0: 13a02001 movne r2, #1
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
30014bd4: 15933000 ldrne r3, [r3]
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
30014bd8: 15872078 strne r2, [r7, #120] ; 0x78
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
30014bdc: 15873074 strne r3, [r7, #116] ; 0x74
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
30014be0: 05873078 streq r3, [r7, #120] ; 0x78
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
30014be4: e3160080 tst r6, #128 ; 0x80
30014be8: 0affffcf beq 30014b2c <rtems_task_mode+0x88>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
30014bec: e2040080 and r0, r4, #128 ; 0x80 30014bf0: ebffec7d bl 3000fdec <_CPU_ISR_Set_level> 30014bf4: eaffffcc b 30014b2c <rtems_task_mode+0x88>
_Thread_Dispatch_necessary = true;
30014bf8: e3a03001 mov r3, #1 30014bfc: e5c93004 strb r3, [r9, #4]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
30014c00: ebffe6fa bl 3000e7f0 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
30014c04: e3a00000 mov r0, #0
30014c08: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000b55c <rtems_task_restart>:
rtems_status_code rtems_task_restart(
rtems_id id,
uint32_t argument
)
{
3000b55c: e92d4030 push {r4, r5, lr}
3000b560: e24dd004 sub sp, sp, #4
3000b564: e1a05001 mov r5, r1
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000b568: e1a0100d mov r1, sp 3000b56c: eb000916 bl 3000d9cc <_Thread_Get>
switch ( location ) {
3000b570: e59d4000 ldr r4, [sp] 3000b574: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000b578: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000b57c: 1a000006 bne 3000b59c <rtems_task_restart+0x40>
case OBJECTS_LOCAL:
if ( _Thread_Restart( the_thread, NULL, argument ) ) {
3000b580: e1a01004 mov r1, r4 3000b584: e1a02005 mov r2, r5 3000b588: eb000b2c bl 3000e240 <_Thread_Restart> 3000b58c: e3500000 cmp r0, #0
3000b590: 1a000003 bne 3000b5a4 <rtems_task_restart+0x48>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000b594: eb000904 bl 3000d9ac <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000b598: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000b59c: e28dd004 add sp, sp, #4
3000b5a0: e8bd8030 pop {r4, r5, pc}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Restart( the_thread, NULL, argument ) ) {
_Thread_Enable_dispatch();
3000b5a4: eb000900 bl 3000d9ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b5a8: e1a00004 mov r0, r4 3000b5ac: eafffffa b 3000b59c <rtems_task_restart+0x40>
3000e2b8 <rtems_task_resume>:
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_resume(
rtems_id id
)
{
3000e2b8: e92d4010 push {r4, lr}
3000e2bc: e24dd004 sub sp, sp, #4
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000e2c0: e1a0100d mov r1, sp 3000e2c4: eb00090b bl 300106f8 <_Thread_Get>
switch ( location ) {
3000e2c8: e59d4000 ldr r4, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000e2cc: e1a03000 mov r3, r0
switch ( location ) {
3000e2d0: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000e2d4: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000e2d8: 1a000004 bne 3000e2f0 <rtems_task_resume+0x38>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000e2dc: e5933010 ldr r3, [r3, #16]
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
3000e2e0: e3130002 tst r3, #2
3000e2e4: 1a000003 bne 3000e2f8 <rtems_task_resume+0x40>
_Thread_Resume( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000e2e8: eb0008fa bl 300106d8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000e2ec: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000e2f0: e28dd004 add sp, sp, #4
3000e2f4: e8bd8010 pop {r4, pc}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
_Thread_Resume( the_thread );
3000e2f8: e3a01002 mov r1, #2 3000e2fc: eb000800 bl 30010304 <_Thread_Clear_state>
_Thread_Enable_dispatch();
3000e300: eb0008f4 bl 300106d8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000e304: e1a00004 mov r0, r4 3000e308: eafffff8 b 3000e2f0 <rtems_task_resume+0x38>
3000cb20 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000cb20: e92d4030 push {r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000cb24: e59f3094 ldr r3, [pc, #148] ; 3000cbc0 <rtems_task_set_note+0xa0>
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000cb28: e1a0c000 mov ip, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000cb2c: e5d33004 ldrb r3, [r3, #4]
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000cb30: e24dd008 sub sp, sp, #8
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000cb34: e3530000 cmp r3, #0
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000cb38: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
3000cb3c: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000cb40: 1a000001 bne 3000cb4c <rtems_task_set_note+0x2c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000cb44: e28dd008 add sp, sp, #8
3000cb48: e8bd8030 pop {r4, r5, pc}
/*
* 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 )
3000cb4c: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000cb50: 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 )
3000cb54: 8afffffa bhi 3000cb44 <rtems_task_set_note+0x24>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000cb58: e59f3064 ldr r3, [pc, #100] ; 3000cbc4 <rtems_task_set_note+0xa4> 3000cb5c: e35c0000 cmp ip, #0 3000cb60: e5933008 ldr r3, [r3, #8]
3000cb64: 0a000010 beq 3000cbac <rtems_task_set_note+0x8c>
3000cb68: e5931008 ldr r1, [r3, #8] 3000cb6c: e15c0001 cmp ip, r1
3000cb70: 0a00000d beq 3000cbac <rtems_task_set_note+0x8c>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
3000cb74: e28d1004 add r1, sp, #4 3000cb78: e58d2000 str r2, [sp] 3000cb7c: eb00099e bl 3000f1fc <_Thread_Get>
switch ( location ) {
3000cb80: e59d5004 ldr r5, [sp, #4] 3000cb84: e59d2000 ldr r2, [sp] 3000cb88: e3550000 cmp r5, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000cb8c: 13a00004 movne r0, #4
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000cb90: 1affffeb bne 3000cb44 <rtems_task_set_note+0x24>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
3000cb94: e59030f0 ldr r3, [r0, #240] ; 0xf0 3000cb98: e2844008 add r4, r4, #8 3000cb9c: e7832104 str r2, [r3, r4, lsl #2]
_Thread_Enable_dispatch();
3000cba0: eb00098d bl 3000f1dc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000cba4: e1a00005 mov r0, r5 3000cba8: eaffffe5 b 3000cb44 <rtems_task_set_note+0x24>
*/
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;
3000cbac: e59330f0 ldr r3, [r3, #240] ; 0xf0 <== NOT EXECUTED 3000cbb0: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000cbb4: e7832104 str r2, [r3, r4, lsl #2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000cbb8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cbbc: eaffffe0 b 3000cb44 <rtems_task_set_note+0x24> <== NOT EXECUTED
3000f080 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
3000f080: e92d4030 push {r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000f084: 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
)
{
3000f088: e24dd004 sub sp, sp, #4 3000f08c: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000f090: 0a000004 beq 3000f0a8 <rtems_task_set_priority+0x28>
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 ) );
3000f094: e59f3078 ldr r3, [pc, #120] ; 3000f114 <rtems_task_set_priority+0x94> 3000f098: e5d33000 ldrb r3, [r3]
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
3000f09c: e1540003 cmp r4, r3
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
3000f0a0: 83a00013 movhi r0, #19
3000f0a4: 8a000018 bhi 3000f10c <rtems_task_set_priority+0x8c>
if ( !old_priority )
3000f0a8: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000f0ac: 03a00009 moveq r0, #9
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
3000f0b0: 0a000015 beq 3000f10c <rtems_task_set_priority+0x8c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
3000f0b4: e1a0100d mov r1, sp 3000f0b8: eb000967 bl 3001165c <_Thread_Get>
switch ( location ) {
3000f0bc: e59d3000 ldr r3, [sp] 3000f0c0: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000f0c4: 13a00004 movne r0, #4
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000f0c8: 1a00000f bne 3000f10c <rtems_task_set_priority+0x8c>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
3000f0cc: e5903014 ldr r3, [r0, #20]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000f0d0: 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;
3000f0d4: e5853000 str r3, [r5]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000f0d8: 0a000009 beq 3000f104 <rtems_task_set_priority+0x84>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
3000f0dc: 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;
3000f0e0: e5804018 str r4, [r0, #24]
if ( the_thread->resource_count == 0 ||
3000f0e4: e3530000 cmp r3, #0
3000f0e8: 0a000002 beq 3000f0f8 <rtems_task_set_priority+0x78>
3000f0ec: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000f0f0: e1540003 cmp r4, r3 <== NOT EXECUTED 3000f0f4: 2a000002 bcs 3000f104 <rtems_task_set_priority+0x84> <== NOT EXECUTED
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
3000f0f8: e1a01004 mov r1, r4 3000f0fc: e3a02000 mov r2, #0 3000f100: eb00081a bl 30011170 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
3000f104: eb00094c bl 3001163c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000f108: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000f10c: e28dd004 add sp, sp, #4
3000f110: e8bd8030 pop {r4, r5, pc}
3000ad50 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
3000ad50: e92d4070 push {r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
3000ad54: e2516000 subs r6, r1, #0
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
3000ad58: e24dd008 sub sp, sp, #8 3000ad5c: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
3000ad60: 03a00009 moveq r0, #9
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
3000ad64: 0a00000e beq 3000ada4 <rtems_task_start+0x54>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
3000ad68: e28d1004 add r1, sp, #4 3000ad6c: eb0008f9 bl 3000d158 <_Thread_Get>
switch ( location ) {
3000ad70: e59d4004 ldr r4, [sp, #4] 3000ad74: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000ad78: 13a00004 movne r0, #4
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000ad7c: 1a000008 bne 3000ada4 <rtems_task_start+0x54>
case OBJECTS_LOCAL:
if ( _Thread_Start(
3000ad80: e1a01004 mov r1, r4 3000ad84: e1a02006 mov r2, r6 3000ad88: e1a03004 mov r3, r4 3000ad8c: e58d5000 str r5, [sp] 3000ad90: eb000b5f bl 3000db14 <_Thread_Start> 3000ad94: e3500000 cmp r0, #0
3000ad98: 1a000003 bne 3000adac <rtems_task_start+0x5c>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000ad9c: eb0008e5 bl 3000d138 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000ada0: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000ada4: e28dd008 add sp, sp, #8
3000ada8: e8bd8070 pop {r4, r5, r6, pc}
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
3000adac: eb0008e1 bl 3000d138 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000adb0: e1a00004 mov r0, r4 3000adb4: eafffffa b 3000ada4 <rtems_task_start+0x54>
3000e578 <rtems_task_suspend>:
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
3000e578: e92d4010 push {r4, lr}
3000e57c: e24dd004 sub sp, sp, #4
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000e580: e1a0100d mov r1, sp 3000e584: eb0008d7 bl 300108e8 <_Thread_Get>
switch ( location ) {
3000e588: e59d3000 ldr r3, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000e58c: e1a02000 mov r2, r0
switch ( location ) {
3000e590: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000e594: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000e598: 1a000004 bne 3000e5b0 <rtems_task_suspend+0x38>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000e59c: e5924010 ldr r4, [r2, #16]
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
3000e5a0: e2144002 ands r4, r4, #2
3000e5a4: 0a000003 beq 3000e5b8 <rtems_task_suspend+0x40>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000e5a8: eb0008c6 bl 300108c8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
3000e5ac: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000e5b0: e28dd004 add sp, sp, #4
3000e5b4: e8bd8010 pop {r4, pc}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Suspend( the_thread );
3000e5b8: e3a01002 mov r1, #2 3000e5bc: eb000aed bl 30011178 <_Thread_Set_state>
_Thread_Enable_dispatch();
3000e5c0: eb0008c0 bl 300108c8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000e5c4: e1a00004 mov r0, r4 3000e5c8: eafffff8 b 3000e5b0 <rtems_task_suspend+0x38>
3000962c <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
3000962c: e92d4070 push {r4, r5, r6, lr}
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
30009630: e2514000 subs r4, r1, #0
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
30009634: e24dd004 sub sp, sp, #4 30009638: e1a05002 mov r5, r2
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
3000963c: 03a00009 moveq r0, #9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
30009640: 0a000013 beq 30009694 <rtems_task_variable_add+0x68>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
30009644: e1a0100d mov r1, sp 30009648: eb000823 bl 3000b6dc <_Thread_Get>
switch (location) {
3000964c: e59d3000 ldr r3, [sp]
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
30009650: e1a06000 mov r6, r0
switch (location) {
30009654: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009658: 13a00004 movne r0, #4
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000965c: 1a00000c bne 30009694 <rtems_task_variable_add+0x68>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
30009660: e59630fc ldr r3, [r6, #252] ; 0xfc
while (tvp) {
30009664: e3530000 cmp r3, #0
30009668: 1a000003 bne 3000967c <rtems_task_variable_add+0x50>
3000966c: ea00000a b 3000969c <rtems_task_variable_add+0x70>
if (tvp->ptr == ptr) {
tvp->dtor = dtor;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
30009670: e5933000 ldr r3, [r3] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
30009674: e3530000 cmp r3, #0 <== NOT EXECUTED 30009678: 0a000007 beq 3000969c <rtems_task_variable_add+0x70> <== NOT EXECUTED
if (tvp->ptr == ptr) {
3000967c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30009680: e1520004 cmp r2, r4 <== NOT EXECUTED 30009684: 1afffff9 bne 30009670 <rtems_task_variable_add+0x44> <== NOT EXECUTED
tvp->dtor = dtor;
30009688: e5835010 str r5, [r3, #16] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000968c: eb00080a bl 3000b6bc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30009690: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30009694: e28dd004 add sp, sp, #4
30009698: e8bd8070 pop {r4, r5, r6, pc}
}
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
3000969c: e3a00014 mov r0, #20 300096a0: eb000c0b bl 3000c6d4 <_Workspace_Allocate>
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
300096a4: e3500000 cmp r0, #0
300096a8: 0a000009 beq 300096d4 <rtems_task_variable_add+0xa8>
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
300096ac: e5942000 ldr r2, [r4]
new->ptr = ptr;
new->dtor = dtor;
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
300096b0: e59630fc ldr r3, [r6, #252] ; 0xfc
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
300096b4: e5802008 str r2, [r0, #8]
new->ptr = ptr;
300096b8: e5804004 str r4, [r0, #4]
new->dtor = dtor;
300096bc: e5805010 str r5, [r0, #16]
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
300096c0: e5803000 str r3, [r0]
the_thread->task_variables = new;
300096c4: e58600fc str r0, [r6, #252] ; 0xfc
_Thread_Enable_dispatch();
300096c8: eb0007fb bl 3000b6bc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300096cc: e3a00000 mov r0, #0 300096d0: eaffffef b 30009694 <rtems_task_variable_add+0x68>
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
300096d4: eb0007f8 bl 3000b6bc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
300096d8: e3a0001a mov r0, #26 <== NOT EXECUTED 300096dc: eaffffec b 30009694 <rtems_task_variable_add+0x68> <== NOT EXECUTED
300096e0 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
300096e0: e92d4010 push {r4, lr}
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
300096e4: e2514000 subs r4, r1, #0
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
300096e8: e24dd004 sub sp, sp, #4
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
300096ec: 03a00009 moveq r0, #9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
300096f0: 0a000015 beq 3000974c <rtems_task_variable_delete+0x6c>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
300096f4: e1a0100d mov r1, sp 300096f8: eb0007f7 bl 3000b6dc <_Thread_Get>
switch (location) {
300096fc: e59d3000 ldr r3, [sp] 30009700: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009704: 13a00004 movne r0, #4
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
switch (location) {
30009708: 1a00000f bne 3000974c <rtems_task_variable_delete+0x6c>
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
3000970c: e59030fc ldr r3, [r0, #252] ; 0xfc
while (tvp) {
30009710: e3530000 cmp r3, #0
30009714: 0a00000a beq 30009744 <rtems_task_variable_delete+0x64>
if (tvp->ptr == ptr) {
30009718: e5932004 ldr r2, [r3, #4] 3000971c: e1520004 cmp r2, r4
30009720: 1a000004 bne 30009738 <rtems_task_variable_delete+0x58>
30009724: ea000010 b 3000976c <rtems_task_variable_delete+0x8c>
30009728: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED 3000972c: e1520004 cmp r2, r4 <== NOT EXECUTED 30009730: 0a000007 beq 30009754 <rtems_task_variable_delete+0x74> <== NOT EXECUTED 30009734: e1a03001 mov r3, r1 <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
30009738: e5931000 ldr r1, [r3] <== NOT EXECUTED
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
3000973c: e3510000 cmp r1, #0 <== NOT EXECUTED 30009740: 1afffff8 bne 30009728 <rtems_task_variable_delete+0x48> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
30009744: eb0007dc bl 3000b6bc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30009748: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000974c: e28dd004 add sp, sp, #4
30009750: e8bd8010 pop {r4, pc}
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
30009754: e5912000 ldr r2, [r1] <== NOT EXECUTED 30009758: e5832000 str r2, [r3] <== NOT EXECUTED
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
3000975c: eb000028 bl 30009804 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
30009760: eb0007d5 bl 3000b6bc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009764: e3a00000 mov r0, #0 30009768: eafffff7 b 3000974c <rtems_task_variable_delete+0x6c>
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
3000976c: e5932000 ldr r2, [r3] 30009770: e1a01003 mov r1, r3 30009774: e58020fc str r2, [r0, #252] ; 0xfc 30009778: eafffff7 b 3000975c <rtems_task_variable_delete+0x7c>
3000977c <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
3000977c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
30009780: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
30009784: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30009788: e1a05002 mov r5, r2 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
3000978c: 0a000016 beq 300097ec <rtems_task_variable_get+0x70> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !result )
30009790: e3520000 cmp r2, #0 <== NOT EXECUTED 30009794: 0a000014 beq 300097ec <rtems_task_variable_get+0x70> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
30009798: e1a0100d mov r1, sp <== NOT EXECUTED 3000979c: eb0007ce bl 3000b6dc <_Thread_Get> <== NOT EXECUTED
switch (location) {
300097a0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300097a4: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300097a8: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !result )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
300097ac: 1a00000f bne 300097f0 <rtems_task_variable_get+0x74> <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
300097b0: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED
while (tvp) {
300097b4: e3530000 cmp r3, #0 <== NOT EXECUTED 300097b8: 1a000003 bne 300097cc <rtems_task_variable_get+0x50> <== NOT EXECUTED 300097bc: ea00000d b 300097f8 <rtems_task_variable_get+0x7c> <== NOT EXECUTED
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
300097c0: 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) {
300097c4: e3530000 cmp r3, #0 <== NOT EXECUTED 300097c8: 0a00000a beq 300097f8 <rtems_task_variable_get+0x7c> <== NOT EXECUTED
if (tvp->ptr == ptr) {
300097cc: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 300097d0: e1520004 cmp r2, r4 <== NOT EXECUTED 300097d4: 1afffff9 bne 300097c0 <rtems_task_variable_get+0x44> <== NOT EXECUTED
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
300097d8: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 300097dc: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
300097e0: eb0007b5 bl 3000b6bc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300097e4: e3a00000 mov r0, #0 <== NOT EXECUTED 300097e8: ea000000 b 300097f0 <rtems_task_variable_get+0x74> <== NOT EXECUTED
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
300097ec: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300097f0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300097f4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
300097f8: eb0007af bl 3000b6bc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
300097fc: e3a00009 mov r0, #9 <== NOT EXECUTED 30009800: eafffffa b 300097f0 <rtems_task_variable_get+0x74> <== NOT EXECUTED
3000adb8 <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;
3000adb8: e59f307c ldr r3, [pc, #124] ; 3000ae3c <rtems_task_wake_after+0x84>
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_wake_after(
rtems_interval ticks
)
{
3000adbc: e92d4030 push {r4, r5, lr}
3000adc0: e5932000 ldr r2, [r3]
3000adc4: e1a04000 mov r4, r0
++level;
3000adc8: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000adcc: e5832000 str r2, [r3]
_Thread_Disable_dispatch();
if ( ticks == 0 ) {
3000add0: e3500000 cmp r0, #0
3000add4: 0a000012 beq 3000ae24 <rtems_task_wake_after+0x6c>
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
3000add8: e59f5060 ldr r5, [pc, #96] ; 3000ae40 <rtems_task_wake_after+0x88><== NOT EXECUTED 3000addc: e3a01008 mov r1, #8 <== NOT EXECUTED 3000ade0: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED 3000ade4: eb000aff bl 3000d9e8 <_Thread_Set_state> <== NOT EXECUTED
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3000ade8: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000adec: e59f0050 ldr r0, [pc, #80] ; 3000ae44 <rtems_task_wake_after+0x8c><== NOT EXECUTED
_Thread_Disable_dispatch();
if ( ticks == 0 ) {
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
_Watchdog_Initialize(
3000adf0: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000adf4: e3a03000 mov r3, #0 <== NOT EXECUTED 3000adf8: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id;
3000adfc: e5812068 str r2, [r1, #104] ; 0x68 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000ae00: e581306c str r3, [r1, #108] ; 0x6c <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000ae04: e5810064 str r0, [r1, #100] ; 0x64 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000ae08: e5814054 str r4, [r1, #84] ; 0x54 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ae0c: e59f0034 ldr r0, [pc, #52] ; 3000ae48 <rtems_task_wake_after+0x90><== NOT EXECUTED 3000ae10: e2811048 add r1, r1, #72 ; 0x48 <== NOT EXECUTED 3000ae14: eb000bd8 bl 3000dd7c <_Watchdog_Insert> <== NOT EXECUTED
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
3000ae18: eb0008c6 bl 3000d138 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL; }
3000ae1c: e3a00000 mov r0, #0 <== NOT EXECUTED
3000ae20: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
3000ae24: e59f3020 ldr r3, [pc, #32] ; 3000ae4c <rtems_task_wake_after+0x94> 3000ae28: e1a0e00f mov lr, pc 3000ae2c: e593f00c ldr pc, [r3, #12]
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
3000ae30: eb0008c0 bl 3000d138 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL; }
3000ae34: e3a00000 mov r0, #0
3000ae38: e8bd8030 pop {r4, r5, pc}
3000bb24 <rtems_task_wake_when>:
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000bb24: e92d40f0 push {r4, r5, r6, r7, lr}
Watchdog_Interval seconds;
if ( !_TOD.is_set )
3000bb28: e59f40cc ldr r4, [pc, #204] ; 3000bbfc <rtems_task_wake_when+0xd8>
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000bb2c: e1a06000 mov r6, r0
Watchdog_Interval seconds;
if ( !_TOD.is_set )
3000bb30: e5d43014 ldrb r3, [r4, #20] 3000bb34: e3530000 cmp r3, #0
return RTEMS_NOT_DEFINED;
3000bb38: 03a0000b moveq r0, #11
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD.is_set )
3000bb3c: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000bb40: e3560000 cmp r6, #0
return RTEMS_INVALID_ADDRESS;
3000bb44: 03a00009 moveq r0, #9
Watchdog_Interval seconds;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000bb48: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
3000bb4c: e3a05000 mov r5, #0 3000bb50: e5865018 str r5, [r6, #24]
if ( !_TOD_Validate( time_buffer ) )
3000bb54: ebfffcd3 bl 3000aea8 <_TOD_Validate> 3000bb58: e1500005 cmp r0, r5
return RTEMS_INVALID_CLOCK;
3000bb5c: 03a00014 moveq r0, #20
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
3000bb60: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
3000bb64: e1a00006 mov r0, r6 3000bb68: ebfffc9f bl 3000adec <_TOD_To_seconds>
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
3000bb6c: e59f208c ldr r2, [pc, #140] ; 3000bc00 <rtems_task_wake_when+0xdc>
3000bb70: e1a06000 mov r6, r0
3000bb74: e3a03000 mov r3, #0
3000bb78: e8940003 ldm r4, {r0, r1}
3000bb7c: eb0047e5 bl 3001db18 <__divdi3>
if ( seconds <= _TOD_Seconds_since_epoch() )
3000bb80: e1560000 cmp r6, r0
3000bb84: 8a000001 bhi 3000bb90 <rtems_task_wake_when+0x6c>
return RTEMS_INVALID_CLOCK;
3000bb88: e3a00014 mov r0, #20 <== NOT EXECUTED
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000bb8c: e8bd80f0 pop {r4, r5, r6, r7, 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;
3000bb90: e59f306c ldr r3, [pc, #108] ; 3000bc04 <rtems_task_wake_when+0xe0> 3000bb94: e5932000 ldr r2, [r3]
++level;
3000bb98: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000bb9c: e5832000 str r2, [r3]
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
3000bba0: e59f7060 ldr r7, [pc, #96] ; 3000bc08 <rtems_task_wake_when+0xe4>
3000bba4: e3a01010 mov r1, #16
3000bba8: e5970008 ldr r0, [r7, #8]
3000bbac: eb000b2e bl 3000e86c <_Thread_Set_state>
3000bbb0: e8940003 ldm r4, {r0, r1}
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3000bbb4: e5974008 ldr r4, [r7, #8]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000bbb8: e59fe04c ldr lr, [pc, #76] ; 3000bc0c <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(
3000bbbc: e594c008 ldr ip, [r4, #8] 3000bbc0: e59f2038 ldr r2, [pc, #56] ; 3000bc00 <rtems_task_wake_when+0xdc> 3000bbc4: e3a03000 mov r3, #0 3000bbc8: e584e064 str lr, [r4, #100] ; 0x64
the_watchdog->id = id;
3000bbcc: e584c068 str ip, [r4, #104] ; 0x68
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000bbd0: e5845050 str r5, [r4, #80] ; 0x50
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3000bbd4: e584506c str r5, [r4, #108] ; 0x6c 3000bbd8: eb0047ce bl 3001db18 <__divdi3>
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
3000bbdc: e0606006 rsb r6, r0, r6
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000bbe0: e2841048 add r1, r4, #72 ; 0x48 3000bbe4: e59f0024 ldr r0, [pc, #36] ; 3000bc10 <rtems_task_wake_when+0xec>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000bbe8: e5846054 str r6, [r4, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000bbec: eb000c31 bl 3000ecb8 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3000bbf0: eb0008f1 bl 3000dfbc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000bbf4: e1a00005 mov r0, r5 <== NOT EXECUTED
3000bbf8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000add8 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
3000add8: e92d4030 push {r4, r5, lr}
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
3000addc: e2504000 subs r4, r0, #0
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
3000ade0: e24dd004 sub sp, sp, #4
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000ade4: 03a00003 moveq r0, #3
rtems_id *id
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
3000ade8: 1a000001 bne 3000adf4 <rtems_timer_create+0x1c>
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000adec: e28dd004 add sp, sp, #4
3000adf0: e8bd8030 pop {r4, r5, pc}
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
3000adf4: e3510000 cmp r1, #0
return RTEMS_INVALID_ADDRESS;
3000adf8: 03a00009 moveq r0, #9
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
3000adfc: 0afffffa beq 3000adec <rtems_timer_create+0x14>
*
* 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;
3000ae00: e59f3070 ldr r3, [pc, #112] ; 3000ae78 <rtems_timer_create+0xa0> 3000ae04: e5932000 ldr r2, [r3]
++level;
3000ae08: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000ae0c: 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 );
3000ae10: e59f5064 ldr r5, [pc, #100] ; 3000ae7c <rtems_timer_create+0xa4> 3000ae14: e58d1000 str r1, [sp] 3000ae18: e1a00005 mov r0, r5 3000ae1c: eb000405 bl 3000be38 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
3000ae20: e3500000 cmp r0, #0 3000ae24: e59d1000 ldr r1, [sp]
3000ae28: 0a00000f beq 3000ae6c <rtems_timer_create+0x94>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000ae2c: e5903008 ldr r3, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ae30: e595201c ldr r2, [r5, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000ae34: e1a0c803 lsl ip, r3, #16
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000ae38: e3a05000 mov r5, #0
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
3000ae3c: e3a0e004 mov lr, #4 3000ae40: e580e038 str lr, [r0, #56] ; 0x38 3000ae44: e5805018 str r5, [r0, #24]
the_watchdog->routine = routine;
3000ae48: e580502c str r5, [r0, #44] ; 0x2c
the_watchdog->id = id;
3000ae4c: e5805030 str r5, [r0, #48] ; 0x30
the_watchdog->user_data = user_data;
3000ae50: e5805034 str r5, [r0, #52] ; 0x34
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ae54: e782072c str r0, [r2, ip, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000ae58: e580400c str r4, [r0, #12]
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
3000ae5c: e5813000 str r3, [r1]
_Thread_Enable_dispatch();
3000ae60: eb0008d1 bl 3000d1ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ae64: e1a00005 mov r0, r5 3000ae68: eaffffdf b 3000adec <rtems_timer_create+0x14>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
3000ae6c: eb0008ce bl 3000d1ac <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000ae70: e3a00005 mov r0, #5 <== NOT EXECUTED 3000ae74: eaffffdc b 3000adec <rtems_timer_create+0x14> <== NOT EXECUTED
3000ae80 <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3000ae80: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
3000ae84: e2516000 subs r6, r1, #0
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3000ae88: e1a05000 mov r5, r0 3000ae8c: e24dd004 sub sp, sp, #4 3000ae90: e1a04002 mov r4, r2 3000ae94: e1a07003 mov r7, r3
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
3000ae98: 03a0000a moveq r0, #10
{
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
3000ae9c: 1a000001 bne 3000aea8 <rtems_timer_fire_after+0x28>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000aea0: e28dd004 add sp, sp, #4
3000aea4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
3000aea8: e3520000 cmp r2, #0
return RTEMS_INVALID_ADDRESS;
3000aeac: 03a00009 moveq r0, #9
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
3000aeb0: 0afffffa beq 3000aea0 <rtems_timer_fire_after+0x20>
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
3000aeb4: e59f0084 ldr r0, [pc, #132] ; 3000af40 <rtems_timer_fire_after+0xc0> 3000aeb8: e1a01005 mov r1, r5 3000aebc: e1a0200d mov r2, sp 3000aec0: eb000511 bl 3000c30c <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3000aec4: e59d3000 ldr r3, [sp] 3000aec8: e1a08000 mov r8, r0 3000aecc: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000aed0: 13a00004 movne r0, #4
if ( !routine )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3000aed4: 1afffff1 bne 3000aea0 <rtems_timer_fire_after+0x20>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3000aed8: e288a010 add sl, r8, #16 3000aedc: e1a0000a mov r0, sl 3000aee0: eb000c2f bl 3000dfa4 <_Watchdog_Remove>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000aee4: e10f2000 mrs r2, CPSR 3000aee8: e3823080 orr r3, r2, #128 ; 0x80 3000aeec: 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 ) {
3000aef0: e5983018 ldr r3, [r8, #24] 3000aef4: e3530000 cmp r3, #0
3000aef8: 1a00000c bne 3000af30 <rtems_timer_fire_after+0xb0>
/*
* 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;
3000aefc: e5883038 str r3, [r8, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000af00: e5883018 str r3, [r8, #24]
the_watchdog->routine = routine;
3000af04: e588402c str r4, [r8, #44] ; 0x2c
the_watchdog->id = id;
3000af08: e5885030 str r5, [r8, #48] ; 0x30
the_watchdog->user_data = user_data;
3000af0c: e5887034 str r7, [r8, #52] ; 0x34
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000af10: e129f002 msr CPSR_fc, r2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000af14: e59f0028 ldr r0, [pc, #40] ; 3000af44 <rtems_timer_fire_after+0xc4> 3000af18: e1a0100a mov r1, sl
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000af1c: e588601c str r6, [r8, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000af20: eb000bb2 bl 3000ddf0 <_Watchdog_Insert>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
3000af24: eb0008a0 bl 3000d1ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000af28: e3a00000 mov r0, #0 3000af2c: eaffffdb b 3000aea0 <rtems_timer_fire_after+0x20>
3000af30: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
_Thread_Enable_dispatch();
3000af34: eb00089c bl 3000d1ac <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000af38: e3a00000 mov r0, #0 <== NOT EXECUTED 3000af3c: eaffffd7 b 3000aea0 <rtems_timer_fire_after+0x20> <== NOT EXECUTED
3001aab4 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001aab4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
3001aab8: e59f40ec ldr r4, [pc, #236] ; 3001abac <rtems_timer_fire_when+0xf8>
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001aabc: e1a06000 mov r6, r0
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
3001aac0: e5d4c014 ldrb ip, [r4, #20]
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001aac4: e24dd008 sub sp, sp, #8
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
3001aac8: e35c0000 cmp ip, #0
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001aacc: e1a05002 mov r5, r2 3001aad0: e1a07003 mov r7, r3
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
3001aad4: 03a0000b moveq r0, #11
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
3001aad8: 1a000001 bne 3001aae4 <rtems_timer_fire_when+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001aadc: e28dd008 add sp, sp, #8
3001aae0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_interval seconds;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
3001aae4: e1a00001 mov r0, r1 3001aae8: e58d1000 str r1, [sp] 3001aaec: ebfff43b bl 30017be0 <_TOD_Validate> 3001aaf0: e3500000 cmp r0, #0 3001aaf4: e59d1000 ldr r1, [sp]
3001aaf8: 1a000001 bne 3001ab04 <rtems_timer_fire_when+0x50>
if ( !routine )
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
3001aafc: e3a00014 mov r0, #20 <== NOT EXECUTED 3001ab00: eafffff5 b 3001aadc <rtems_timer_fire_when+0x28> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
3001ab04: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3001ab08: 03a00009 moveq r0, #9
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
3001ab0c: 0afffff2 beq 3001aadc <rtems_timer_fire_when+0x28>
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
3001ab10: e1a00001 mov r0, r1
3001ab14: ebfff402 bl 30017b24 <_TOD_To_seconds>
3001ab18: e59f2090 ldr r2, [pc, #144] ; 3001abb0 <rtems_timer_fire_when+0xfc>
3001ab1c: e1a08000 mov r8, r0
3001ab20: e3a03000 mov r3, #0
3001ab24: e8940003 ldm r4, {r0, r1}
3001ab28: eb005277 bl 3002f50c <__divdi3>
if ( seconds <= _TOD_Seconds_since_epoch() )
3001ab2c: e1580000 cmp r8, r0
3001ab30: 9afffff1 bls 3001aafc <rtems_timer_fire_when+0x48>
3001ab34: e59f0078 ldr r0, [pc, #120] ; 3001abb4 <rtems_timer_fire_when+0x100> 3001ab38: e1a01006 mov r1, r6 3001ab3c: e28d2004 add r2, sp, #4 3001ab40: eb000bb7 bl 3001da24 <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001ab44: e59d9004 ldr r9, [sp, #4] 3001ab48: e1a0a000 mov sl, r0 3001ab4c: e3590000 cmp r9, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001ab50: 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 ) {
3001ab54: 1affffe0 bne 3001aadc <rtems_timer_fire_when+0x28>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001ab58: e28ab010 add fp, sl, #16
3001ab5c: e1a0000b mov r0, fp
3001ab60: eb00136b bl 3001f914 <_Watchdog_Remove>
3001ab64: e8940003 ldm r4, {r0, r1}
the_timer->the_class = TIMER_TIME_OF_DAY;
3001ab68: e3a0c002 mov ip, #2 3001ab6c: e59f203c ldr r2, [pc, #60] ; 3001abb0 <rtems_timer_fire_when+0xfc> 3001ab70: e3a03000 mov r3, #0 3001ab74: e58ac038 str ip, [sl, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001ab78: e58a9018 str r9, [sl, #24]
the_watchdog->routine = routine;
3001ab7c: e58a502c str r5, [sl, #44] ; 0x2c
the_watchdog->id = id;
3001ab80: e58a6030 str r6, [sl, #48] ; 0x30
the_watchdog->user_data = user_data;
3001ab84: e58a7034 str r7, [sl, #52] ; 0x34 3001ab88: eb00525f bl 3002f50c <__divdi3>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
3001ab8c: e0608008 rsb r8, r0, r8
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001ab90: e1a0100b mov r1, fp 3001ab94: e59f001c ldr r0, [pc, #28] ; 3001abb8 <rtems_timer_fire_when+0x104>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001ab98: e58a801c str r8, [sl, #28]
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001ab9c: eb0012ef bl 3001f760 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3001aba0: eb000f68 bl 3001e948 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3001aba4: e1a00009 mov r0, r9 3001aba8: eaffffcb b 3001aadc <rtems_timer_fire_when+0x28>
3001abbc <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
3001abbc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
3001abc0: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
3001abc4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3001abc8: e1a01000 mov r1, r0 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
3001abcc: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
3001abd0: 0a00000e beq 3001ac10 <rtems_timer_get_information+0x54> <== NOT EXECUTED 3001abd4: e59f003c ldr r0, [pc, #60] ; 3001ac18 <rtems_timer_get_information+0x5c><== NOT EXECUTED 3001abd8: e1a0200d mov r2, sp <== NOT EXECUTED 3001abdc: eb000b90 bl 3001da24 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001abe0: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3001abe4: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001abe8: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001abec: 1a000007 bne 3001ac10 <rtems_timer_get_information+0x54> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
3001abf0: e590c038 ldr ip, [r0, #56] ; 0x38 <== NOT EXECUTED
the_info->initial = the_timer->Ticker.initial;
3001abf4: e590101c ldr r1, [r0, #28] <== NOT EXECUTED
the_info->start_time = the_timer->Ticker.start_time;
3001abf8: e5902024 ldr r2, [r0, #36] ; 0x24 <== NOT EXECUTED
the_info->stop_time = the_timer->Ticker.stop_time;
3001abfc: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
3001ac00: e584c000 str ip, [r4] <== NOT EXECUTED
the_info->initial = the_timer->Ticker.initial;
the_info->start_time = the_timer->Ticker.start_time;
the_info->stop_time = the_timer->Ticker.stop_time;
3001ac04: e984000e stmib r4, {r1, r2, r3} <== NOT EXECUTED
_Thread_Enable_dispatch();
3001ac08: eb000f4e bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001ac0c: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001ac10: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001ac14: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001b314 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
3001b314: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3001b318: e3500000 cmp r0, #0 <== NOT EXECUTED
3001b31c: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
3001b320: e1a04001 mov r4, r1 <== NOT EXECUTED
3001b324: e1a08002 mov r8, r2 <== NOT EXECUTED
3001b328: 0a000051 beq 3001b474 <rtems_timer_initiate_server+0x160> <== NOT EXECUTED
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
3001b32c: e59f3150 ldr r3, [pc, #336] ; 3001b484 <rtems_timer_initiate_server+0x170><== NOT EXECUTED 3001b330: e5d33000 ldrb r3, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
3001b334: e1500003 cmp r0, r3 <== NOT EXECUTED 3001b338: 8a00004a bhi 3001b468 <rtems_timer_initiate_server+0x154> <== NOT EXECUTED 3001b33c: 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;
3001b340: e59f3140 ldr r3, [pc, #320] ; 3001b488 <rtems_timer_initiate_server+0x174><== NOT EXECUTED 3001b344: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3001b348: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3001b34c: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
3001b350: e59f5134 ldr r5, [pc, #308] ; 3001b48c <rtems_timer_initiate_server+0x178><== NOT EXECUTED
initialized = true;
3001b354: e3a03001 mov r3, #1 <== NOT EXECUTED
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
3001b358: e5d56000 ldrb r6, [r5] <== NOT EXECUTED
initialized = true;
3001b35c: e5c53000 strb r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
3001b360: eb000d78 bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( tmpInitialized )
3001b364: e3560000 cmp r6, #0 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3001b368: 13a0400e movne r4, #14 <== NOT EXECUTED
_Thread_Disable_dispatch();
tmpInitialized = initialized;
initialized = true;
_Thread_Enable_dispatch();
if ( tmpInitialized )
3001b36c: 1a000041 bne 3001b478 <rtems_timer_initiate_server+0x164> <== 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(
3001b370: e388c902 orr ip, r8, #32768 ; 0x8000 <== NOT EXECUTED 3001b374: e1a02004 mov r2, r4 <== NOT EXECUTED 3001b378: e58dc000 str ip, [sp] <== NOT EXECUTED 3001b37c: e59f010c ldr r0, [pc, #268] ; 3001b490 <rtems_timer_initiate_server+0x17c><== NOT EXECUTED 3001b380: e28dc00c add ip, sp, #12 <== NOT EXECUTED 3001b384: e1a01007 mov r1, r7 <== NOT EXECUTED 3001b388: e3a03c01 mov r3, #256 ; 0x100 <== NOT EXECUTED 3001b38c: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3001b390: ebfffae9 bl 30019f3c <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) {
3001b394: e2504000 subs r4, r0, #0 <== NOT EXECUTED
initialized = false;
3001b398: 15c56000 strbne r6, [r5] <== 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) {
3001b39c: 1a000035 bne 3001b478 <rtems_timer_initiate_server+0x164> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3001b3a0: e59f30ec ldr r3, [pc, #236] ; 3001b494 <rtems_timer_initiate_server+0x180><== 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(
&_RTEMS_tasks_Information,
_Objects_Get_index(id)
3001b3a4: e59d800c ldr r8, [sp, #12] <== NOT EXECUTED 3001b3a8: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 3001b3ac: e1a02808 lsl r2, r8, #16 <== NOT EXECUTED 3001b3b0: e793b722 ldr fp, [r3, r2, lsr #14] <== 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;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001b3b4: e59f30dc ldr r3, [pc, #220] ; 3001b498 <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;
tail->previous = head;
3001b3b8: e285c06c add ip, r5, #108 ; 0x6c <== NOT EXECUTED 3001b3bc: e5933000 ldr r3, [r3] <== NOT EXECUTED 3001b3c0: e585c074 str ip, [r5, #116] ; 0x74 <== 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;
3001b3c4: e59fc0d0 ldr ip, [pc, #208] ; 3001b49c <rtems_timer_initiate_server+0x188><== NOT EXECUTED
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001b3c8: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3001b3cc: e59f10cc ldr r1, [pc, #204] ; 3001b4a0 <rtems_timer_initiate_server+0x18c><== 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(
3001b3d0: e1a0a005 mov sl, r5 <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3001b3d4: e59f90c8 ldr r9, [pc, #200] ; 3001b4a4 <rtems_timer_initiate_server+0x190><== 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;
3001b3d8: e585c008 str ip, [r5, #8] <== NOT EXECUTED
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001b3dc: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001b3e0: e285e070 add lr, r5, #112 ; 0x70 <== 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(
3001b3e4: e5aab004 str fp, [sl, #4]! <== NOT EXECUTED
3001b3e8: e59f20b8 ldr r2, [pc, #184] ; 3001b4a8 <rtems_timer_initiate_server+0x194><== NOT EXECUTED
3001b3ec: e3a03000 mov r3, #0 <== NOT EXECUTED
3001b3f0: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3001b3f4: e2857038 add r7, r5, #56 ; 0x38 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001b3f8: e2856034 add r6, r5, #52 ; 0x34 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3001b3fc: e5854038 str r4, [r5, #56] ; 0x38 <== NOT EXECUTED 3001b400: e5854070 str r4, [r5, #112] ; 0x70 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001b404: e5854014 str r4, [r5, #20] <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3001b408: e5854030 str r4, [r5, #48] ; 0x30 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001b40c: e585404c str r4, [r5, #76] ; 0x4c <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3001b410: e5854068 str r4, [r5, #104] ; 0x68 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001b414: e585e06c str lr, [r5, #108] ; 0x6c <== 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;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001b418: e585c040 str ip, [r5, #64] ; 0x40 <== NOT EXECUTED 3001b41c: e5857034 str r7, [r5, #52] ; 0x34 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001b420: e585603c str r6, [r5, #60] ; 0x3c <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3001b424: e5859028 str r9, [r5, #40] ; 0x28 <== NOT EXECUTED
the_watchdog->id = id;
3001b428: e585802c str r8, [r5, #44] ; 0x2c <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3001b42c: e5859060 str r9, [r5, #96] ; 0x60 <== NOT EXECUTED
the_watchdog->id = id;
3001b430: e5858064 str r8, [r5, #100] ; 0x64 <== NOT EXECUTED 3001b434: eb005034 bl 3002f50c <__divdi3> <== NOT EXECUTED 3001b438: e1a03000 mov r3, r0 <== NOT EXECUTED
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001b43c: e5853078 str r3, [r5, #120] ; 0x78 <== NOT EXECUTED
ts->active = false;
/*
* The default timer server is now available.
*/
_Timer_server = ts;
3001b440: e59f3064 ldr r3, [pc, #100] ; 3001b4ac <rtems_timer_initiate_server+0x198><== 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;
3001b444: e585407c str r4, [r5, #124] ; 0x7c <== NOT EXECUTED
_Timer_server = ts;
/*
* Start the timer server
*/
status = rtems_task_start(
3001b448: e1a00008 mov r0, r8 <== 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;
3001b44c: e5c54080 strb r4, [r5, #128] ; 0x80 <== NOT EXECUTED
_Timer_server = ts;
/*
* Start the timer server
*/
status = rtems_task_start(
3001b450: e59f1058 ldr r1, [pc, #88] ; 3001b4b0 <rtems_timer_initiate_server+0x19c><== NOT EXECUTED 3001b454: e1a0200a mov r2, sl <== NOT EXECUTED
ts->active = false;
/*
* The default timer server is now available.
*/
_Timer_server = ts;
3001b458: e583a000 str sl, [r3] <== NOT EXECUTED
/*
* Start the timer server
*/
status = rtems_task_start(
3001b45c: ebfffc7c bl 3001a654 <rtems_task_start> <== NOT EXECUTED 3001b460: e1a04000 mov r4, r0 <== NOT EXECUTED
if (status) {
initialized = false;
}
#endif
return status;
3001b464: ea000003 b 3001b478 <rtems_timer_initiate_server+0x164> <== 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 )
3001b468: e3700001 cmn r0, #1 <== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
_priority = 0;
3001b46c: 03a07000 moveq r7, #0 <== 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 )
3001b470: 0affffb2 beq 3001b340 <rtems_timer_initiate_server+0x2c> <== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
3001b474: e3a04013 mov r4, #19 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001b478: e1a00004 mov r0, r4 <== NOT EXECUTED
3001b47c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3001b480: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3001ac4c <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
3001ac4c: e92d4070 push {r4, r5, r6, lr}
3001ac50: e24dd004 sub sp, sp, #4
3001ac54: e1a01000 mov r1, r0
3001ac58: e1a0200d mov r2, sp
3001ac5c: e59f0088 ldr r0, [pc, #136] ; 3001acec <rtems_timer_reset+0xa0>
3001ac60: eb000b6f bl 3001da24 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001ac64: e59d4000 ldr r4, [sp] 3001ac68: e1a06000 mov r6, r0 3001ac6c: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001ac70: 13a05004 movne r5, #4
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001ac74: 1a000006 bne 3001ac94 <rtems_timer_reset+0x48>
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
3001ac78: e5905038 ldr r5, [r0, #56] ; 0x38 3001ac7c: e3550000 cmp r5, #0
3001ac80: 0a000006 beq 3001aca0 <rtems_timer_reset+0x54>
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001ac84: e3550001 cmp r5, #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;
3001ac88: 13a0500b movne r5, #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 ) {
3001ac8c: 0a00000b beq 3001acc0 <rtems_timer_reset+0x74> <== 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();
3001ac90: eb000f2c bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001ac94: e1a00005 mov r0, r5
3001ac98: e28dd004 add sp, sp, #4
3001ac9c: e8bd8070 pop {r4, r5, r6, pc}
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
3001aca0: e2806010 add r6, r0, #16 3001aca4: e1a00006 mov r0, r6 3001aca8: eb001319 bl 3001f914 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
3001acac: e59f003c ldr r0, [pc, #60] ; 3001acf0 <rtems_timer_reset+0xa4> 3001acb0: e1a01006 mov r1, r6 3001acb4: eb0012a9 bl 3001f760 <_Watchdog_Insert>
* 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();
3001acb8: eb000f22 bl 3001e948 <_Thread_Enable_dispatch> 3001acbc: eafffff4 b 3001ac94 <rtems_timer_reset+0x48>
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;
3001acc0: e59f302c ldr r3, [pc, #44] ; 3001acf4 <rtems_timer_reset+0xa8><== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
3001acc4: 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;
3001acc8: e5935000 ldr r5, [r3] <== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
3001accc: eb001310 bl 3001f914 <_Watchdog_Remove> <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001acd0: e1a00005 mov r0, r5 <== NOT EXECUTED 3001acd4: e1a01006 mov r1, r6 <== NOT EXECUTED 3001acd8: e1a0e00f mov lr, pc <== NOT EXECUTED 3001acdc: e595f004 ldr pc, [r5, #4] <== NOT EXECUTED
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
3001ace0: e1a05004 mov r5, r4 <== 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();
3001ace4: eb000f17 bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED 3001ace8: eaffffe9 b 3001ac94 <rtems_timer_reset+0x48> <== NOT EXECUTED
3001acf8 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001acf8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3001acfc: e1a07000 mov r7, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
3001ad00: e59f00d0 ldr r0, [pc, #208] ; 3001add8 <rtems_timer_server_fire_after+0xe0><== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001ad04: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
3001ad08: e5904000 ldr r4, [r0] <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001ad0c: e1a06001 mov r6, r1 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
3001ad10: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001ad14: e1a05002 mov r5, r2 <== NOT EXECUTED
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
3001ad18: 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 )
3001ad1c: 0a000005 beq 3001ad38 <rtems_timer_server_fire_after+0x40> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
3001ad20: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3001ad24: 03a00009 moveq r0, #9 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !routine )
3001ad28: 0a000002 beq 3001ad38 <rtems_timer_server_fire_after+0x40> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
3001ad2c: e3510000 cmp r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
3001ad30: 03a0000a moveq r0, #10 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
3001ad34: 1a000001 bne 3001ad40 <rtems_timer_server_fire_after+0x48> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001ad38: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3001ad3c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001ad40: e28d2004 add r2, sp, #4 <== NOT EXECUTED
3001ad44: e59f0090 ldr r0, [pc, #144] ; 3001addc <rtems_timer_server_fire_after+0xe4><== NOT EXECUTED
3001ad48: e1a01007 mov r1, r7 <== NOT EXECUTED
3001ad4c: e58d3000 str r3, [sp] <== NOT EXECUTED
3001ad50: eb000b33 bl 3001da24 <_Objects_Get> <== NOT EXECUTED
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001ad54: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3001ad58: e1a08000 mov r8, r0 <== NOT EXECUTED 3001ad5c: e3520000 cmp r2, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001ad60: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001ad64: 1afffff3 bne 3001ad38 <rtems_timer_server_fire_after+0x40> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001ad68: e2880010 add r0, r8, #16 <== NOT EXECUTED 3001ad6c: eb0012e8 bl 3001f914 <_Watchdog_Remove> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001ad70: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001ad74: e3812080 orr r2, r1, #128 ; 0x80 <== NOT EXECUTED 3001ad78: 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 ) {
3001ad7c: e5982018 ldr r2, [r8, #24] <== NOT EXECUTED 3001ad80: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3001ad84: e3520000 cmp r2, #0 <== NOT EXECUTED 3001ad88: 1a00000e bne 3001adc8 <rtems_timer_server_fire_after+0xd0> <== 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;
3001ad8c: e3a00001 mov r0, #1 <== NOT EXECUTED 3001ad90: e5880038 str r0, [r8, #56] ; 0x38 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001ad94: e5882018 str r2, [r8, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
3001ad98: e588502c str r5, [r8, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
3001ad9c: e5887030 str r7, [r8, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3001ada0: e5883034 str r3, [r8, #52] ; 0x34 <== NOT EXECUTED
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
3001ada4: e588601c str r6, [r8, #28] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001ada8: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
(*timer_server->schedule_operation)( timer_server, the_timer );
3001adac: e1a00004 mov r0, r4 <== NOT EXECUTED 3001adb0: e1a01008 mov r1, r8 <== NOT EXECUTED 3001adb4: e1a0e00f mov lr, pc <== NOT EXECUTED 3001adb8: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3001adbc: eb000ee1 bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001adc0: e3a00000 mov r0, #0 <== NOT EXECUTED 3001adc4: eaffffdb b 3001ad38 <rtems_timer_server_fire_after+0x40> <== NOT EXECUTED 3001adc8: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
_Thread_Enable_dispatch();
3001adcc: eb000edd bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001add0: e3a00000 mov r0, #0 <== NOT EXECUTED 3001add4: eaffffd7 b 3001ad38 <rtems_timer_server_fire_after+0x40> <== NOT EXECUTED
3001ade0 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001ade0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3001ade4: e1a07000 mov r7, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
3001ade8: e59f00fc ldr r0, [pc, #252] ; 3001aeec <rtems_timer_server_fire_when+0x10c><== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001adec: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
3001adf0: e5904000 ldr r4, [r0] <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001adf4: e1a06002 mov r6, r2 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
3001adf8: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001adfc: e1a08003 mov r8, r3 <== NOT EXECUTED
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
3001ae00: 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 )
3001ae04: 0a000004 beq 3001ae1c <rtems_timer_server_fire_when+0x3c> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
3001ae08: e59f50e0 ldr r5, [pc, #224] ; 3001aef0 <rtems_timer_server_fire_when+0x110><== NOT EXECUTED 3001ae0c: e5d53014 ldrb r3, [r5, #20] <== NOT EXECUTED 3001ae10: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
3001ae14: 03a0000b moveq r0, #11 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
3001ae18: 1a000001 bne 3001ae24 <rtems_timer_server_fire_when+0x44> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001ae1c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3001ae20: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
3001ae24: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3001ae28: 03a00009 moveq r0, #9 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
3001ae2c: 0afffffa beq 3001ae1c <rtems_timer_server_fire_when+0x3c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
3001ae30: e1a00001 mov r0, r1 <== NOT EXECUTED 3001ae34: e58d1000 str r1, [sp] <== NOT EXECUTED 3001ae38: ebfff368 bl 30017be0 <_TOD_Validate> <== NOT EXECUTED 3001ae3c: e3500000 cmp r0, #0 <== NOT EXECUTED 3001ae40: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3001ae44: 1a000001 bne 3001ae50 <rtems_timer_server_fire_when+0x70> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
3001ae48: e3a00014 mov r0, #20 <== NOT EXECUTED 3001ae4c: eafffff2 b 3001ae1c <rtems_timer_server_fire_when+0x3c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
3001ae50: e1a00001 mov r0, r1 <== NOT EXECUTED
3001ae54: ebfff332 bl 30017b24 <_TOD_To_seconds> <== NOT EXECUTED
3001ae58: e59f2094 ldr r2, [pc, #148] ; 3001aef4 <rtems_timer_server_fire_when+0x114><== NOT EXECUTED
3001ae5c: e1a0a000 mov sl, r0 <== NOT EXECUTED
3001ae60: e3a03000 mov r3, #0 <== NOT EXECUTED
3001ae64: e8950003 ldm r5, {r0, r1} <== NOT EXECUTED
3001ae68: eb0051a7 bl 3002f50c <__divdi3> <== NOT EXECUTED
if ( seconds <= _TOD_Seconds_since_epoch() )
3001ae6c: e15a0000 cmp sl, r0 <== NOT EXECUTED 3001ae70: 9afffff4 bls 3001ae48 <rtems_timer_server_fire_when+0x68> <== NOT EXECUTED 3001ae74: e59f007c ldr r0, [pc, #124] ; 3001aef8 <rtems_timer_server_fire_when+0x118><== NOT EXECUTED 3001ae78: e1a01007 mov r1, r7 <== NOT EXECUTED 3001ae7c: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3001ae80: eb000ae7 bl 3001da24 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001ae84: e59db004 ldr fp, [sp, #4] <== NOT EXECUTED 3001ae88: e1a09000 mov r9, r0 <== NOT EXECUTED 3001ae8c: e35b0000 cmp fp, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001ae90: 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 ) {
3001ae94: 1affffe0 bne 3001ae1c <rtems_timer_server_fire_when+0x3c> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001ae98: e2890010 add r0, r9, #16 <== NOT EXECUTED
3001ae9c: eb00129c bl 3001f914 <_Watchdog_Remove> <== NOT EXECUTED
3001aea0: e8950003 ldm r5, {r0, r1} <== NOT EXECUTED
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
3001aea4: e3a0c003 mov ip, #3 <== NOT EXECUTED 3001aea8: e59f2044 ldr r2, [pc, #68] ; 3001aef4 <rtems_timer_server_fire_when+0x114><== NOT EXECUTED 3001aeac: e3a03000 mov r3, #0 <== NOT EXECUTED 3001aeb0: e589c038 str ip, [r9, #56] ; 0x38 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001aeb4: e589b018 str fp, [r9, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
3001aeb8: e589602c str r6, [r9, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
3001aebc: e5897030 str r7, [r9, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3001aec0: e5898034 str r8, [r9, #52] ; 0x34 <== NOT EXECUTED 3001aec4: eb005190 bl 3002f50c <__divdi3> <== NOT EXECUTED
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
3001aec8: e060a00a rsb sl, r0, sl <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001aecc: e1a01009 mov r1, r9 <== NOT EXECUTED 3001aed0: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
3001aed4: e589a01c str sl, [r9, #28] <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001aed8: e1a0e00f mov lr, pc <== NOT EXECUTED 3001aedc: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3001aee0: eb000e98 bl 3001e948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001aee4: e1a0000b mov r0, fp <== NOT EXECUTED 3001aee8: eaffffcb b 3001ae1c <rtems_timer_server_fire_when+0x3c> <== NOT EXECUTED
3000b1c4 <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;
3000b1c4: e59f3020 ldr r3, [pc, #32] ; 3000b1ec <rtems_workspace_greedy_free+0x28><== NOT EXECUTED
void rtems_workspace_greedy_free( void *opaque )
{
3000b1c8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000b1cc: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000b1d0: e1a01000 mov r1, r0 <== NOT EXECUTED
++level;
3000b1d4: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000b1d8: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Disable_dispatch(); _Heap_Greedy_free( &_Workspace_Area, opaque );
3000b1dc: e59f000c ldr r0, [pc, #12] ; 3000b1f0 <rtems_workspace_greedy_free+0x2c><== NOT EXECUTED 3000b1e0: eb000303 bl 3000bdf4 <_Heap_Greedy_free> <== NOT EXECUTED
_Thread_Enable_dispatch(); }
3000b1e4: 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();
3000b1e8: ea000908 b 3000d610 <_Thread_Enable_dispatch> <== NOT EXECUTED
3000b09c <sched_get_priority_max>:
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
3000b09c: e3500004 cmp r0, #4 <== NOT EXECUTED
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
3000b0a0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
switch ( policy ) {
3000b0a4: 9a000004 bls 3000b0bc <sched_get_priority_max+0x20> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000b0a8: eb002176 bl 30013688 <__errno> <== NOT EXECUTED
3000b0ac: e3a03016 mov r3, #22 <== NOT EXECUTED
3000b0b0: e5803000 str r3, [r0] <== NOT EXECUTED
3000b0b4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b0b8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
3000b0bc: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b0c0: e1a00013 lsl r0, r3, r0 <== NOT EXECUTED 3000b0c4: e3100017 tst r0, #23 <== NOT EXECUTED 3000b0c8: 0afffff6 beq 3000b0a8 <sched_get_priority_max+0xc> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
3000b0cc: e59f3008 ldr r3, [pc, #8] ; 3000b0dc <sched_get_priority_max+0x40><== NOT EXECUTED 3000b0d0: e5d30000 ldrb r0, [r3] <== NOT EXECUTED 3000b0d4: e2400001 sub r0, r0, #1 <== NOT EXECUTED
}
3000b0d8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b0e0 <sched_get_priority_min>:
*/
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
3000b0e0: 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
)
{
3000b0e4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
switch ( policy ) {
3000b0e8: 9a000004 bls 3000b100 <sched_get_priority_min+0x20> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000b0ec: eb002165 bl 30013688 <__errno> <== NOT EXECUTED
3000b0f0: e3a03016 mov r3, #22 <== NOT EXECUTED
3000b0f4: e5803000 str r3, [r0] <== NOT EXECUTED
3000b0f8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b0fc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*/
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
3000b100: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b104: e1a00013 lsl r0, r3, r0 <== NOT EXECUTED 3000b108: e3100017 tst r0, #23 <== NOT EXECUTED 3000b10c: 0afffff6 beq 3000b0ec <sched_get_priority_min+0xc> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
3000b110: e1a00003 mov r0, r3 <== NOT EXECUTED
}
3000b114: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a52c <sched_getparam>:
*/
int sched_getparam(
pid_t pid __attribute__((unused)),
struct sched_param *param __attribute__((unused))
)
{
3000a52c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a530: eb00227a bl 30012f20 <__errno> <== NOT EXECUTED 3000a534: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a538: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a53c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a540: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a544 <sched_getscheduler>:
#include <rtems/posix/time.h>
int sched_getscheduler(
pid_t pid __attribute__((unused))
)
{
3000a544: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a548: eb002274 bl 30012f20 <__errno> <== NOT EXECUTED 3000a54c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a550: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a554: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a558: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b118 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
3000b118: e92d4010 push {r4, lr} <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
3000b11c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
3000b120: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
3000b124: 1a000007 bne 3000b148 <sched_rr_get_interval+0x30> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
3000b128: e3510000 cmp r1, #0 <== NOT EXECUTED 3000b12c: 0a00000f beq 3000b170 <sched_rr_get_interval+0x58> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
3000b130: e59f304c ldr r3, [pc, #76] ; 3000b184 <sched_rr_get_interval+0x6c><== NOT EXECUTED 3000b134: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000b138: eb000e80 bl 3000eb40 <_Timespec_From_ticks> <== NOT EXECUTED
return 0;
3000b13c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000b140: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b144: e8bd8010 pop {r4, pc} <== NOT EXECUTED
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
3000b148: e58d1000 str r1, [sp] <== NOT EXECUTED 3000b14c: ebffef57 bl 30006eb0 <getpid> <== NOT EXECUTED 3000b150: e1500004 cmp r0, r4 <== NOT EXECUTED 3000b154: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000b158: 0afffff2 beq 3000b128 <sched_rr_get_interval+0x10> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
3000b15c: eb002149 bl 30013688 <__errno> <== NOT EXECUTED 3000b160: e3a03003 mov r3, #3 <== NOT EXECUTED 3000b164: e5803000 str r3, [r0] <== NOT EXECUTED 3000b168: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000b16c: eafffff3 b 3000b140 <sched_rr_get_interval+0x28> <== NOT EXECUTED
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
3000b170: eb002144 bl 30013688 <__errno> <== NOT EXECUTED 3000b174: e3a03016 mov r3, #22 <== NOT EXECUTED 3000b178: e5803000 str r3, [r0] <== NOT EXECUTED 3000b17c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000b180: eaffffee b 3000b140 <sched_rr_get_interval+0x28> <== NOT EXECUTED
3000a55c <sched_setparam>:
int sched_setparam(
pid_t pid __attribute__((unused)),
const struct sched_param *param __attribute__((unused))
)
{
3000a55c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a560: eb00226e bl 30012f20 <__errno> <== NOT EXECUTED 3000a564: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a568: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a56c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a570: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a574 <sched_setscheduler>:
int sched_setscheduler(
pid_t pid __attribute__((unused)),
int policy __attribute__((unused)),
const struct sched_param *param __attribute__((unused))
)
{
3000a574: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a578: eb002268 bl 30012f20 <__errno> <== NOT EXECUTED 3000a57c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a580: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a584: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a588: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000d3d0 <sem_close>:
#include <rtems/seterr.h>
int sem_close(
sem_t *sem
)
{
3000d3d0: e92d4010 push {r4, lr}
3000d3d4: e24dd004 sub sp, sp, #4
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
3000d3d8: e5901000 ldr r1, [r0] 3000d3dc: e1a0200d mov r2, sp 3000d3e0: e59f0040 ldr r0, [pc, #64] ; 3000d428 <sem_close+0x58> 3000d3e4: eb0008c4 bl 3000f6fc <_Objects_Get>
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000d3e8: e59d4000 ldr r4, [sp] 3000d3ec: e3540000 cmp r4, #0
3000d3f0: 0a000005 beq 3000d40c <sem_close+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000d3f4: eb0024a5 bl 30016690 <__errno> <== NOT EXECUTED 3000d3f8: e3a03016 mov r3, #22 <== NOT EXECUTED 3000d3fc: e5803000 str r3, [r0] <== NOT EXECUTED 3000d400: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000d404: e28dd004 add sp, sp, #4
3000d408: e8bd8010 pop {r4, pc}
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_semaphore->open_count -= 1;
3000d40c: e5902018 ldr r2, [r0, #24] 3000d410: e2422001 sub r2, r2, #1 3000d414: e5802018 str r2, [r0, #24]
_POSIX_Semaphore_Delete( the_semaphore );
3000d418: eb00194a bl 30013948 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
3000d41c: eb000c5e bl 3001059c <_Thread_Enable_dispatch>
return 0;
3000d420: e1a00004 mov r0, r4 3000d424: eafffff6 b 3000d404 <sem_close+0x34>
3000d42c <sem_destroy>:
#include <rtems/seterr.h>
int sem_destroy(
sem_t *sem
)
{
3000d42c: e92d4010 push {r4, lr}
3000d430: e24dd004 sub sp, sp, #4
3000d434: e5901000 ldr r1, [r0]
3000d438: e1a0200d mov r2, sp
3000d43c: e59f0058 ldr r0, [pc, #88] ; 3000d49c <sem_destroy+0x70>
3000d440: eb0008ad bl 3000f6fc <_Objects_Get>
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000d444: e59d3000 ldr r3, [sp] 3000d448: e3530000 cmp r3, #0
3000d44c: 0a000005 beq 3000d468 <sem_destroy+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000d450: eb00248e bl 30016690 <__errno> <== NOT EXECUTED 3000d454: e3a03016 mov r3, #22 <== NOT EXECUTED 3000d458: e5803000 str r3, [r0] <== NOT EXECUTED 3000d45c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000d460: e28dd004 add sp, sp, #4
3000d464: e8bd8010 pop {r4, pc}
case OBJECTS_LOCAL:
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
3000d468: e5d04014 ldrb r4, [r0, #20] 3000d46c: e3540000 cmp r4, #0
3000d470: 1a000003 bne 3000d484 <sem_destroy+0x58>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
_POSIX_Semaphore_Delete( the_semaphore );
3000d474: eb001933 bl 30013948 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
3000d478: eb000c47 bl 3001059c <_Thread_Enable_dispatch>
return 0;
3000d47c: e1a00004 mov r0, r4 3000d480: eafffff6 b 3000d460 <sem_destroy+0x34>
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
_Thread_Enable_dispatch();
3000d484: eb000c44 bl 3001059c <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000d488: eb002480 bl 30016690 <__errno> <== NOT EXECUTED 3000d48c: e3a03016 mov r3, #22 <== NOT EXECUTED 3000d490: e5803000 str r3, [r0] <== NOT EXECUTED 3000d494: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000d498: eafffff0 b 3000d460 <sem_destroy+0x34> <== NOT EXECUTED
3000d4a0 <sem_getvalue>:
int sem_getvalue(
sem_t *sem,
int *sval
)
{
3000d4a0: e92d4030 push {r4, r5, lr}
3000d4a4: e5903000 ldr r3, [r0]
3000d4a8: e24dd004 sub sp, sp, #4
3000d4ac: e1a04001 mov r4, r1
3000d4b0: e59f0040 ldr r0, [pc, #64] ; 3000d4f8 <sem_getvalue+0x58>
3000d4b4: e1a01003 mov r1, r3
3000d4b8: e1a0200d mov r2, sp
3000d4bc: eb00088e bl 3000f6fc <_Objects_Get>
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000d4c0: e59d5000 ldr r5, [sp] 3000d4c4: e3550000 cmp r5, #0
3000d4c8: 0a000005 beq 3000d4e4 <sem_getvalue+0x44>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000d4cc: eb00246f bl 30016690 <__errno> <== NOT EXECUTED 3000d4d0: e3a03016 mov r3, #22 <== NOT EXECUTED 3000d4d4: e5803000 str r3, [r0] <== NOT EXECUTED 3000d4d8: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000d4dc: e28dd004 add sp, sp, #4
3000d4e0: e8bd8030 pop {r4, r5, pc}
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore );
3000d4e4: e5903064 ldr r3, [r0, #100] ; 0x64 3000d4e8: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
3000d4ec: eb000c2a bl 3001059c <_Thread_Enable_dispatch>
return 0;
3000d4f0: e1a00005 mov r0, r5 3000d4f4: eafffff8 b 3000d4dc <sem_getvalue+0x3c>
3000ab8c <sem_init>:
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
3000ab8c: e92d4010 push {r4, lr}
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
3000ab90: e2504000 subs r4, r0, #0
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
3000ab94: e24dd008 sub sp, sp, #8 3000ab98: e1a0c001 mov ip, r1 3000ab9c: e1a03002 mov r3, r2
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
3000aba0: 0a00000b beq 3000abd4 <sem_init+0x48>
rtems_set_errno_and_return_minus_one( EINVAL );
status = _POSIX_Semaphore_Create_support(
3000aba4: e3a00000 mov r0, #0 3000aba8: e1a0200c mov r2, ip 3000abac: e1a01000 mov r1, r0 3000abb0: e28dc004 add ip, sp, #4 3000abb4: e58dc000 str ip, [sp] 3000abb8: eb001854 bl 30010d10 <_POSIX_Semaphore_Create_support>
pshared,
value,
&the_semaphore
);
if ( status != -1 )
3000abbc: e3700001 cmn r0, #1
*sem = the_semaphore->Object.id;
3000abc0: 159d3004 ldrne r3, [sp, #4] 3000abc4: 15933008 ldrne r3, [r3, #8] 3000abc8: 15843000 strne r3, [r4]
return status;
}
3000abcc: e28dd008 add sp, sp, #8
3000abd0: e8bd8010 pop {r4, pc}
{
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
rtems_set_errno_and_return_minus_one( EINVAL );
3000abd4: eb00226c bl 3001358c <__errno> <== NOT EXECUTED 3000abd8: e3a03016 mov r3, #22 <== NOT EXECUTED 3000abdc: e5803000 str r3, [r0] <== NOT EXECUTED 3000abe0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000abe4: eafffff8 b 3000abcc <sem_init+0x40> <== NOT EXECUTED
3000b6a0 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
3000b6a0: e92d000e push {r1, r2, r3}
3000b6a4: 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;
3000b6a8: e59f3104 ldr r3, [pc, #260] ; 3000b7b4 <sem_open+0x114> 3000b6ac: e24dd018 sub sp, sp, #24 3000b6b0: e5932000 ldr r2, [r3] 3000b6b4: e59d4030 ldr r4, [sp, #48] ; 0x30
++level;
3000b6b8: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000b6bc: e5832000 str r2, [r3] 3000b6c0: e1a05000 mov r5, r0
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
3000b6c4: e2146c02 ands r6, r4, #512 ; 0x200
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
3000b6c8: 128d303c addne r3, sp, #60 ; 0x3c 3000b6cc: 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 );
3000b6d0: e59f00e0 ldr r0, [pc, #224] ; 3000b7b8 <sem_open+0x118> 3000b6d4: e1a01005 mov r1, r5 3000b6d8: e28d2008 add r2, sp, #8 3000b6dc: e28d3014 add r3, sp, #20 3000b6e0: 159d7038 ldrne r7, [sp, #56] ; 0x38
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
3000b6e4: 01a07006 moveq r7, r6 3000b6e8: ebfffe64 bl 3000b080 <_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 ) {
3000b6ec: e2508000 subs r8, r0, #0
3000b6f0: 0a000008 beq 3000b718 <sem_open+0x78>
/*
* 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) ) ) {
3000b6f4: e3580002 cmp r8, #2
3000b6f8: 1a000001 bne 3000b704 <sem_open+0x64>
3000b6fc: e3560000 cmp r6, #0
3000b700: 1a000018 bne 3000b768 <sem_open+0xc8>
_Thread_Enable_dispatch();
3000b704: eb000dbf bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
3000b708: eb002420 bl 30014790 <__errno> <== NOT EXECUTED 3000b70c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000b710: e5808000 str r8, [r0] <== NOT EXECUTED 3000b714: ea00000e b 3000b754 <sem_open+0xb4> <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
3000b718: e2044c0a and r4, r4, #2560 ; 0xa00 3000b71c: e3540c0a cmp r4, #2560 ; 0xa00
3000b720: 0a00001d beq 3000b79c <sem_open+0xfc>
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
3000b724: e59d1008 ldr r1, [sp, #8] 3000b728: e28d2010 add r2, sp, #16 3000b72c: e59f0084 ldr r0, [pc, #132] ; 3000b7b8 <sem_open+0x118> 3000b730: eb0009d6 bl 3000de90 <_Objects_Get>
_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 );
the_semaphore->open_count += 1;
3000b734: 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 );
3000b738: e58d000c str r0, [sp, #12]
the_semaphore->open_count += 1;
3000b73c: e2833001 add r3, r3, #1 3000b740: e5803018 str r3, [r0, #24]
_Thread_Enable_dispatch();
3000b744: eb000daf bl 3000ee08 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
3000b748: eb000dae bl 3000ee08 <_Thread_Enable_dispatch>
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;
3000b74c: e59d300c ldr r3, [sp, #12] 3000b750: e2833008 add r3, r3, #8
#endif }
3000b754: e1a00003 mov r0, r3
3000b758: e28dd018 add sp, sp, #24
3000b75c: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
3000b760: e28dd00c add sp, sp, #12
3000b764: e12fff1e bx lr
/*
* 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(
3000b768: e1a03007 mov r3, r7 3000b76c: e28dc00c add ip, sp, #12 3000b770: e3a02000 mov r2, #0 3000b774: e59d1014 ldr r1, [sp, #20] 3000b778: e1a00005 mov r0, r5 3000b77c: e58dc000 str ip, [sp] 3000b780: eb0019aa bl 30011e30 <_POSIX_Semaphore_Create_support> 3000b784: e1a04000 mov r4, r0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
3000b788: eb000d9e bl 3000ee08 <_Thread_Enable_dispatch>
if ( status == -1 )
3000b78c: e3740001 cmn r4, #1
return SEM_FAILED;
3000b790: 01a03004 moveq r3, r4
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
3000b794: 1affffec bne 3000b74c <sem_open+0xac>
3000b798: eaffffed b 3000b754 <sem_open+0xb4> <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
3000b79c: eb000d99 bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
3000b7a0: eb0023fa bl 30014790 <__errno> <== NOT EXECUTED 3000b7a4: e3a03011 mov r3, #17 <== NOT EXECUTED 3000b7a8: e5803000 str r3, [r0] <== NOT EXECUTED 3000b7ac: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000b7b0: eaffffe7 b 3000b754 <sem_open+0xb4> <== NOT EXECUTED
3000abe8 <sem_post>:
#include <rtems/seterr.h>
int sem_post(
sem_t *sem
)
{
3000abe8: e92d4010 push {r4, lr}
3000abec: e24dd004 sub sp, sp, #4
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
3000abf0: e5901000 ldr r1, [r0] 3000abf4: e1a0200d mov r2, sp 3000abf8: e59f0040 ldr r0, [pc, #64] ; 3000ac40 <sem_post+0x58> 3000abfc: eb00084c bl 3000cd34 <_Objects_Get>
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000ac00: e59d4000 ldr r4, [sp] 3000ac04: e3540000 cmp r4, #0
3000ac08: 0a000005 beq 3000ac24 <sem_post+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000ac0c: eb00225e bl 3001358c <__errno> <== NOT EXECUTED 3000ac10: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ac14: e5803000 str r3, [r0] <== NOT EXECUTED 3000ac18: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000ac1c: e28dd004 add sp, sp, #4
3000ac20: e8bd8010 pop {r4, pc}
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Surrender(
3000ac24: e5901008 ldr r1, [r0, #8] 3000ac28: e1a02004 mov r2, r4 3000ac2c: e280001c add r0, r0, #28 3000ac30: eb000592 bl 3000c280 <_CORE_semaphore_Surrender>
NULL /* XXX need to define a routine to handle this case */
#else
NULL
#endif
);
_Thread_Enable_dispatch();
3000ac34: eb000be6 bl 3000dbd4 <_Thread_Enable_dispatch>
return 0;
3000ac38: e1a00004 mov r0, r4 3000ac3c: eafffff6 b 3000ac1c <sem_post+0x34>
3000d6d0 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
3000d6d0: e92d4010 push {r4, lr} <== NOT EXECUTED
3000d6d4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000d6d8: 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 );
3000d6dc: e1a00001 mov r0, r1 <== NOT EXECUTED 3000d6e0: e1a0100d mov r1, sp <== NOT EXECUTED 3000d6e4: eb0015d5 bl 30012e40 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
3000d6e8: e3500003 cmp r0, #3 <== NOT EXECUTED
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
3000d6ec: e1a00004 mov r0, r4 <== 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 ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
3000d6f0: 0a000004 beq 3000d708 <sem_timedwait+0x38> <== NOT EXECUTED
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
3000d6f4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000d6f8: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000d6fc: eb0018b6 bl 300139dc <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
3000d700: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000d704: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
3000d708: e3a01001 mov r1, #1 <== NOT EXECUTED 3000d70c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000d710: eb0018b1 bl 300139dc <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 3000d714: eafffff9 b 3000d700 <sem_timedwait+0x30> <== NOT EXECUTED
3000d724 <sem_unlink>:
#include <rtems/seterr.h>
int sem_unlink(
const char *name
)
{
3000d724: e92d4030 push {r4, r5, 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;
3000d728: e59f3078 ldr r3, [pc, #120] ; 3000d7a8 <sem_unlink+0x84> 3000d72c: e24dd008 sub sp, sp, #8 3000d730: e5932000 ldr r2, [r3] 3000d734: e1a01000 mov r1, r0
++level;
3000d738: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000d73c: e5832000 str r2, [r3]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
3000d740: e59f4064 ldr r4, [pc, #100] ; 3000d7ac <sem_unlink+0x88> 3000d744: e1a0200d mov r2, sp 3000d748: e1a00004 mov r0, r4 3000d74c: e28d3004 add r3, sp, #4 3000d750: eb00167d bl 3001314c <_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 ) {
3000d754: e2505000 subs r5, r0, #0
3000d758: 1a00000d bne 3000d794 <sem_unlink+0x70>
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3000d75c: e594301c ldr r3, [r4, #28] 3000d760: e1dd20b0 ldrh r2, [sp]
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Namespace_remove (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Namespace_remove(
3000d764: e1a00004 mov r0, r4 3000d768: e7934102 ldr r4, [r3, r2, lsl #2] 3000d76c: e1a01004 mov r1, r4
the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object(
&_POSIX_Semaphore_Information,
_Objects_Get_index( the_semaphore_id )
);
the_semaphore->linked = false;
3000d770: e5c45015 strb r5, [r4, #21] 3000d774: eb000834 bl 3000f84c <_Objects_Namespace_remove>
_POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore );
3000d778: e1a00004 mov r0, r4 3000d77c: eb001871 bl 30013948 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
3000d780: eb000b85 bl 3001059c <_Thread_Enable_dispatch>
return 0;
3000d784: e1a03005 mov r3, r5
}
3000d788: e1a00003 mov r0, r3
3000d78c: e28dd008 add sp, sp, #8
3000d790: e8bd8030 pop {r4, r5, pc}
_Thread_Disable_dispatch();
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id, &name_len );
if ( status != 0 ) {
_Thread_Enable_dispatch();
3000d794: eb000b80 bl 3001059c <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( status );
3000d798: eb0023bc bl 30016690 <__errno> <== NOT EXECUTED 3000d79c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000d7a0: e5805000 str r5, [r0] <== NOT EXECUTED 3000d7a4: eafffff7 b 3000d788 <sem_unlink+0x64> <== NOT EXECUTED
3000a458 <setitimer>:
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
if ( !value )
3000a458: e3510000 cmp r1, #0 <== NOT EXECUTED
int setitimer(
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
3000a45c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !value )
3000a460: 0a00000d beq 3000a49c <setitimer+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
3000a464: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a468: 0a00000b beq 3000a49c <setitimer+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
3000a46c: e3500002 cmp r0, #2 <== NOT EXECUTED 3000a470: 9a000004 bls 3000a488 <setitimer+0x30> <== NOT EXECUTED
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000a474: eb002263 bl 30012e08 <__errno> <== NOT EXECUTED 3000a478: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a47c: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a480: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a484: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
switch ( which ) {
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a488: eb00225e bl 30012e08 <__errno> <== NOT EXECUTED 3000a48c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a490: e5803000 str r3, [r0] <== NOT EXECUTED
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
3000a494: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a498: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
if ( !value )
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
rtems_set_errno_and_return_minus_one( EFAULT );
3000a49c: eb002259 bl 30012e08 <__errno> <== NOT EXECUTED 3000a4a0: e3a0300e mov r3, #14 <== NOT EXECUTED 3000a4a4: e5803000 str r3, [r0] <== NOT EXECUTED 3000a4a8: eafffff4 b 3000a480 <setitimer+0x28> <== NOT EXECUTED
3000af58 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
3000af58: e2523000 subs r3, r2, #0 <== NOT EXECUTED
*oact = _POSIX_signals_Vectors[ sig ];
3000af5c: 159f20c4 ldrne r2, [pc, #196] ; 3000b028 <sigaction+0xd0> <== NOT EXECUTED
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
3000af60: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000af64: e1a05001 mov r5, r1 <== NOT EXECUTED
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
3000af68: 10801080 addne r1, r0, r0, lsl #1 <== NOT EXECUTED 3000af6c: 10822101 addne r2, r2, r1, lsl #2 <== NOT EXECUTED
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
3000af70: e1a04000 mov r4, r0 <== NOT EXECUTED
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
3000af74: 18920007 ldmne r2, {r0, r1, r2} <== NOT EXECUTED
3000af78: 18830007 stmne r3, {r0, r1, r2} <== NOT EXECUTED
if ( !sig )
3000af7c: e3540000 cmp r4, #0 <== NOT EXECUTED 3000af80: 0a000023 beq 3000b014 <sigaction+0xbc> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000af84: e2443001 sub r3, r4, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
3000af88: e353001f cmp r3, #31 <== NOT EXECUTED 3000af8c: 8a000020 bhi 3000b014 <sigaction+0xbc> <== NOT EXECUTED
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
3000af90: e3540009 cmp r4, #9 <== NOT EXECUTED 3000af94: 0a00001e beq 3000b014 <sigaction+0xbc> <== NOT EXECUTED
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
3000af98: e3550000 cmp r5, #0 <== NOT EXECUTED 3000af9c: 0a00001a beq 3000b00c <sigaction+0xb4> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000afa0: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000afa4: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000afa8: 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 ) {
3000afac: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000afb0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000afb4: 0a000009 beq 3000afe0 <sigaction+0x88> <== NOT EXECUTED
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
3000afb8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000afbc: eb0016f9 bl 30010ba8 <_POSIX_signals_Clear_process_signals><== NOT EXECUTED
_POSIX_signals_Vectors[ sig ] = *act;
3000afc0: e8950007 ldm r5, {r0, r1, r2} <== NOT EXECUTED
3000afc4: e59f305c ldr r3, [pc, #92] ; 3000b028 <sigaction+0xd0> <== NOT EXECUTED
3000afc8: e0844084 add r4, r4, r4, lsl #1 <== NOT EXECUTED
3000afcc: e0834104 add r4, r3, r4, lsl #2 <== NOT EXECUTED
3000afd0: 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 (
3000afd4: 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;
3000afd8: e3a00000 mov r0, #0 <== NOT EXECUTED
3000afdc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
3000afe0: e59f2044 ldr r2, [pc, #68] ; 3000b02c <sigaction+0xd4> <== NOT EXECUTED
3000afe4: e0844084 add r4, r4, r4, lsl #1 <== NOT EXECUTED
3000afe8: e59f3038 ldr r3, [pc, #56] ; 3000b028 <sigaction+0xd0> <== NOT EXECUTED
3000afec: e1a04104 lsl r4, r4, #2 <== NOT EXECUTED
3000aff0: e0833004 add r3, r3, r4 <== NOT EXECUTED
3000aff4: e0824004 add r4, r2, r4 <== NOT EXECUTED
3000aff8: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
3000affc: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
3000b000: 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;
3000b004: e3a00000 mov r0, #0 <== NOT EXECUTED
3000b008: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000b00c: e1a00005 mov r0, r5 <== NOT EXECUTED
}
3000b010: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
3000b014: eb002247 bl 30013938 <__errno> <== NOT EXECUTED
3000b018: e3a03016 mov r3, #22 <== NOT EXECUTED
3000b01c: e5803000 str r3, [r0] <== NOT EXECUTED
3000b020: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b024: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000b030 <sigaddset>:
int sigaddset(
sigset_t *set,
int signo
)
{
if ( !set )
3000b030: e2503000 subs r3, r0, #0 <== NOT EXECUTED
int sigaddset(
sigset_t *set,
int signo
)
{
3000b034: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000b038: 0a00000a beq 3000b068 <sigaddset+0x38> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000b03c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000b040: 0a000008 beq 3000b068 <sigaddset+0x38> <== NOT EXECUTED 3000b044: e2411001 sub r1, r1, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(signo) )
3000b048: e351001f cmp r1, #31 <== NOT EXECUTED 3000b04c: 8a000005 bhi 3000b068 <sigaddset+0x38> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
*set |= signo_to_mask(signo);
3000b050: e5932000 ldr r2, [r3] <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3000b054: e3a00001 mov r0, #1 <== NOT EXECUTED 3000b058: e1821110 orr r1, r2, r0, lsl r1 <== NOT EXECUTED
return 0;
3000b05c: e3a00000 mov r0, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
*set |= signo_to_mask(signo);
3000b060: e5831000 str r1, [r3] <== NOT EXECUTED
return 0; }
3000b064: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
3000b068: eb002232 bl 30013938 <__errno> <== NOT EXECUTED
3000b06c: e3a03016 mov r3, #22 <== NOT EXECUTED
3000b070: e5803000 str r3, [r0] <== NOT EXECUTED
3000b074: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b078: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000d200 <sigdelset>:
int sigdelset(
sigset_t *set,
int signo
)
{
if ( !set )
3000d200: e2503000 subs r3, r0, #0 <== NOT EXECUTED
int sigdelset(
sigset_t *set,
int signo
)
{
3000d204: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000d208: 0a00000c beq 3000d240 <sigdelset+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000d20c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000d210: 0a000008 beq 3000d238 <sigdelset+0x38> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000d214: e2411001 sub r1, r1, #1 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
3000d218: e351001f cmp r1, #31 <== NOT EXECUTED 3000d21c: 8a000007 bhi 3000d240 <sigdelset+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
*set &= ~signo_to_mask(signo);
3000d220: e5932000 ldr r2, [r3] <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3000d224: e3a00001 mov r0, #1 <== NOT EXECUTED 3000d228: e1c21110 bic r1, r2, r0, lsl r1 <== NOT EXECUTED
return 0;
3000d22c: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
*set &= ~signo_to_mask(signo);
3000d230: e5831000 str r1, [r3] <== NOT EXECUTED
return 0;
3000d234: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
return 0;
3000d238: 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;
}
3000d23c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
return 0;
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
3000d240: eb0022c3 bl 30015d54 <__errno> <== NOT EXECUTED
3000d244: e3a03016 mov r3, #22 <== NOT EXECUTED
3000d248: e5803000 str r3, [r0] <== NOT EXECUTED
3000d24c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d250: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ff98 <sigemptyset>:
int sigemptyset(
sigset_t *set
)
{
if ( !set )
3000ff98: e2503000 subs r3, r0, #0
#include <rtems/seterr.h>
int sigemptyset(
sigset_t *set
)
{
3000ff9c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( !set )
3000ffa0: 0a000002 beq 3000ffb0 <sigemptyset+0x18>
rtems_set_errno_and_return_minus_one( EINVAL );
*set = 0;
3000ffa4: e3a00000 mov r0, #0 3000ffa8: e5830000 str r0, [r3]
return 0; }
3000ffac: e49df004 pop {pc} ; (ldr pc, [sp], #4)
int sigemptyset(
sigset_t *set
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000ffb0: eb000a2c bl 30012868 <__errno> <== NOT EXECUTED
3000ffb4: e3a03016 mov r3, #22 <== NOT EXECUTED
3000ffb8: e5803000 str r3, [r0] <== NOT EXECUTED
3000ffbc: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000ffc0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000d280 <sigfillset>:
int sigfillset(
sigset_t *set
)
{
if ( !set )
3000d280: e3500000 cmp r0, #0 <== NOT EXECUTED
#include <rtems/seterr.h>
int sigfillset(
sigset_t *set
)
{
3000d284: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000d288: 0a000003 beq 3000d29c <sigfillset+0x1c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
*set = SIGNAL_ALL_MASK;
3000d28c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000d290: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
3000d294: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000d298: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int sigfillset(
sigset_t *set
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000d29c: eb0022ac bl 30015d54 <__errno> <== NOT EXECUTED
3000d2a0: e3a03016 mov r3, #22 <== NOT EXECUTED
3000d2a4: e5803000 str r3, [r0] <== NOT EXECUTED
3000d2a8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d2ac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000d2b0 <sigismember>:
int sigismember(
const sigset_t *set,
int signo
)
{
if ( !set )
3000d2b0: e3500000 cmp r0, #0 <== NOT EXECUTED
int sigismember(
const sigset_t *set,
int signo
)
{
3000d2b4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000d2b8: 0a00000c beq 3000d2f0 <sigismember+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000d2bc: e3510000 cmp r1, #0 <== NOT EXECUTED 3000d2c0: 0a000008 beq 3000d2e8 <sigismember+0x38> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000d2c4: e2411001 sub r1, r1, #1 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
3000d2c8: e351001f cmp r1, #31 <== NOT EXECUTED 3000d2cc: 8a000007 bhi 3000d2f0 <sigismember+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( *set & signo_to_mask(signo) )
3000d2d0: e5903000 ldr r3, [r0] <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3000d2d4: e3a02001 mov r2, #1 <== NOT EXECUTED
const sigset_t *set,
int signo
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000d2d8: e0133112 ands r3, r3, r2, lsl r1 <== NOT EXECUTED
3000d2dc: 03a00000 moveq r0, #0 <== NOT EXECUTED
3000d2e0: 13a00001 movne r0, #1 <== NOT EXECUTED
3000d2e4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
return 0;
3000d2e8: e1a00001 mov r0, r1 <== NOT EXECUTED
if ( *set & signo_to_mask(signo) )
return 1;
return 0;
}
3000d2ec: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
return 0;
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
3000d2f0: eb002297 bl 30015d54 <__errno> <== NOT EXECUTED
3000d2f4: e3a03016 mov r3, #22 <== NOT EXECUTED
3000d2f8: e5803000 str r3, [r0] <== NOT EXECUTED
3000d2fc: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d300: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ad5c <signal>:
sighandler_t signal(
int signum,
sighandler_t handler
)
{
3000ad5c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000ad60: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
3000ad64: e1a04000 mov r4, r0 <== NOT EXECUTED
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
sigemptyset(&s.sa_mask);
3000ad68: e28d0004 add r0, sp, #4 <== NOT EXECUTED
)
{
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
3000ad6c: e58d1008 str r1, [sp, #8] <== NOT EXECUTED
sigemptyset(&s.sa_mask);
3000ad70: ebffffee bl 3000ad30 <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;
3000ad74: e3a03000 mov r3, #0 <== NOT EXECUTED
#endif
sigaction( signum, &s, &old );
3000ad78: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ad7c: e1a0100d mov r1, sp <== NOT EXECUTED 3000ad80: 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;
3000ad84: e58d3000 str r3, [sp] <== NOT EXECUTED
#endif
sigaction( signum, &s, &old );
3000ad88: ebffff9f bl 3000ac0c <sigaction> <== NOT EXECUTED
return (sighandler_t) old.sa_handler; }
3000ad8c: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
3000ad90: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3000ad94: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b0a8 <sigpending>:
sigset_t *set
)
{
POSIX_API_Control *api;
if ( !set )
3000b0a8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
#include <rtems/seterr.h>
int sigpending(
sigset_t *set
)
{
3000b0ac: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set )
3000b0b0: 0a000009 beq 3000b0dc <sigpending+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000b0b4: e59f2034 ldr r2, [pc, #52] ; 3000b0f0 <sigpending+0x48> <== NOT EXECUTED
*set = api->signals_pending | _POSIX_signals_Pending;
3000b0b8: e59f1034 ldr r1, [pc, #52] ; 3000b0f4 <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 ];
3000b0bc: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED
*set = api->signals_pending | _POSIX_signals_Pending;
3000b0c0: e5911000 ldr r1, [r1] <== NOT EXECUTED 3000b0c4: e59220f4 ldr r2, [r2, #244] ; 0xf4 <== NOT EXECUTED
return 0;
3000b0c8: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
*set = api->signals_pending | _POSIX_signals_Pending;
3000b0cc: e59220d4 ldr r2, [r2, #212] ; 0xd4 <== NOT EXECUTED 3000b0d0: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000b0d4: e5832000 str r2, [r3] <== NOT EXECUTED
return 0;
}
3000b0d8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
)
{
POSIX_API_Control *api;
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000b0dc: eb002215 bl 30013938 <__errno> <== NOT EXECUTED
3000b0e0: e3a03016 mov r3, #22 <== NOT EXECUTED
3000b0e4: e5803000 str r3, [r0] <== NOT EXECUTED
3000b0e8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b0ec: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b0f8 <sigprocmask>:
/*
* P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask.
*/
#if defined(RTEMS_POSIX_API)
return pthread_sigmask( how, set, oset );
3000b0f8: ea001847 b 3001121c <pthread_sigmask> <== NOT EXECUTED
3000d358 <sigqueue>:
int sigqueue(
pid_t pid,
int signo,
const union sigval value
)
{
3000d358: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000d35c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000d360: e28d3004 add r3, sp, #4 <== NOT EXECUTED
3000d364: e5232004 str r2, [r3, #-4]! <== NOT EXECUTED
return killinfo( pid, signo, &value );
3000d368: e1a0200d mov r2, sp <== NOT EXECUTED 3000d36c: eb0016ed bl 30012f28 <killinfo> <== NOT EXECUTED
}
3000d370: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000d374: e8bd8000 pop {pc} <== NOT EXECUTED
3000d378 <sigsuspend>:
#include <rtems/seterr.h>
int sigsuspend(
const sigset_t *sigmask
)
{
3000d378: e92d4010 push {r4, lr} <== NOT EXECUTED
3000d37c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
3000d380: 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 );
3000d384: e1a01000 mov r1, r0 <== NOT EXECUTED 3000d388: e1a0200d mov r2, sp <== NOT EXECUTED 3000d38c: e3a00001 mov r0, #1 <== NOT EXECUTED 3000d390: ebffffef bl 3000d354 <sigprocmask> <== NOT EXECUTED
current_unblocked_signals = ~(*sigmask);
3000d394: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000d398: e28d0008 add r0, sp, #8 <== NOT EXECUTED 3000d39c: e1e03003 mvn r3, r3 <== NOT EXECUTED
status = sigtimedwait( ¤t_unblocked_signals, NULL, NULL );
3000d3a0: 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);
3000d3a4: e5203004 str r3, [r0, #-4]! <== NOT EXECUTED
status = sigtimedwait( ¤t_unblocked_signals, NULL, NULL );
3000d3a8: e1a02001 mov r2, r1 <== NOT EXECUTED 3000d3ac: eb000009 bl 3000d3d8 <sigtimedwait> <== NOT EXECUTED
(void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL );
3000d3b0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000d3b4: e1a0100d mov r1, sp <== NOT EXECUTED 3000d3b8: e1a02000 mov r2, r0 <== NOT EXECUTED 3000d3bc: ebffffe4 bl 3000d354 <sigprocmask> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
assert( status != -1 );
#endif
rtems_set_errno_and_return_minus_one( EINTR );
3000d3c0: eb002263 bl 30015d54 <__errno> <== NOT EXECUTED 3000d3c4: e3a03004 mov r3, #4 <== NOT EXECUTED 3000d3c8: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000d3cc: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d3d0: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000d3d4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b464 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
3000b464: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
3000b468: e2506000 subs r6, r0, #0 <== NOT EXECUTED
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
3000b46c: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 3000b470: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b474: e1a04002 mov r4, r2 <== NOT EXECUTED
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
3000b478: 0a000083 beq 3000b68c <sigtimedwait+0x228> <== NOT EXECUTED
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
3000b47c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b480: 0a000007 beq 3000b4a4 <sigtimedwait+0x40> <== NOT EXECUTED
if ( !_Timespec_Is_valid( timeout ) )
3000b484: e1a00002 mov r0, r2 <== NOT EXECUTED 3000b488: eb000ecf bl 3000efcc <_Timespec_Is_valid> <== NOT EXECUTED 3000b48c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b490: 0a00007d beq 3000b68c <sigtimedwait+0x228> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
3000b494: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b498: eb000edc bl 3000f010 <_Timespec_To_ticks> <== NOT EXECUTED
if ( !interval )
3000b49c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000b4a0: 0a000079 beq 3000b68c <sigtimedwait+0x228> <== NOT EXECUTED
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
the_thread = _Thread_Executing;
3000b4a4: e59f71f4 ldr r7, [pc, #500] ; 3000b6a0 <sigtimedwait+0x23c><== NOT EXECUTED
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
3000b4a8: e3550000 cmp r5, #0 <== NOT EXECUTED
the_thread = _Thread_Executing;
3000b4ac: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
3000b4b0: 028d5004 addeq r5, sp, #4 <== NOT EXECUTED
the_thread = _Thread_Executing;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000b4b4: e593a0f4 ldr sl, [r3, #244] ; 0xf4 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b4b8: e10f8000 mrs r8, CPSR <== NOT EXECUTED 3000b4bc: e3882080 orr r2, r8, #128 ; 0x80 <== NOT EXECUTED 3000b4c0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
*/
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
3000b4c4: e5961000 ldr r1, [r6] <== NOT EXECUTED 3000b4c8: e59a20d4 ldr r2, [sl, #212] ; 0xd4 <== NOT EXECUTED 3000b4cc: e1110002 tst r1, r2 <== NOT EXECUTED 3000b4d0: 1a000021 bne 3000b55c <sigtimedwait+0xf8> <== NOT EXECUTED
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
3000b4d4: e59f21c8 ldr r2, [pc, #456] ; 3000b6a4 <sigtimedwait+0x240><== NOT EXECUTED 3000b4d8: e5922000 ldr r2, [r2] <== NOT EXECUTED 3000b4dc: e1110002 tst r1, r2 <== NOT EXECUTED 3000b4e0: 0a00003d beq 3000b5dc <sigtimedwait+0x178> <== NOT EXECUTED 3000b4e4: e3a0401b mov r4, #27 <== NOT EXECUTED 3000b4e8: e3a01001 mov r1, #1 <== NOT EXECUTED
/* 3.3.8 Synchronously Accept a Signal, P1003.1b-1993, p. 76
NOTE: P1003.1c/D10, p. 39 adds sigwait(). */
int _EXFUN(sigwaitinfo, (const sigset_t *set, siginfo_t *info));
int _EXFUN(sigtimedwait,
3000b4ec: e2443001 sub r3, r4, #1 <== NOT EXECUTED
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
3000b4f0: e0123311 ands r3, r2, r1, lsl r3 <== NOT EXECUTED 3000b4f4: 1a00000b bne 3000b528 <sigtimedwait+0xc4> <== NOT EXECUTED
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000b4f8: e2844001 add r4, r4, #1 <== NOT EXECUTED 3000b4fc: e3540020 cmp r4, #32 <== NOT EXECUTED 3000b500: 1afffff9 bne 3000b4ec <sigtimedwait+0x88> <== NOT EXECUTED 3000b504: e3a04001 mov r4, #1 <== NOT EXECUTED 3000b508: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b50c: ea000002 b 3000b51c <sigtimedwait+0xb8> <== NOT EXECUTED
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
3000b510: e2844001 add r4, r4, #1 <== NOT EXECUTED 3000b514: e354001b cmp r4, #27 <== NOT EXECUTED 3000b518: 0a000002 beq 3000b528 <sigtimedwait+0xc4> <== NOT EXECUTED 3000b51c: e2443001 sub r3, r4, #1 <== NOT EXECUTED
if ( set & signo_to_mask( signo ) ) {
3000b520: e0123311 ands r3, r2, r1, lsl r3 <== NOT EXECUTED 3000b524: 0afffff9 beq 3000b510 <sigtimedwait+0xac> <== NOT EXECUTED
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
3000b528: e3a0c000 mov ip, #0 <== NOT EXECUTED 3000b52c: e1a0000a mov r0, sl <== NOT EXECUTED 3000b530: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b534: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b538: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b53c: e58dc000 str ip, [sp] <== NOT EXECUTED 3000b540: eb0017c5 bl 3001145c <_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 (
3000b544: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level );
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
3000b548: e3a02001 mov r2, #1 <== NOT EXECUTED 3000b54c: 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;
3000b550: e5854000 str r4, [r5] <== NOT EXECUTED
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
3000b554: e985000c stmib r5, {r2, r3} <== NOT EXECUTED
return signo;
3000b558: ea00001c b 3000b5d0 <sigtimedwait+0x16c> <== NOT EXECUTED
*/
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
3000b55c: e3a0101b mov r1, #27 <== NOT EXECUTED 3000b560: e3a00001 mov r0, #1 <== NOT EXECUTED 3000b564: e2413001 sub r3, r1, #1 <== NOT EXECUTED
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
3000b568: e0123310 ands r3, r2, r0, lsl r3 <== NOT EXECUTED 3000b56c: 1a00000b bne 3000b5a0 <sigtimedwait+0x13c> <== NOT EXECUTED
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000b570: e2811001 add r1, r1, #1 <== NOT EXECUTED 3000b574: e3510020 cmp r1, #32 <== NOT EXECUTED 3000b578: 1afffff9 bne 3000b564 <sigtimedwait+0x100> <== NOT EXECUTED 3000b57c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b580: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b584: ea000002 b 3000b594 <sigtimedwait+0x130> <== NOT EXECUTED
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
3000b588: e2811001 add r1, r1, #1 <== NOT EXECUTED 3000b58c: e351001b cmp r1, #27 <== NOT EXECUTED 3000b590: 0a000002 beq 3000b5a0 <sigtimedwait+0x13c> <== NOT EXECUTED 3000b594: e2413001 sub r3, r1, #1 <== NOT EXECUTED
if ( set & signo_to_mask( signo ) ) {
3000b598: e0123310 ands r3, r2, r0, lsl r3 <== NOT EXECUTED 3000b59c: 0afffff9 beq 3000b588 <sigtimedwait+0x124> <== NOT EXECUTED
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
_POSIX_signals_Clear_signals(
3000b5a0: e3a0c000 mov ip, #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 );
3000b5a4: e5851000 str r1, [r5] <== NOT EXECUTED
_POSIX_signals_Clear_signals(
3000b5a8: e1a0000a mov r0, sl <== NOT EXECUTED 3000b5ac: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b5b0: e1a0300c mov r3, ip <== NOT EXECUTED 3000b5b4: e58dc000 str ip, [sp] <== NOT EXECUTED 3000b5b8: eb0017a7 bl 3001145c <_POSIX_signals_Clear_signals> <== NOT EXECUTED 3000b5bc: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
3000b5c0: e3a01001 mov r1, #1 <== NOT EXECUTED
3000b5c4: e3a03000 mov r3, #0 <== NOT EXECUTED
3000b5c8: e985000a stmib r5, {r1, r3} <== NOT EXECUTED
return the_info->si_signo;
3000b5cc: e5954000 ldr r4, [r5] <== NOT EXECUTED
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
3000b5d0: e1a00004 mov r0, r4 <== NOT EXECUTED
3000b5d4: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000b5d8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, 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;
3000b5dc: e59f20c4 ldr r2, [pc, #196] ; 3000b6a8 <sigtimedwait+0x244><== NOT EXECUTED
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
3000b5e0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000b5e4: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000b5e8: e5850000 str r0, [r5] <== NOT EXECUTED
++level;
3000b5ec: e2811001 add r1, r1, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000b5f0: e5821000 str r1, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
3000b5f4: e3a02004 mov r2, #4 <== NOT EXECUTED 3000b5f8: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
the_thread->Wait.option = *set;
3000b5fc: e5961000 ldr r1, [r6] <== NOT EXECUTED
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
3000b600: e59f20a4 ldr r2, [pc, #164] ; 3000b6ac <sigtimedwait+0x248><== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
3000b604: e5831030 str r1, [r3, #48] ; 0x30 <== NOT EXECUTED
the_thread->Wait.return_argument = the_info;
3000b608: e5835028 str r5, [r3, #40] ; 0x28 <== NOT EXECUTED
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
3000b60c: 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;
3000b610: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b614: e5823030 str r3, [r2, #48] ; 0x30 <== NOT EXECUTED 3000b618: e129f008 msr CPSR_fc, r8 <== 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 );
3000b61c: e1a00002 mov r0, r2 <== NOT EXECUTED 3000b620: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b624: e59f2084 ldr r2, [pc, #132] ; 3000b6b0 <sigtimedwait+0x24c><== NOT EXECUTED 3000b628: eb000d11 bl 3000ea74 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b62c: eb000bda bl 3000e59c <_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 );
3000b630: e3a0c000 mov ip, #0 <== NOT EXECUTED 3000b634: e5951000 ldr r1, [r5] <== NOT EXECUTED 3000b638: e1a0300c mov r3, ip <== NOT EXECUTED 3000b63c: e1a0000a mov r0, sl <== NOT EXECUTED 3000b640: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b644: e58dc000 str ip, [sp] <== NOT EXECUTED 3000b648: eb001783 bl 3001145c <_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)
3000b64c: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED 3000b650: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000b654: e3530004 cmp r3, #4 <== NOT EXECUTED 3000b658: 1a000005 bne 3000b674 <sigtimedwait+0x210> <== NOT EXECUTED
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
3000b65c: e5954000 ldr r4, [r5] <== NOT EXECUTED 3000b660: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000b664: e2442001 sub r2, r4, #1 <== NOT EXECUTED 3000b668: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b66c: e0133211 ands r3, r3, r1, lsl r2 <== NOT EXECUTED 3000b670: 1affffd6 bne 3000b5d0 <sigtimedwait+0x16c> <== NOT EXECUTED
errno = _Thread_Executing->Wait.return_code;
3000b674: eb00228d bl 300140b0 <__errno> <== NOT EXECUTED 3000b678: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED
return -1;
3000b67c: e3e04000 mvn r4, #0 <== NOT EXECUTED
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
3000b680: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000b684: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
3000b688: eaffffd0 b 3000b5d0 <sigtimedwait+0x16c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
3000b68c: eb002287 bl 300140b0 <__errno> <== NOT EXECUTED 3000b690: e3a03016 mov r3, #22 <== NOT EXECUTED 3000b694: e5803000 str r3, [r0] <== NOT EXECUTED 3000b698: e3e04000 mvn r4, #0 <== NOT EXECUTED 3000b69c: eaffffcb b 3000b5d0 <sigtimedwait+0x16c> <== NOT EXECUTED
3000d630 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
3000d630: e92d4010 push {r4, lr} <== NOT EXECUTED
3000d634: e1a04001 mov r4, r1 <== NOT EXECUTED
int status;
status = sigtimedwait( set, NULL, NULL );
3000d638: e3a01000 mov r1, #0 <== NOT EXECUTED 3000d63c: e1a02001 mov r2, r1 <== NOT EXECUTED 3000d640: ebffff64 bl 3000d3d8 <sigtimedwait> <== NOT EXECUTED
if ( status != -1 ) {
3000d644: e3700001 cmn r0, #1 <== NOT EXECUTED 3000d648: 0a000005 beq 3000d664 <sigwait+0x34> <== NOT EXECUTED
if ( sig )
3000d64c: e3540000 cmp r4, #0 <== NOT EXECUTED
*sig = status;
3000d650: 15840000 strne r0, [r4] <== NOT EXECUTED
return 0;
3000d654: 13a00000 movne r0, #0 <== NOT EXECUTED
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
3000d658: 18bd8010 popne {r4, pc} <== NOT EXECUTED
*sig = status;
return 0;
3000d65c: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
3000d660: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( sig )
*sig = status;
return 0;
}
return errno;
3000d664: eb0021ba bl 30015d54 <__errno> <== NOT EXECUTED
3000d668: e5900000 ldr r0, [r0] <== NOT EXECUTED
3000d66c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000d628 <sigwaitinfo>:
int sigwaitinfo(
const sigset_t *set,
siginfo_t *info
)
{
return sigtimedwait( set, info, NULL );
3000d628: e3a02000 mov r2, #0 <== NOT EXECUTED 3000d62c: eaffff69 b 3000d3d8 <sigtimedwait> <== NOT EXECUTED
3000a1bc <sysconf>:
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
3000a1bc: e3500002 cmp r0, #2 <== NOT EXECUTED
*/
long sysconf(
int name
)
{
3000a1c0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( name == _SC_CLK_TCK )
3000a1c4: 0a00000b beq 3000a1f8 <sysconf+0x3c> <== NOT EXECUTED
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
3000a1c8: e3500004 cmp r0, #4 <== NOT EXECUTED 3000a1cc: 0a00000e beq 3000a20c <sysconf+0x50> <== NOT EXECUTED
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
3000a1d0: e3500033 cmp r0, #51 ; 0x33 <== NOT EXECUTED
return 1024;
3000a1d4: 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 )
3000a1d8: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return 1024;
if ( name == _SC_PAGESIZE )
3000a1dc: e3500008 cmp r0, #8 <== NOT EXECUTED
return PAGE_SIZE;
3000a1e0: 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 )
3000a1e4: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
3000a1e8: e350004f cmp r0, #79 ; 0x4f <== NOT EXECUTED 3000a1ec: 1a000009 bne 3000a218 <sysconf+0x5c> <== NOT EXECUTED
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
3000a1f0: e3a00020 mov r0, #32 <== NOT EXECUTED
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
3000a1f4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
3000a1f8: e59f302c ldr r3, [pc, #44] ; 3000a22c <sysconf+0x70> <== NOT EXECUTED
3000a1fc: e59f002c ldr r0, [pc, #44] ; 3000a230 <sysconf+0x74> <== NOT EXECUTED
3000a200: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
3000a204: eb004653 bl 3001bb58 <__aeabi_uidiv> <== NOT EXECUTED
3000a208: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
3000a20c: e59f3020 ldr r3, [pc, #32] ; 3000a234 <sysconf+0x78> <== NOT EXECUTED
3000a210: e5930000 ldr r0, [r3] <== NOT EXECUTED
3000a214: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
3000a218: eb00225d bl 30012b94 <__errno> <== NOT EXECUTED
3000a21c: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a220: e5803000 str r3, [r0] <== NOT EXECUTED
3000a224: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a228: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b7bc <timer_create>:
timer_t *timerid
)
{
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
3000b7bc: e3500001 cmp r0, #1 <== NOT EXECUTED
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
3000b7c0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000b7c4: e1a04001 mov r4, r1 <== NOT EXECUTED
3000b7c8: e1a05002 mov r5, r2 <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
3000b7cc: 1a000034 bne 3000b8a4 <timer_create+0xe8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
3000b7d0: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b7d4: 0a000032 beq 3000b8a4 <timer_create+0xe8> <== NOT EXECUTED
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
3000b7d8: e3510000 cmp r1, #0 <== NOT EXECUTED 3000b7dc: 0a000009 beq 3000b808 <timer_create+0x4c> <== NOT EXECUTED
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
3000b7e0: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000b7e4: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000b7e8: e3530001 cmp r3, #1 <== NOT EXECUTED 3000b7ec: 8a00002c bhi 3000b8a4 <timer_create+0xe8> <== 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 )
3000b7f0: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 3000b7f4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b7f8: 0a000029 beq 3000b8a4 <timer_create+0xe8> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000b7fc: e2433001 sub r3, r3, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
3000b800: e353001f cmp r3, #31 <== NOT EXECUTED 3000b804: 8a000026 bhi 3000b8a4 <timer_create+0xe8> <== 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;
3000b808: e59f30c0 ldr r3, [pc, #192] ; 3000b8d0 <timer_create+0x114><== NOT EXECUTED 3000b80c: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3000b810: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000b814: 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 );
3000b818: e59f00b4 ldr r0, [pc, #180] ; 3000b8d4 <timer_create+0x118><== NOT EXECUTED 3000b81c: eb000866 bl 3000d9bc <_Objects_Allocate> <== NOT EXECUTED
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
3000b820: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b824: 0a000023 beq 3000b8b8 <timer_create+0xfc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
3000b828: e3a03002 mov r3, #2 <== NOT EXECUTED 3000b82c: e5c0303c strb r3, [r0, #60] ; 0x3c <== NOT EXECUTED
ptimer->thread_id = _Thread_Executing->Object.id;
3000b830: e59f30a0 ldr r3, [pc, #160] ; 3000b8d8 <timer_create+0x11c><== NOT EXECUTED
if ( evp != NULL ) {
3000b834: 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;
3000b838: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000b83c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000b840: e5803038 str r3, [r0, #56] ; 0x38 <== NOT EXECUTED
if ( evp != NULL ) {
ptimer->inf.sigev_notify = evp->sigev_notify;
ptimer->inf.sigev_signo = evp->sigev_signo;
ptimer->inf.sigev_value = evp->sigev_value;
3000b844: 1894000e ldmne r4, {r1, r2, r3} <== NOT EXECUTED
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
if ( evp != NULL ) {
ptimer->inf.sigev_notify = evp->sigev_notify;
ptimer->inf.sigev_signo = evp->sigev_signo;
3000b848: 15802044 strne r2, [r0, #68] ; 0x44 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b84c: e59f2080 ldr r2, [pc, #128] ; 3000b8d4 <timer_create+0x118><== NOT EXECUTED
ptimer->inf.sigev_value = evp->sigev_value;
3000b850: 15803048 strne r3, [r0, #72] ; 0x48 <== NOT EXECUTED
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000b854: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b858: e592201c ldr r2, [r2, #28] <== NOT EXECUTED
}
ptimer->overrun = 0;
3000b85c: e3a04000 mov r4, #0 <== NOT EXECUTED
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
if ( evp != NULL ) {
ptimer->inf.sigev_notify = evp->sigev_notify;
3000b860: 15801040 strne r1, [r0, #64] ; 0x40 <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000b864: e1a01803 lsl r1, r3, #16 <== NOT EXECUTED
ptimer->inf.sigev_signo = evp->sigev_signo;
ptimer->inf.sigev_value = evp->sigev_value;
}
ptimer->overrun = 0;
3000b868: e5804068 str r4, [r0, #104] ; 0x68 <== NOT EXECUTED
ptimer->timer_data.it_value.tv_sec = 0;
3000b86c: e580405c str r4, [r0, #92] ; 0x5c <== NOT EXECUTED
ptimer->timer_data.it_value.tv_nsec = 0;
3000b870: e5804060 str r4, [r0, #96] ; 0x60 <== NOT EXECUTED
ptimer->timer_data.it_interval.tv_sec = 0;
3000b874: e5804054 str r4, [r0, #84] ; 0x54 <== NOT EXECUTED
ptimer->timer_data.it_interval.tv_nsec = 0;
3000b878: e5804058 str r4, [r0, #88] ; 0x58 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000b87c: e5804018 str r4, [r0, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
3000b880: e580402c str r4, [r0, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
3000b884: e5804030 str r4, [r0, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000b888: e5804034 str r4, [r0, #52] ; 0x34 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b88c: e7820721 str r0, [r2, r1, lsr #14] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000b890: 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;
3000b894: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b898: eb000d5a bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000b89c: e1a00004 mov r0, r4 <== NOT EXECUTED
}
3000b8a0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( !evp->sigev_signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
3000b8a4: eb0023b9 bl 30014790 <__errno> <== NOT EXECUTED
3000b8a8: e3a03016 mov r3, #22 <== NOT EXECUTED
3000b8ac: e5803000 str r3, [r0] <== NOT EXECUTED
3000b8b0: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b8b4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
3000b8b8: eb000d52 bl 3000ee08 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
3000b8bc: eb0023b3 bl 30014790 <__errno> <== NOT EXECUTED
3000b8c0: e3a0300b mov r3, #11 <== NOT EXECUTED
3000b8c4: e5803000 str r3, [r0] <== NOT EXECUTED
3000b8c8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b8cc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000ad70 <timer_delete>:
int timer_delete(
timer_t timerid
)
{
3000ad70: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000ad74: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000ad78: 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 *)
3000ad7c: e1a0200d mov r2, sp <== NOT EXECUTED 3000ad80: e59f005c ldr r0, [pc, #92] ; 3000ade4 <timer_delete+0x74> <== NOT EXECUTED 3000ad84: eb0008f5 bl 3000d160 <_Objects_Get> <== NOT EXECUTED
*/
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000ad88: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000ad8c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000ad90: e3550000 cmp r5, #0 <== NOT EXECUTED 3000ad94: 0a000005 beq 3000adb0 <timer_delete+0x40> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000ad98: eb00245b bl 30013f0c <__errno> <== NOT EXECUTED 3000ad9c: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ada0: e5803000 str r3, [r0] <== NOT EXECUTED 3000ada4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000ada8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000adac: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Timer_Information, &ptimer->Object );
3000adb0: e1a01000 mov r1, r0 <== NOT EXECUTED 3000adb4: e59f0028 ldr r0, [pc, #40] ; 3000ade4 <timer_delete+0x74> <== NOT EXECUTED 3000adb8: eb0007d6 bl 3000cd18 <_Objects_Close> <== NOT EXECUTED
ptimer->state = POSIX_TIMER_STATE_FREE;
3000adbc: e3a03001 mov r3, #1 <== NOT EXECUTED 3000adc0: e5c4303c strb r3, [r4, #60] ; 0x3c <== NOT EXECUTED
(void) _Watchdog_Remove( &ptimer->Timer );
3000adc4: e2840010 add r0, r4, #16 <== NOT EXECUTED 3000adc8: eb001068 bl 3000ef70 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free (
POSIX_Timer_Control *the_timer
)
{
_Objects_Free( &_POSIX_Timer_Information, &the_timer->Object );
3000adcc: e59f0010 ldr r0, [pc, #16] ; 3000ade4 <timer_delete+0x74> <== NOT EXECUTED 3000add0: e1a01004 mov r1, r4 <== NOT EXECUTED 3000add4: eb00088a bl 3000d004 <_Objects_Free> <== NOT EXECUTED
_POSIX_Timer_Free( ptimer );
_Thread_Enable_dispatch();
3000add8: eb000c88 bl 3000e000 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000addc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ade0: eafffff0 b 3000ada8 <timer_delete+0x38> <== NOT EXECUTED
3000b90c <timer_getoverrun>:
#include <rtems/posix/timer.h>
int timer_getoverrun(
timer_t timerid
)
{
3000b90c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b910: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000b914: 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 *)
3000b918: e1a0200d mov r2, sp <== NOT EXECUTED 3000b91c: e59f0038 ldr r0, [pc, #56] ; 3000b95c <timer_getoverrun+0x50><== NOT EXECUTED 3000b920: eb0008d7 bl 3000dc84 <_Objects_Get> <== NOT EXECUTED
int overrun;
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000b924: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000b928: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b92c: 0a000006 beq 3000b94c <timer_getoverrun+0x40> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000b930: eb00237a bl 30014720 <__errno> <== NOT EXECUTED 3000b934: e3a03016 mov r3, #22 <== NOT EXECUTED 3000b938: e5803000 str r3, [r0] <== NOT EXECUTED 3000b93c: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
3000b940: e1a00004 mov r0, r4 <== NOT EXECUTED
3000b944: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b948: e8bd8010 pop {r4, pc} <== NOT EXECUTED
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
overrun = ptimer->overrun;
3000b94c: e5904068 ldr r4, [r0, #104] ; 0x68 <== NOT EXECUTED
ptimer->overrun = 0;
3000b950: e5803068 str r3, [r0, #104] ; 0x68 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b954: eb000c72 bl 3000eb24 <_Thread_Enable_dispatch> <== NOT EXECUTED
return overrun;
3000b958: eafffff8 b 3000b940 <timer_getoverrun+0x34> <== NOT EXECUTED
3000b960 <timer_gettime>:
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
3000b960: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
3000b964: e2514000 subs r4, r1, #0 <== NOT EXECUTED
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
3000b968: e24dd00c sub sp, sp, #12 <== NOT EXECUTED 3000b96c: e1a05000 mov r5, r0 <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
3000b970: 0a000019 beq 3000b9dc <timer_gettime+0x7c> <== NOT EXECUTED 3000b974: e59f1074 ldr r1, [pc, #116] ; 3000b9f0 <timer_gettime+0x90><== NOT EXECUTED 3000b978: e1a0000d mov r0, sp <== NOT EXECUTED 3000b97c: eb00060e bl 3000d1bc <_TOD_Get_with_nanoseconds> <== NOT EXECUTED 3000b980: e1a01005 mov r1, r5 <== NOT EXECUTED 3000b984: e59f0068 ldr r0, [pc, #104] ; 3000b9f4 <timer_gettime+0x94><== NOT EXECUTED 3000b988: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000b98c: eb0008bc bl 3000dc84 <_Objects_Get> <== NOT EXECUTED
/* Reads the current time */
_TOD_Get( ¤t_time );
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000b990: e59d6008 ldr r6, [sp, #8] <== NOT EXECUTED 3000b994: e1a05000 mov r5, r0 <== NOT EXECUTED 3000b998: e3560000 cmp r6, #0 <== NOT EXECUTED 3000b99c: 1a00000e bne 3000b9dc <timer_gettime+0x7c> <== NOT EXECUTED
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
3000b9a0: e59f3050 ldr r3, [pc, #80] ; 3000b9f8 <timer_gettime+0x98> <== NOT EXECUTED 3000b9a4: e5952024 ldr r2, [r5, #36] ; 0x24 <== NOT EXECUTED 3000b9a8: e590001c ldr r0, [r0, #28] <== NOT EXECUTED 3000b9ac: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000b9b0: e0800002 add r0, r0, r2 <== NOT EXECUTED
_Watchdog_Ticks_since_boot; /* now */
_Timespec_From_ticks( left, &value->it_value );
3000b9b4: e0630000 rsb r0, r3, r0 <== NOT EXECUTED 3000b9b8: e2841008 add r1, r4, #8 <== NOT EXECUTED 3000b9bc: eb000efb bl 3000f5b0 <_Timespec_From_ticks> <== NOT EXECUTED
value->it_interval = ptimer->timer_data.it_interval;
3000b9c0: e2853054 add r3, r5, #84 ; 0x54 <== NOT EXECUTED
3000b9c4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000b9c8: e884000c stm r4, {r2, r3} <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b9cc: eb000c54 bl 3000eb24 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000b9d0: e1a00006 mov r0, r6 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
3000b9d4: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000b9d8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000b9dc: eb00234f bl 30014720 <__errno> <== NOT EXECUTED 3000b9e0: e3a03016 mov r3, #22 <== NOT EXECUTED 3000b9e4: e5803000 str r3, [r0] <== NOT EXECUTED 3000b9e8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000b9ec: eafffff8 b 3000b9d4 <timer_gettime+0x74> <== NOT EXECUTED
3000a3c4 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
3000a3c4: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr} <== NOT EXECUTED
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
3000a3c8: e2524000 subs r4, r2, #0 <== NOT EXECUTED
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
3000a3cc: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 3000a3d0: e1a05000 mov r5, r0 <== NOT EXECUTED 3000a3d4: e1a08001 mov r8, r1 <== NOT EXECUTED 3000a3d8: e1a07003 mov r7, r3 <== NOT EXECUTED
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
3000a3dc: 0a000067 beq 3000a580 <timer_settime+0x1bc> <== 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) ) ) {
3000a3e0: e2840008 add r0, r4, #8 <== NOT EXECUTED 3000a3e4: eb000f3b bl 3000e0d8 <_Timespec_Is_valid> <== NOT EXECUTED 3000a3e8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a3ec: 0a000063 beq 3000a580 <timer_settime+0x1bc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
3000a3f0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a3f4: eb000f37 bl 3000e0d8 <_Timespec_Is_valid> <== NOT EXECUTED 3000a3f8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a3fc: 0a00005f beq 3000a580 <timer_settime+0x1bc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
3000a400: e3580000 cmp r8, #0 <== NOT EXECUTED 3000a404: 13580004 cmpne r8, #4 <== NOT EXECUTED 3000a408: 1a00005c bne 3000a580 <timer_settime+0x1bc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
3000a40c: e28d6004 add r6, sp, #4 <== NOT EXECUTED
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
3000a410: e3580004 cmp r8, #4 <== NOT EXECUTED
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
3000a414: e894000f ldm r4, {r0, r1, r2, r3} <== NOT EXECUTED
3000a418: e886000f stm r6, {r0, r1, r2, r3} <== NOT EXECUTED
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
3000a41c: 0a000036 beq 3000a4fc <timer_settime+0x138> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
3000a420: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a424: e59f01a8 ldr r0, [pc, #424] ; 3000a5d4 <timer_settime+0x210><== NOT EXECUTED 3000a428: e28d2024 add r2, sp, #36 ; 0x24 <== NOT EXECUTED 3000a42c: eb0008f5 bl 3000c808 <_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 ) {
3000a430: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000a434: e1a05000 mov r5, r0 <== NOT EXECUTED 3000a438: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a43c: 1a00004f bne 3000a580 <timer_settime+0x1bc> <== 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 ) {
3000a440: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3000a444: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a448: 1a000002 bne 3000a458 <timer_settime+0x94> <== NOT EXECUTED 3000a44c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000a450: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a454: 0a00004e beq 3000a594 <timer_settime+0x1d0> <== NOT EXECUTED
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
3000a458: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a45c: eb000f51 bl 3000e1a8 <_Timespec_To_ticks> <== NOT EXECUTED 3000a460: e5850064 str r0, [r5, #100] ; 0x64 <== NOT EXECUTED
initial_period = _Timespec_To_ticks( &normalize.it_value );
3000a464: e28d000c add r0, sp, #12 <== NOT EXECUTED 3000a468: eb000f4e bl 3000e1a8 <_Timespec_To_ticks> <== NOT EXECUTED
activated = _POSIX_Timer_Insert_helper(
3000a46c: e5952008 ldr r2, [r5, #8] <== 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 );
3000a470: e1a01000 mov r1, r0 <== NOT EXECUTED
activated = _POSIX_Timer_Insert_helper(
3000a474: e59f315c ldr r3, [pc, #348] ; 3000a5d8 <timer_settime+0x214><== NOT EXECUTED 3000a478: e2850010 add r0, r5, #16 <== NOT EXECUTED 3000a47c: e58d5000 str r5, [sp] <== NOT EXECUTED 3000a480: eb0018b1 bl 3001074c <_POSIX_Timer_Insert_helper> <== NOT EXECUTED
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
3000a484: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000a488: 0a00004e beq 3000a5c8 <timer_settime+0x204> <== NOT EXECUTED
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
3000a48c: e3570000 cmp r7, #0 <== NOT EXECUTED
*ovalue = ptimer->timer_data;
3000a490: e285c054 add ip, r5, #84 ; 0x54 <== NOT EXECUTED
ptimer->timer_data = normalize;
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
3000a494: e3a0e003 mov lr, #3 <== NOT EXECUTED
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
*ovalue = ptimer->timer_data;
3000a498: 189c000f ldmne ip, {r0, r1, r2, r3} <== NOT EXECUTED
3000a49c: 1887000f stmne r7, {r0, r1, r2, r3} <== NOT EXECUTED
ptimer->timer_data = normalize;
3000a4a0: e896000f ldm r6, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
3000a4a4: e5c5e03c strb lr, [r5, #60] ; 0x3c <== NOT EXECUTED
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
*ovalue = ptimer->timer_data;
ptimer->timer_data = normalize;
3000a4a8: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
3000a4ac: e59f1128 ldr r1, [pc, #296] ; 3000a5dc <timer_settime+0x218><== NOT EXECUTED 3000a4b0: e28d001c add r0, sp, #28 <== NOT EXECUTED 3000a4b4: eb000638 bl 3000bd9c <_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);
3000a4b8: e59f2120 ldr r2, [pc, #288] ; 3000a5e0 <timer_settime+0x21c><== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
3000a4bc: e89000c0 ldm r0, {r6, r7} <== NOT EXECUTED
3000a4c0: e3a03000 mov r3, #0 <== NOT EXECUTED
3000a4c4: e1a00006 mov r0, r6 <== NOT EXECUTED
3000a4c8: e1a01007 mov r1, r7 <== NOT EXECUTED
3000a4cc: eb004ad3 bl 3001d020 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a4d0: e59f2108 ldr r2, [pc, #264] ; 3000a5e0 <timer_settime+0x21c><== NOT EXECUTED 3000a4d4: 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);
3000a4d8: e585006c str r0, [r5, #108] ; 0x6c <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a4dc: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a4e0: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a4e4: eb004c08 bl 3001d50c <__moddi3> <== NOT EXECUTED 3000a4e8: e5850070 str r0, [r5, #112] ; 0x70 <== NOT EXECUTED
ptimer->timer_data = normalize;
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
_TOD_Get( &ptimer->time );
_Thread_Enable_dispatch();
3000a4ec: eb000c6d bl 3000d6a8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a4f0: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
3000a4f4: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
3000a4f8: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
3000a4fc: e59f10d8 ldr r1, [pc, #216] ; 3000a5dc <timer_settime+0x218><== NOT EXECUTED
3000a500: e28d001c add r0, sp, #28 <== NOT EXECUTED
3000a504: eb000624 bl 3000bd9c <_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);
3000a508: e59f20d0 ldr r2, [pc, #208] ; 3000a5e0 <timer_settime+0x21c><== NOT EXECUTED
3000a50c: e8900300 ldm r0, {r8, r9} <== NOT EXECUTED
3000a510: e3a03000 mov r3, #0 <== NOT EXECUTED
3000a514: e1a00008 mov r0, r8 <== NOT EXECUTED
3000a518: e1a01009 mov r1, r9 <== NOT EXECUTED
3000a51c: eb004abf bl 3001d020 <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a520: e59f20b8 ldr r2, [pc, #184] ; 3000a5e0 <timer_settime+0x21c><== NOT EXECUTED 3000a524: 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);
3000a528: e58d0014 str r0, [sp, #20] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3000a52c: e1a01009 mov r1, r9 <== NOT EXECUTED 3000a530: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a534: eb004bf4 bl 3001d50c <__moddi3> <== NOT EXECUTED
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
3000a538: e28d1014 add r1, sp, #20 <== NOT EXECUTED 3000a53c: e58d0018 str r0, [sp, #24] <== NOT EXECUTED 3000a540: e28d000c add r0, sp, #12 <== NOT EXECUTED 3000a544: eb000ef4 bl 3000e11c <_Timespec_Less_than> <== NOT EXECUTED 3000a548: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a54c: 1a00000b bne 3000a580 <timer_settime+0x1bc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
3000a550: e28d100c add r1, sp, #12 <== NOT EXECUTED 3000a554: e1a02001 mov r2, r1 <== NOT EXECUTED 3000a558: e28d0014 add r0, sp, #20 <== NOT EXECUTED 3000a55c: eb000efc bl 3000e154 <_Timespec_Subtract> <== NOT EXECUTED 3000a560: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a564: e59f0068 ldr r0, [pc, #104] ; 3000a5d4 <timer_settime+0x210><== NOT EXECUTED 3000a568: e28d2024 add r2, sp, #36 ; 0x24 <== NOT EXECUTED 3000a56c: eb0008a5 bl 3000c808 <_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 ) {
3000a570: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000a574: e1a05000 mov r5, r0 <== NOT EXECUTED 3000a578: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a57c: 0affffaf beq 3000a440 <timer_settime+0x7c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000a580: eb0022e7 bl 30013124 <__errno> <== NOT EXECUTED 3000a584: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a588: e5803000 str r3, [r0] <== NOT EXECUTED 3000a58c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000a590: eaffffd7 b 3000a4f4 <timer_settime+0x130> <== 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 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
3000a594: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000a598: eb00100d bl 3000e5d4 <_Watchdog_Remove> <== NOT EXECUTED
/* The old data of the timer are returned */
if ( ovalue )
*ovalue = ptimer->timer_data;
3000a59c: e285c054 add ip, r5, #84 ; 0x54 <== NOT EXECUTED
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
/* The old data of the timer are returned */
if ( ovalue )
3000a5a0: e3570000 cmp r7, #0 <== NOT EXECUTED
*ovalue = ptimer->timer_data;
/* The new data are set */
ptimer->timer_data = normalize;
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
3000a5a4: e3a0e004 mov lr, #4 <== NOT EXECUTED
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
/* The old data of the timer are returned */
if ( ovalue )
*ovalue = ptimer->timer_data;
3000a5a8: 189c000f ldmne ip, {r0, r1, r2, r3} <== NOT EXECUTED
3000a5ac: 1887000f stmne r7, {r0, r1, r2, r3} <== NOT EXECUTED
/* The new data are set */
ptimer->timer_data = normalize;
3000a5b0: e896000f ldm r6, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
3000a5b4: e5c5e03c strb lr, [r5, #60] ; 0x3c <== NOT EXECUTED
(void) _Watchdog_Remove( &ptimer->Timer );
/* The old data of the timer are returned */
if ( ovalue )
*ovalue = ptimer->timer_data;
/* The new data are set */
ptimer->timer_data = normalize;
3000a5b8: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
/* Returns with success */
_Thread_Enable_dispatch();
3000a5bc: eb000c39 bl 3000d6a8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a5c0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a5c4: eaffffca b 3000a4f4 <timer_settime+0x130> <== NOT EXECUTED
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
_Thread_Enable_dispatch();
3000a5c8: eb000c36 bl 3000d6a8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a5cc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a5d0: eaffffc7 b 3000a4f4 <timer_settime+0x130> <== NOT EXECUTED
3000a558 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
3000a558: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000a55c: e59f40e8 ldr r4, [pc, #232] ; 3000a64c <ualarm+0xf4> <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
3000a560: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000a564: e594601c ldr r6, [r4, #28] <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
3000a568: e1a05000 mov r5, r0 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000a56c: e3560000 cmp r6, #0 <== NOT EXECUTED 3000a570: 0a00001d beq 3000a5ec <ualarm+0x94> <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
3000a574: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a578: eb000fb1 bl 3000e444 <_Watchdog_Remove> <== NOT EXECUTED
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
3000a57c: e2400002 sub r0, r0, #2 <== NOT EXECUTED 3000a580: e3500001 cmp r0, #1 <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
3000a584: 83a06000 movhi r6, #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) ) {
3000a588: 9a00001d bls 3000a604 <ualarm+0xac> <== 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 ) {
3000a58c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a590: 0a000012 beq 3000a5e0 <ualarm+0x88> <== NOT EXECUTED
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
3000a594: e59f30b4 ldr r3, [pc, #180] ; 3000a650 <ualarm+0xf8> <== NOT EXECUTED
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ticks = _Timespec_To_ticks( &tp );
3000a598: e1a0000d mov r0, sp <== 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;
3000a59c: e0832395 umull r2, r3, r5, r3 <== NOT EXECUTED 3000a5a0: e1a03923 lsr r3, r3, #18 <== NOT EXECUTED
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
3000a5a4: e0632283 rsb r2, r3, r3, lsl #5 <== NOT EXECUTED
3000a5a8: e0622302 rsb r2, r2, r2, lsl #6 <== NOT EXECUTED
3000a5ac: e0832182 add r2, r3, r2, lsl #3 <== NOT EXECUTED
3000a5b0: e0455302 sub r5, r5, r2, lsl #6 <== NOT EXECUTED
3000a5b4: e0652285 rsb r2, r5, r5, lsl #5 <== NOT EXECUTED
3000a5b8: e0855102 add r5, r5, r2, lsl #2 <== NOT EXECUTED
3000a5bc: e1a05185 lsl r5, r5, #3 <== NOT EXECUTED
3000a5c0: e88d0028 stm sp, {r3, r5} <== NOT EXECUTED
ticks = _Timespec_To_ticks( &tp );
3000a5c4: eb000e65 bl 3000df60 <_Timespec_To_ticks> <== NOT EXECUTED
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
3000a5c8: e1a0000d mov r0, sp <== NOT EXECUTED 3000a5cc: eb000e63 bl 3000df60 <_Timespec_To_ticks> <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a5d0: e59f1074 ldr r1, [pc, #116] ; 3000a64c <ualarm+0xf4> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a5d4: e584000c str r0, [r4, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a5d8: e59f0074 ldr r0, [pc, #116] ; 3000a654 <ualarm+0xfc> <== NOT EXECUTED 3000a5dc: eb000f2b bl 3000e290 <_Watchdog_Insert> <== NOT EXECUTED
}
return remaining;
}
3000a5e0: e1a00006 mov r0, r6 <== NOT EXECUTED
3000a5e4: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000a5e8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000a5ec: e59f3064 ldr r3, [pc, #100] ; 3000a658 <ualarm+0x100> <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a5f0: e5846008 str r6, [r4, #8] <== NOT EXECUTED
the_watchdog->routine = routine;
3000a5f4: e584301c str r3, [r4, #28] <== NOT EXECUTED
the_watchdog->id = id;
3000a5f8: e5846020 str r6, [r4, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000a5fc: e5846024 str r6, [r4, #36] ; 0x24 <== NOT EXECUTED 3000a600: eaffffe1 b 3000a58c <ualarm+0x34> <== 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);
3000a604: e594200c ldr r2, [r4, #12] <== NOT EXECUTED 3000a608: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED 3000a60c: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 3000a610: e0800002 add r0, r0, r2 <== NOT EXECUTED
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
3000a614: e0630000 rsb r0, r3, r0 <== NOT EXECUTED 3000a618: e1a0100d mov r1, sp <== NOT EXECUTED 3000a61c: eb000e3e bl 3000df1c <_Timespec_From_ticks> <== NOT EXECUTED
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
remaining += tp.tv_nsec / 1000;
3000a620: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3000a624: e59f0030 ldr r0, [pc, #48] ; 3000a65c <ualarm+0x104> <== 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;
3000a628: e59d3000 ldr r3, [sp] <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
3000a62c: e0c01092 smull r1, r0, r2, r0 <== 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;
3000a630: e0631283 rsb r1, r3, r3, lsl #5 <== NOT EXECUTED 3000a634: e0611301 rsb r1, r1, r1, lsl #6 <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
3000a638: e1a02fc2 asr r2, r2, #31 <== 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;
3000a63c: e0833181 add r3, r3, r1, lsl #3 <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
3000a640: e0622340 rsb r2, r2, r0, asr #6 <== NOT EXECUTED 3000a644: e0826303 add r6, r2, r3, lsl #6 <== NOT EXECUTED 3000a648: eaffffcf b 3000a58c <ualarm+0x34> <== NOT EXECUTED
3000a58c <vfork>:
#include <unistd.h>
pid_t vfork(void)
{
return -1;
}
3000a58c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000a590: e12fff1e bx lr <== NOT EXECUTED
3000a594 <wait>:
#include <rtems/seterr.h>
int wait(
int *stat_loc
)
{
3000a594: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a598: eb002260 bl 30012f20 <__errno> <== NOT EXECUTED 3000a59c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a5a0: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a5a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a5a8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a5ac <waitpid>:
int waitpid(
pid_t pid,
int *stat_loc,
int options
)
{
3000a5ac: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000a5b0: eb00225a bl 30012f20 <__errno> <== NOT EXECUTED 3000a5b4: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000a5b8: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000a5bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a5c0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED