0004af78 <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(); ticks = microseconds / microseconds_per_tick;
4af78: 41f9 0006 1df8 lea 61df8 <Configuration+0xc>,%a0
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
4af7e: 4e56 0000 linkw %fp,#0
* 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;
4af82: 202e 0008 movel %fp@(8),%d0 4af86: 4c50 0001 remul %a0@,%d1,%d0 4af8a: 4c50 0000 remul %a0@,%d0,%d0
if ( (microseconds % microseconds_per_tick) != 0 )
4af8e: 4a81 tstl %d1
4af90: 6702 beqs 4af94 <TOD_MICROSECONDS_TO_TICKS+0x1c> <== ALWAYS TAKEN
ticks += 1;
4af92: 5280 addql #1,%d0 <== NOT EXECUTED
return ticks;
}
4af94: 4e5e unlk %fp <== NOT EXECUTED
00046e08 <TOD_MILLISECONDS_TO_TICKS>:
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
46e08: 4e56 0000 linkw %fp,#0
/** * 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();
46e0c: 2039 0005 e0d8 movel 5e0d8 <Configuration+0xc>,%d0
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
46e12: 2f02 movel %d2,%sp@-
/** * 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();
46e14: 243c 0000 03e8 movel #1000,%d2 46e1a: 4c42 0000 remul %d2,%d0,%d0
ticks = milliseconds / milliseconds_per_tick;
46e1e: 242e 0008 movel %fp@(8),%d2 46e22: 4c40 2001 remul %d0,%d1,%d2 46e26: 4c40 2002 remul %d0,%d2,%d2 46e2a: 2002 movel %d2,%d0
if ( (milliseconds % milliseconds_per_tick) != 0 )
46e2c: 4a81 tstl %d1
46e2e: 6702 beqs 46e32 <TOD_MILLISECONDS_TO_TICKS+0x2a> <== ALWAYS TAKEN
ticks += 1;
46e30: 5280 addql #1,%d0 <== NOT EXECUTED
return ticks;
}
46e32: 241f movel %sp@+,%d2
46e34: 4e5e unlk %fp <== NOT EXECUTED
000484ac <_CORE_RWLock_Release>:
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
484ac: 223c 0000 0700 movel #1792,%d1
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
484b2: 4e56 fff0 linkw %fp,#-16
ISR_Level level; Thread_Control *executing = _Thread_Executing;
484b6: 2079 0006 19ce moveal 619ce <_Per_CPU_Information+0xc>,%a0
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
484bc: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 484c0: 246e 0008 moveal %fp@(8),%a2
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
484c4: 40c0 movew %sr,%d0 484c6: 8280 orl %d0,%d1 484c8: 46c1 movew %d1,%sr
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
484ca: 222a 0044 movel %a2@(68),%d1
484ce: 660a bnes 484da <_CORE_RWLock_Release+0x2e>
_ISR_Enable( level );
484d0: 46c0 movew %d0,%sr
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
484d2: 7002 moveq #2,%d0 484d4: 2140 0034 movel %d0,%a0@(52)
return CORE_RWLOCK_SUCCESSFUL;
484d8: 6078 bras 48552 <_CORE_RWLock_Release+0xa6>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
484da: 7401 moveq #1,%d2 484dc: b481 cmpl %d1,%d2
484de: 6610 bnes 484f0 <_CORE_RWLock_Release+0x44> the_rwlock->number_of_readers -= 1;
484e0: 222a 0048 movel %a2@(72),%d1 484e4: 5381 subql #1,%d1 484e6: 2541 0048 movel %d1,%a2@(72)
if ( the_rwlock->number_of_readers != 0 ) {
484ea: 6704 beqs 484f0 <_CORE_RWLock_Release+0x44>
/* must be unlocked again */
_ISR_Enable( level );
484ec: 46c0 movew %d0,%sr
return CORE_RWLOCK_SUCCESSFUL;
484ee: 6062 bras 48552 <_CORE_RWLock_Release+0xa6>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
484f0: 42a8 0034 clrl %a0@(52)
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
484f4: 42aa 0044 clrl %a2@(68)
_ISR_Enable( level );
484f8: 46c0 movew %d0,%sr
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
484fa: 2f0a movel %a2,%sp@- 484fc: 4eb9 0004 9ec4 jsr 49ec4 <_Thread_queue_Dequeue>
if ( next ) {
48502: 588f addql #4,%sp 48504: 4a80 tstl %d0
48506: 674a beqs 48552 <_CORE_RWLock_Release+0xa6>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
48508: 7201 moveq #1,%d1 4850a: 2040 moveal %d0,%a0 4850c: b2a8 0030 cmpl %a0@(48),%d1
48510: 6608 bnes 4851a <_CORE_RWLock_Release+0x6e>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
48512: 7002 moveq #2,%d0 48514: 2540 0044 movel %d0,%a2@(68)
return CORE_RWLOCK_SUCCESSFUL;
48518: 6038 bras 48552 <_CORE_RWLock_Release+0xa6>
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
4851a: 7201 moveq #1,%d1
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
4851c: 52aa 0048 addql #1,%a2@(72)
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
48520: 49f9 0004 a2f8 lea 4a2f8 <_Thread_queue_First>,%a4
if ( !next ||
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 );
48526: 47f9 0004 a1d0 lea 4a1d0 <_Thread_queue_Extract>,%a3
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
4852c: 2541 0044 movel %d1,%a2@(68)
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
48530: 2f0a movel %a2,%sp@- 48532: 4e94 jsr %a4@
if ( !next ||
48534: 588f addql #4,%sp 48536: 4a80 tstl %d0
48538: 6718 beqs 48552 <_CORE_RWLock_Release+0xa6>
4853a: 7401 moveq #1,%d2 4853c: 2040 moveal %d0,%a0 4853e: b4a8 0030 cmpl %a0@(48),%d2
48542: 670e beqs 48552 <_CORE_RWLock_Release+0xa6> <== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
48544: 52aa 0048 addql #1,%a2@(72)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
48548: 2f00 movel %d0,%sp@- 4854a: 2f0a movel %a2,%sp@- 4854c: 4e93 jsr %a3@
}
4854e: 508f addql #8,%sp 48550: 60de bras 48530 <_CORE_RWLock_Release+0x84>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
48552: 4280 clrl %d0 48554: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 4855a: 4e5e unlk %fp
...
00048560 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
48560: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
48564: 486e fffc pea %fp@(-4) 48568: 2f2e 0008 movel %fp@(8),%sp@- 4856c: 4eb9 0004 9bf0 jsr 49bf0 <_Thread_Get>
switch ( location ) {
48572: 508f addql #8,%sp 48574: 4aae fffc tstl %fp@(-4)
48578: 661e bnes 48598 <_CORE_RWLock_Timeout+0x38> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
4857a: 2f00 movel %d0,%sp@- 4857c: 4eb9 0004 a3e4 jsr 4a3e4 <_Thread_queue_Process_timeout>
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
return _Thread_Dispatch_disable_level;
48582: 588f addql #4,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
48584: 2039 0006 156c movel 6156c <_Thread_Dispatch_disable_level>,%d0 4858a: 5380 subql #1,%d0 4858c: 23c0 0006 156c movel %d0,6156c <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
48592: 2039 0006 156c movel 6156c <_Thread_Dispatch_disable_level>,%d0
_Thread_Unnest_dispatch();
break;
}
}
48598: 4e5e unlk %fp <== NOT EXECUTED
00047244 <_CORE_barrier_Wait>:
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
47244: 203c 0000 0700 movel #1792,%d0
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4724a: 4e56 fff4 linkw %fp,#-12
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
4724e: 2279 0006 03ae moveal 603ae <_Per_CPU_Information+0xc>,%a1
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
47254: 48d7 001c moveml %d2-%d4,%sp@ 47258: 206e 0008 moveal %fp@(8),%a0
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
4725c: 42a9 0034 clrl %a1@(52)
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
47260: 242e 000c movel %fp@(12),%d2 47264: 262e 0014 movel %fp@(20),%d3 47268: 282e 0018 movel %fp@(24),%d4
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4726c: 40c1 movew %sr,%d1 4726e: 8081 orl %d1,%d0 47270: 46c0 movew %d0,%sr
the_barrier->number_of_waiting_threads++;
47272: 2028 0048 movel %a0@(72),%d0 47276: 5280 addql #1,%d0 47278: 2140 0048 movel %d0,%a0@(72)
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
4727c: 4aa8 0040 tstl %a0@(64)
47280: 6626 bnes 472a8 <_CORE_barrier_Wait+0x64>
if ( the_barrier->number_of_waiting_threads ==
47282: b0a8 0044 cmpl %a0@(68),%d0
47286: 6620 bnes 472a8 <_CORE_barrier_Wait+0x64>
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
47288: 7001 moveq #1,%d0 4728a: 2340 0034 movel %d0,%a1@(52)
_ISR_Enable( level );
4728e: 46c1 movew %d1,%sr
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
47290: 2d44 0010 movel %d4,%fp@(16) 47294: 2d42 000c movel %d2,%fp@(12)
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
47298: 4cd7 001c moveml %sp@,%d2-%d4
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
_ISR_Enable( level );
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
4729c: 2d48 0008 movel %a0,%fp@(8)
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
472a0: 4e5e unlk %fp
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
_ISR_Enable( level );
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
472a2: 4ef9 0004 bd0c jmp 4bd0c <_CORE_barrier_Release>
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;
472a8: 7001 moveq #1,%d0 472aa: 2140 0030 movel %d0,%a0@(48)
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
472ae: 2348 0044 movel %a0,%a1@(68)
executing->Wait.id = id;
472b2: 2342 0020 movel %d2,%a1@(32)
_ISR_Enable( level );
472b6: 46c1 movew %d1,%sr
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
472b8: 2d43 000c movel %d3,%fp@(12) 472bc: 203c 0004 92cc movel #299724,%d0 472c2: 2d48 0008 movel %a0,%fp@(8)
}
472c6: 4cd7 001c moveml %sp@,%d2-%d4
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
472ca: 2d40 0010 movel %d0,%fp@(16)
}
472ce: 4e5e unlk %fp
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
472d0: 4ef9 0004 8fd4 jmp 48fd4 <_Thread_queue_Enqueue_with_handler>
...
0004675c <_CORE_semaphore_Surrender>:
CORE_semaphore_Status _CORE_semaphore_Surrender(
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
CORE_semaphore_API_mp_support_callout api_semaphore_mp_support
)
{
4675c: 4e56 0000 linkw %fp,#0 46760: 2f0a movel %a2,%sp@- 46762: 246e 0008 moveal %fp@(8),%a2
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
46766: 2f0a movel %a2,%sp@- 46768: 4eb9 0004 807c jsr 4807c <_Thread_queue_Dequeue> 4676e: 588f addql #4,%sp 46770: 4a80 tstl %d0
46772: 6624 bnes 46798 <_CORE_semaphore_Surrender+0x3c>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
46774: 303c 0700 movew #1792,%d0 46778: 40c1 movew %sr,%d1 4677a: 8081 orl %d1,%d0 4677c: 46c0 movew %d0,%sr
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
4677e: 202a 0048 movel %a2@(72),%d0 46782: b0aa 0040 cmpl %a2@(64),%d0
46786: 640a bccs 46792 <_CORE_semaphore_Surrender+0x36> <== NEVER TAKEN
the_semaphore->count += 1;
46788: 5280 addql #1,%d0 4678a: 2540 0048 movel %d0,%a2@(72)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
4678e: 4280 clrl %d0 46790: 6002 bras 46794 <_CORE_semaphore_Surrender+0x38>
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
46792: 7004 moveq #4,%d0 <== NOT EXECUTED
_ISR_Enable( level );
46794: 46c1 movew %d1,%sr 46796: 6002 bras 4679a <_CORE_semaphore_Surrender+0x3e>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
46798: 4280 clrl %d0
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
4679a: 246e fffc moveal %fp@(-4),%a2 4679e: 4e5e unlk %fp
...
000455d8 <_Event_Surrender>:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
455d8: 203c 0000 0700 movel #1792,%d0
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
455de: 4e56 ffec linkw %fp,#-20 455e2: 48d7 043c moveml %d2-%d5/%a2,%sp@ 455e6: 246e 0008 moveal %fp@(8),%a2
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
455ea: 206a 00fe moveal %a2@(254),%a0
option_set = (rtems_option) the_thread->Wait.option;
455ee: 282a 0030 movel %a2@(48),%d4
_ISR_Disable( level );
455f2: 40c1 movew %sr,%d1 455f4: 8081 orl %d1,%d0 455f6: 46c0 movew %d0,%sr
pending_events = api->pending_events; event_condition = (rtems_event_set) the_thread->Wait.count;
455f8: 262a 0024 movel %a2@(36),%d3
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Get(
rtems_event_set the_event_set,
rtems_event_set the_event_condition
)
{
return ( the_event_set & the_event_condition );
455fc: 2003 movel %d3,%d0
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
pending_events = api->pending_events;
455fe: 2410 movel %a0@,%d2 45600: c082 andl %d2,%d0
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
45602: 6700 00ca beqw 456ce <_Event_Surrender+0xf6>
/*
* 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() &&
45606: 4ab9 0005 eff6 tstl 5eff6 <_Per_CPU_Information+0x8>
4560c: 674a beqs 45658 <_Event_Surrender+0x80>
4560e: b5f9 0005 effa cmpal 5effa <_Per_CPU_Information+0xc>,%a2
45614: 6642 bnes 45658 <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
45616: 2279 0005 f3d4 moveal 5f3d4 <_Event_Sync_state>,%a1
/*
* 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 ) &&
4561c: 7a02 moveq #2,%d5 4561e: ba89 cmpl %a1,%d5
45620: 670e beqs 45630 <_Event_Surrender+0x58> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
45622: 2279 0005 f3d4 moveal 5f3d4 <_Event_Sync_state>,%a1
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
45628: 1a3c 0001 moveb #1,%d5 4562c: ba89 cmpl %a1,%d5
4562e: 6628 bnes 45658 <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
45630: b680 cmpl %d0,%d3
45632: 6708 beqs 4563c <_Event_Surrender+0x64>
45634: 0804 0001 btst #1,%d4 45638: 6700 0094 beqw 456ce <_Event_Surrender+0xf6>
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) );
4563c: 2600 movel %d0,%d3 4563e: 4683 notl %d3 45640: c682 andl %d2,%d3 45642: 2083 movel %d3,%a0@
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
45644: 206a 0028 moveal %a2@(40),%a0
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
45648: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
4564c: 2080 movel %d0,%a0@
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
4564e: 7003 moveq #3,%d0 45650: 23c0 0005 f3d4 movel %d0,5f3d4 <_Event_Sync_state> 45656: 6076 bras 456ce <_Event_Surrender+0xf6>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
45658: 2a2a 0010 movel %a2@(16),%d5 4565c: 0285 0000 0100 andil #256,%d5
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
45662: 676a beqs 456ce <_Event_Surrender+0xf6>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
45664: b680 cmpl %d0,%d3
45666: 6706 beqs 4566e <_Event_Surrender+0x96>
45668: 0804 0001 btst #1,%d4
4566c: 6760 beqs 456ce <_Event_Surrender+0xf6> <== NEVER TAKEN
4566e: 2600 movel %d0,%d3 45670: 4683 notl %d3 45672: c682 andl %d2,%d3 45674: 2083 movel %d3,%a0@
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
45676: 206a 0028 moveal %a2@(40),%a0
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
4567a: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
4567e: 2080 movel %d0,%a0@
_ISR_Flash( level );
45680: 203c 0000 0700 movel #1792,%d0 45686: 46c1 movew %d1,%sr 45688: 8081 orl %d1,%d0 4568a: 46c0 movew %d0,%sr
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4568c: 7a02 moveq #2,%d5 4568e: baaa 0050 cmpl %a2@(80),%d5
45692: 6714 beqs 456a8 <_Event_Surrender+0xd0>
_ISR_Enable( level );
45694: 46c1 movew %d1,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
45696: 2f3c 1003 fff8 movel #268697592,%sp@- 4569c: 2f0a movel %a2,%sp@- 4569e: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state> 456a4: 508f addql #8,%sp 456a6: 6028 bras 456d0 <_Event_Surrender+0xf8>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
456a8: 7003 moveq #3,%d0 456aa: 2540 0050 movel %d0,%a2@(80)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
456ae: 46c1 movew %d1,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
456b0: 486a 0048 pea %a2@(72) 456b4: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove> 456ba: 2f3c 1003 fff8 movel #268697592,%sp@- 456c0: 2f0a movel %a2,%sp@- 456c2: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state> 456c8: 4fef 000c lea %sp@(12),%sp 456cc: 6002 bras 456d0 <_Event_Surrender+0xf8>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
456ce: 46c1 movew %d1,%sr
}
456d0: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2 456d6: 4e5e unlk %fp
...
000456dc <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
456dc: 4e56 fffc linkw %fp,#-4 456e0: 2f03 movel %d3,%sp@- 456e2: 2f02 movel %d2,%sp@-
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
456e4: 486e fffc pea %fp@(-4) 456e8: 2f2e 0008 movel %fp@(8),%sp@- 456ec: 4eb9 0004 7da8 jsr 47da8 <_Thread_Get>
switch ( location ) {
456f2: 508f addql #8,%sp 456f4: 4aae fffc tstl %fp@(-4)
456f8: 665c bnes 45756 <_Event_Timeout+0x7a> <== NEVER TAKEN
*
* 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.
*/
_ISR_Disable( level );
456fa: 223c 0000 0700 movel #1792,%d1 45700: 40c2 movew %sr,%d2 45702: 8282 orl %d2,%d1 45704: 46c1 movew %d1,%sr
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
45706: 2040 moveal %d0,%a0 45708: 42a8 0024 clrl %a0@(36)
if ( _Thread_Is_executing( the_thread ) ) {
4570c: b0b9 0005 effa cmpl 5effa <_Per_CPU_Information+0xc>,%d0
45712: 6614 bnes 45728 <_Event_Timeout+0x4c>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
45714: 2239 0005 f3d4 movel 5f3d4 <_Event_Sync_state>,%d1 4571a: 7601 moveq #1,%d3 4571c: b681 cmpl %d1,%d3
4571e: 6608 bnes 45728 <_Event_Timeout+0x4c>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
45720: 7202 moveq #2,%d1 45722: 23c1 0005 f3d4 movel %d1,5f3d4 <_Event_Sync_state>
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
45728: 7606 moveq #6,%d3 4572a: 2040 moveal %d0,%a0 4572c: 2143 0034 movel %d3,%a0@(52)
_ISR_Enable( level );
45730: 46c2 movew %d2,%sr 45732: 2f3c 1003 fff8 movel #268697592,%sp@- 45738: 2f00 movel %d0,%sp@- 4573a: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state>
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
return _Thread_Dispatch_disable_level;
45740: 508f addql #8,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
45742: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0 45748: 5380 subql #1,%d0 4574a: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45750: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
45756: 242e fff4 movel %fp@(-12),%d2 4575a: 262e fff8 movel %fp@(-8),%d3 4575e: 4e5e unlk %fp
...
0004b168 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
4b168: 4e56 ffcc linkw %fp,#-52 4b16c: 202e 0010 movel %fp@(16),%d0 4b170: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 4b174: 246e 0008 moveal %fp@(8),%a2 4b178: 262e 000c movel %fp@(12),%d3
Heap_Block *extend_first_block = NULL; 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;
4b17c: 2403 movel %d3,%d2 4b17e: d480 addl %d0,%d2
uintptr_t const free_size = stats->free_size;
4b180: 206a 0030 moveal %a2@(48),%a0
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
4b184: 282a 0020 movel %a2@(32),%d4
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;
4b188: 2a2a 0010 movel %a2@(16),%d5
uintptr_t const min_block_size = heap->min_block_size;
4b18c: 222a 0014 movel %a2@(20),%d1
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;
4b190: 42ae fff8 clrl %fp@(-8)
Heap_Block *extend_last_block = NULL;
4b194: 42ae fffc clrl %fp@(-4)
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;
4b198: 2d48 fff4 movel %a0,%fp@(-12)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
4b19c: b682 cmpl %d2,%d3 4b19e: 6200 01a6 bhiw 4b346 <_Heap_Extend+0x1de>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
4b1a2: 486e fffc pea %fp@(-4) 4b1a6: 486e fff8 pea %fp@(-8) 4b1aa: 2f01 movel %d1,%sp@- 4b1ac: 2f05 movel %d5,%sp@- 4b1ae: 2f00 movel %d0,%sp@- 4b1b0: 2f03 movel %d3,%sp@- 4b1b2: 4eb9 0004 69e6 jsr 469e6 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
4b1b8: 4fef 0018 lea %sp@(24),%sp 4b1bc: 4a00 tstb %d0 4b1be: 6700 0186 beqw 4b346 <_Heap_Extend+0x1de> 4b1c2: 2044 moveal %d4,%a0 4b1c4: 9bcd subal %a5,%a5 4b1c6: 4281 clrl %d1 4b1c8: 97cb subal %a3,%a3 4b1ca: 99cc subal %a4,%a4
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
4b1cc: b888 cmpl %a0,%d4
4b1ce: 6704 beqs 4b1d4 <_Heap_Extend+0x6c>
4b1d0: 2248 moveal %a0,%a1 4b1d2: 6004 bras 4b1d8 <_Heap_Extend+0x70> 4b1d4: 226a 0018 moveal %a2@(24),%a1
uintptr_t const sub_area_end = start_block->prev_size;
4b1d8: 2010 movel %a0@,%d0
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
4b1da: b680 cmpl %d0,%d3
4b1dc: 6406 bccs 4b1e4 <_Heap_Extend+0x7c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
4b1de: b3c2 cmpal %d2,%a1 4b1e0: 6500 0164 bcsw 4b346 <_Heap_Extend+0x1de>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4b1e4: b3c2 cmpal %d2,%a1
4b1e6: 6706 beqs 4b1ee <_Heap_Extend+0x86>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4b1e8: b082 cmpl %d2,%d0
4b1ea: 6206 bhis 4b1f2 <_Heap_Extend+0x8a>
4b1ec: 6006 bras 4b1f4 <_Heap_Extend+0x8c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4b1ee: 2848 moveal %a0,%a4 4b1f0: 6002 bras 4b1f4 <_Heap_Extend+0x8c>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4b1f2: 2208 movel %a0,%d1 4b1f4: 2e00 movel %d0,%d7 4b1f6: 2240 moveal %d0,%a1 4b1f8: 5189 subql #8,%a1 4b1fa: 4c45 7006 remul %d5,%d6,%d7
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
4b1fe: 93c6 subal %d6,%a1
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
4b200: b680 cmpl %d0,%d3
4b202: 6606 bnes 4b20a <_Heap_Extend+0xa2>
start_block->prev_size = extend_area_end;
4b204: 2082 movel %d2,%a0@
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 )
4b206: 2649 moveal %a1,%a3 4b208: 6006 bras 4b210 <_Heap_Extend+0xa8>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
4b20a: b680 cmpl %d0,%d3
4b20c: 6302 blss 4b210 <_Heap_Extend+0xa8>
4b20e: 2a49 moveal %a1,%a5
- 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;
4b210: 70fe moveq #-2,%d0 4b212: c0a9 0004 andl %a1@(4),%d0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4b216: 41f1 0800 lea %a1@(00000000,%d0:l),%a0
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
4b21a: b888 cmpl %a0,%d4
4b21c: 66ae bnes 4b1cc <_Heap_Extend+0x64>
if ( extend_area_begin < heap->area_begin ) {
4b21e: b6aa 0018 cmpl %a2@(24),%d3
4b222: 6406 bccs 4b22a <_Heap_Extend+0xc2>
heap->area_begin = extend_area_begin;
4b224: 2543 0018 movel %d3,%a2@(24) 4b228: 600a bras 4b234 <_Heap_Extend+0xcc>
} else if ( heap->area_end < extend_area_end ) {
4b22a: b4aa 001c cmpl %a2@(28),%d2
4b22e: 6304 blss 4b234 <_Heap_Extend+0xcc>
heap->area_end = extend_area_end;
4b230: 2542 001c movel %d2,%a2@(28)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4b234: 206e fffc moveal %fp@(-4),%a0
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
4b238: 2008 movel %a0,%d0
(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;
4b23a: 7801 moveq #1,%d4
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4b23c: 226e fff8 moveal %fp@(-8),%a1
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
4b240: 9089 subl %a1,%d0
(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;
4b242: 8880 orl %d0,%d4
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
4b244: 2282 movel %d2,%a1@
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4b246: 2344 0004 movel %d4,%a1@(4)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
4b24a: 2080 movel %d0,%a0@
extend_last_block->size_and_flag = 0;
4b24c: 42a8 0004 clrl %a0@(4)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4b250: b3ea 0020 cmpal %a2@(32),%a1
4b254: 6406 bccs 4b25c <_Heap_Extend+0xf4>
heap->first_block = extend_first_block;
4b256: 2549 0020 movel %a1,%a2@(32) 4b25a: 600a bras 4b266 <_Heap_Extend+0xfe>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4b25c: b1ea 0024 cmpal %a2@(36),%a0
4b260: 6304 blss 4b266 <_Heap_Extend+0xfe>
heap->last_block = extend_last_block;
4b262: 2548 0024 movel %a0,%a2@(36)
}
if ( merge_below_block != NULL ) {
4b266: 4a8c tstl %a4
4b268: 6732 beqs 4b29c <_Heap_Extend+0x134>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
4b26a: 202a 0010 movel %a2@(16),%d0
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
4b26e: 5083 addql #8,%d3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
4b270: 2803 movel %d3,%d4 4b272: 4c40 4001 remul %d0,%d1,%d4
if ( remainder != 0 ) {
4b276: 4a81 tstl %d1
4b278: 6704 beqs 4b27e <_Heap_Extend+0x116>
return value - remainder + alignment;
4b27a: d680 addl %d0,%d3 4b27c: 9681 subl %d1,%d3
uintptr_t const new_first_block_begin =
4b27e: 2043 moveal %d3,%a0 4b280: 5188 subql #8,%a0
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 =
4b282: 200c movel %a4,%d0 4b284: 9088 subl %a0,%d0
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;
4b286: 7201 moveq #1,%d1 4b288: 8280 orl %d0,%d1
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;
4b28a: 2094 movel %a4@,%a0@
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4b28c: 2141 0004 movel %d1,%a0@(4)
_Heap_Free_block( heap, new_first_block );
4b290: 2f08 movel %a0,%sp@- 4b292: 2f0a movel %a2,%sp@- 4b294: 4eba feb6 jsr %pc@(4b14c <_Heap_Free_block>) 4b298: 508f addql #8,%sp 4b29a: 600e bras 4b2aa <_Heap_Extend+0x142>
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 ) {
4b29c: 4a81 tstl %d1
4b29e: 670a beqs 4b2aa <_Heap_Extend+0x142>
{
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;
4b2a0: 9288 subl %a0,%d1 4b2a2: 7801 moveq #1,%d4 4b2a4: 8881 orl %d1,%d4 4b2a6: 2144 0004 movel %d4,%a0@(4)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
4b2aa: 4a8b tstl %a3
4b2ac: 6734 beqs 4b2e2 <_Heap_Extend+0x17a>
)
{
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,
4b2ae: 5182 subql #8,%d2
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(
4b2b0: 948b subl %a3,%d2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4b2b2: 2202 movel %d2,%d1 4b2b4: 4c6a 1000 0010 remul %a2@(16),%d0,%d1
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)
| HEAP_PREV_BLOCK_USED;
4b2ba: 7201 moveq #1,%d1 4b2bc: 9480 subl %d0,%d2
);
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)
4b2be: 202b 0004 movel %a3@(4),%d0 4b2c2: 9082 subl %d2,%d0
| HEAP_PREV_BLOCK_USED;
4b2c4: 8280 orl %d0,%d1
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;
4b2c6: 7001 moveq #1,%d0 4b2c8: 2781 2804 movel %d1,%a3@(00000004,%d2:l) 4b2cc: c0ab 0004 andl %a3@(4),%d0
block->size_and_flag = size | flag;
4b2d0: 8480 orl %d0,%d2 4b2d2: 2742 0004 movel %d2,%a3@(4)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
4b2d6: 2f0b movel %a3,%sp@- 4b2d8: 2f0a movel %a2,%sp@- 4b2da: 4eba fe70 jsr %pc@(4b14c <_Heap_Free_block>) 4b2de: 508f addql #8,%sp 4b2e0: 6020 bras 4b302 <_Heap_Extend+0x19a>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
4b2e2: 4a8d tstl %a5
4b2e4: 671c beqs 4b302 <_Heap_Extend+0x19a>
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;
4b2e6: 7201 moveq #1,%d1
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;
4b2e8: 7801 moveq #1,%d4
)
{
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 );
4b2ea: 202e fff8 movel %fp@(-8),%d0 4b2ee: 908d subl %a5,%d0 4b2f0: c2ad 0004 andl %a5@(4),%d1
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
4b2f4: 206e fffc moveal %fp@(-4),%a0
block->size_and_flag = size | flag;
4b2f8: 8280 orl %d0,%d1 4b2fa: 2b41 0004 movel %d1,%a5@(4)
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;
4b2fe: 89a8 0004 orl %d4,%a0@(4)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4b302: 4a8c tstl %a4
4b304: 6610 bnes 4b316 <_Heap_Extend+0x1ae>
4b306: 4a8b tstl %a3
4b308: 660c bnes 4b316 <_Heap_Extend+0x1ae>
_Heap_Free_block( heap, extend_first_block );
4b30a: 2f2e fff8 movel %fp@(-8),%sp@- 4b30e: 2f0a movel %a2,%sp@- 4b310: 4eba fe3a jsr %pc@(4b14c <_Heap_Free_block>) 4b314: 508f addql #8,%sp
*/
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
4b316: 206a 0024 moveal %a2@(36),%a0
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;
4b31a: 7201 moveq #1,%d1
* 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(
4b31c: 202a 0020 movel %a2@(32),%d0 4b320: 9088 subl %a0,%d0
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;
4b322: c2a8 0004 andl %a0@(4),%d1
block->size_and_flag = size | flag;
4b326: 8280 orl %d0,%d1 4b328: 2141 0004 movel %d1,%a0@(4)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
4b32c: 202a 0030 movel %a2@(48),%d0 4b330: 90ae fff4 subl %fp@(-12),%d0
/* Statistics */
stats->size += extended_size;
4b334: d1aa 002c addl %d0,%a2@(44)
if ( extended_size_ptr != NULL )
4b338: 4aae 0014 tstl %fp@(20)
4b33c: 670c beqs 4b34a <_Heap_Extend+0x1e2> <== NEVER TAKEN
*extended_size_ptr = extended_size;
4b33e: 206e 0014 moveal %fp@(20),%a0 4b342: 2080 movel %d0,%a0@ 4b344: 6004 bras 4b34a <_Heap_Extend+0x1e2>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
4b346: 4200 clrb %d0 4b348: 6002 bras 4b34c <_Heap_Extend+0x1e4>
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
4b34a: 7001 moveq #1,%d0
}
4b34c: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5 4b352: 4e5e unlk %fp
...
0004b118 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4b118: 4e56 ffe8 linkw %fp,#-24 4b11c: 206e 0008 moveal %fp@(8),%a0 4b120: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@ 4b124: 202e 000c movel %fp@(12),%d0
/*
* 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 ) {
4b128: 6700 014e beqw 4b278 <_Heap_Free+0x160> 4b12c: 2240 moveal %d0,%a1 4b12e: 5189 subql #8,%a1 4b130: 4c68 0001 0010 remul %a0@(16),%d1,%d0
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
4b136: 2828 0020 movel %a0@(32),%d4
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
4b13a: 93c1 subal %d1,%a1
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;
4b13c: b889 cmpl %a1,%d4
4b13e: 620c bhis 4b14c <_Heap_Free+0x34>
4b140: b3e8 0024 cmpal %a0@(36),%a1 4b144: 53c0 sls %d0 4b146: 49c0 extbl %d0 4b148: 4480 negl %d0 4b14a: 6002 bras 4b14e <_Heap_Free+0x36> 4b14c: 4280 clrl %d0
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
4b14e: 4a00 tstb %d0 4b150: 6700 012a beqw 4b27c <_Heap_Free+0x164>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4b154: 2629 0004 movel %a1@(4),%d3
- 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;
4b158: 70fe moveq #-2,%d0 4b15a: c083 andl %d3,%d0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4b15c: 45f1 0800 lea %a1@(00000000,%d0:l),%a2
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;
4b160: b88a cmpl %a2,%d4
4b162: 620c bhis 4b170 <_Heap_Free+0x58> <== NEVER TAKEN
4b164: b5e8 0024 cmpal %a0@(36),%a2 4b168: 53c1 sls %d1 4b16a: 49c1 extbl %d1 4b16c: 4481 negl %d1 4b16e: 6002 bras 4b172 <_Heap_Free+0x5a>
4b170: 4281 clrl %d1 <== NOT EXECUTED
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
4b172: 4a01 tstb %d1 4b174: 6700 0106 beqw 4b27c <_Heap_Free+0x164>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4b178: 242a 0004 movel %a2@(4),%d2
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4b17c: 0802 0000 btst #0,%d2 4b180: 6700 00fa beqw 4b27c <_Heap_Free+0x164>
- 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;
4b184: 72fe moveq #-2,%d1
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
4b186: 2668 0024 moveal %a0@(36),%a3 4b18a: c481 andl %d1,%d2
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4b18c: b7ca cmpal %a2,%a3
4b18e: 670c beqs 4b19c <_Heap_Free+0x84>
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;
4b190: 7201 moveq #1,%d1 4b192: c2b2 2804 andl %a2@(00000004,%d2:l),%d1
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
4b196: 5381 subql #1,%d1 4b198: 4481 negl %d1 4b19a: 6002 bras 4b19e <_Heap_Free+0x86>
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 ));
4b19c: 4281 clrl %d1
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
4b19e: 1a01 moveb %d1,%d5
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
4b1a0: 0803 0000 btst #0,%d3
4b1a4: 6660 bnes 4b206 <_Heap_Free+0xee>
uintptr_t const prev_size = block->prev_size;
4b1a6: 2611 movel %a1@,%d3
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4b1a8: 93c3 subal %d3,%a1
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;
4b1aa: b889 cmpl %a1,%d4
4b1ac: 620a bhis 4b1b8 <_Heap_Free+0xa0> <== NEVER TAKEN
4b1ae: b3cb cmpal %a3,%a1 4b1b0: 53c1 sls %d1 4b1b2: 49c1 extbl %d1 4b1b4: 4481 negl %d1 4b1b6: 6002 bras 4b1ba <_Heap_Free+0xa2>
4b1b8: 4281 clrl %d1 <== NOT EXECUTED
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
4b1ba: 4a01 tstb %d1 4b1bc: 6700 00be beqw 4b27c <_Heap_Free+0x164>
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;
4b1c0: 7201 moveq #1,%d1 4b1c2: c2a9 0004 andl %a1@(4),%d1
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) ) {
4b1c6: 6700 00b4 beqw 4b27c <_Heap_Free+0x164> 4b1ca: d680 addl %d0,%d3
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
4b1cc: 4a05 tstb %d5
4b1ce: 6724 beqs 4b1f4 <_Heap_Free+0xdc>
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
4b1d0: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + prev_size + next_block_size;
4b1d4: d483 addl %d3,%d2
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1d6: 7201 moveq #1,%d1
Heap_Block *prev = block->prev;
4b1d8: 246a 000c moveal %a2@(12),%a2
prev->next = next;
4b1dc: 254b 0008 movel %a3,%a2@(8) 4b1e0: 8282 orl %d2,%d1
next->prev = prev;
4b1e2: 274a 000c movel %a2,%a3@(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;
4b1e6: 53a8 0038 subql #1,%a0@(56)
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;
4b1ea: 2382 2800 movel %d2,%a1@(00000000,%d2:l)
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;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1ee: 2341 0004 movel %d1,%a1@(4) 4b1f2: 6078 bras 4b26c <_Heap_Free+0x154>
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;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1f4: 7401 moveq #1,%d2
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b1f6: 72fe moveq #-2,%d1
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;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1f8: 8483 orl %d3,%d2
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
4b1fa: 2483 movel %d3,%a2@
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;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b1fc: 2342 0004 movel %d2,%a1@(4)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b200: c3aa 0004 andl %d1,%a2@(4) 4b204: 6066 bras 4b26c <_Heap_Free+0x154>
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
4b206: 4a01 tstb %d1
4b208: 672a beqs 4b234 <_Heap_Free+0x11c>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
4b20a: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + next_block_size;
4b20e: 2202 movel %d2,%d1 4b210: d280 addl %d0,%d1
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b212: 7401 moveq #1,%d2
Heap_Block *prev = old_block->prev;
4b214: 246a 000c moveal %a2@(12),%a2
new_block->next = next;
4b218: 234b 0008 movel %a3,%a1@(8) 4b21c: 8481 orl %d1,%d2
new_block->prev = prev;
4b21e: 234a 000c movel %a2,%a1@(12)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4b222: 2381 1800 movel %d1,%a1@(00000000,%d1:l)
next->prev = new_block;
4b226: 2749 000c movel %a1,%a3@(12)
prev->next = new_block;
4b22a: 2549 0008 movel %a1,%a2@(8)
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4b22e: 2342 0004 movel %d2,%a1@(4) 4b232: 6038 bras 4b26c <_Heap_Free+0x154>
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;
4b234: 7201 moveq #1,%d1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4b236: 74fe moveq #-2,%d2
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;
4b238: 8280 orl %d0,%d1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
4b23a: 2668 0008 moveal %a0@(8),%a3
new_block->next = next;
new_block->prev = block_before;
4b23e: 2348 000c movel %a0,%a1@(12) 4b242: 2341 0004 movel %d1,%a1@(4)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
4b246: 2228 0038 movel %a0@(56),%d1 4b24a: 5281 addql #1,%d1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
4b24c: 234b 0008 movel %a3,%a1@(8)
} 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;
4b250: c5aa 0004 andl %d2,%a2@(4)
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
4b254: 2749 000c movel %a1,%a3@(12)
next_block->prev_size = block_size;
4b258: 2480 movel %d0,%a2@
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
4b25a: 2149 0008 movel %a1,%a0@(8)
/* Statistics */
++stats->free_blocks;
4b25e: 2141 0038 movel %d1,%a0@(56)
if ( stats->max_free_blocks < stats->free_blocks ) {
4b262: b2a8 003c cmpl %a0@(60),%d1
4b266: 6304 blss 4b26c <_Heap_Free+0x154>
stats->max_free_blocks = stats->free_blocks;
4b268: 2141 003c movel %d1,%a0@(60)
}
}
/* Statistics */
--stats->used_blocks;
4b26c: 53a8 0040 subql #1,%a0@(64)
++stats->frees;
4b270: 52a8 0050 addql #1,%a0@(80)
stats->free_size += block_size;
4b274: d1a8 0030 addl %d0,%a0@(48)
* 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;
4b278: 7001 moveq #1,%d0 4b27a: 6002 bras 4b27e <_Heap_Free+0x166>
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
_HAssert( false );
return( false );
4b27c: 4200 clrb %d0
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4b27e: 4cd7 0c3c moveml %sp@,%d2-%d5/%a2-%a3 4b282: 4e5e unlk %fp
...
0004697e <_Heap_Get_first_and_last_block>:
uintptr_t page_size,
uintptr_t min_block_size,
Heap_Block **first_block_ptr,
Heap_Block **last_block_ptr
)
{
4697e: 4e56 fff4 linkw %fp,#-12 46982: 206e 0008 moveal %fp@(8),%a0
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
46986: 2008 movel %a0,%d0 46988: 5080 addql #8,%d0
uintptr_t page_size,
uintptr_t min_block_size,
Heap_Block **first_block_ptr,
Heap_Block **last_block_ptr
)
{
4698a: 48d7 001c moveml %d2-%d4,%sp@ 4698e: 222e 0010 movel %fp@(16),%d1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
46992: 2800 movel %d0,%d4 46994: 242e 000c movel %fp@(12),%d2
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
46998: 43f0 2800 lea %a0@(00000000,%d2:l),%a1 4699c: 4c41 4003 remul %d1,%d3,%d4
if ( remainder != 0 ) {
469a0: 4a83 tstl %d3
469a2: 6704 beqs 469a8 <_Heap_Get_first_and_last_block+0x2a>
return value - remainder + alignment;
469a4: d081 addl %d1,%d0 469a6: 9083 subl %d3,%d0
_Heap_Align_down( heap_area_size - overhead, page_size );
Heap_Block *const first_block = (Heap_Block *) first_block_begin;
Heap_Block *const last_block =
_Heap_Block_at( first_block, first_block_size );
if (
469a8: b1c9 cmpal %a1,%a0
469aa: 622e bhis 469da <_Heap_Get_first_and_last_block+0x5c>
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);
469ac: 2240 moveal %d0,%a1 469ae: 5189 subql #8,%a1
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
469b0: 9088 subl %a0,%d0
Heap_Block *const last_block =
_Heap_Block_at( first_block, first_block_size );
if (
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
469b2: b082 cmpl %d2,%d0
469b4: 6424 bccs 469da <_Heap_Get_first_and_last_block+0x5c>
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);
uintptr_t const first_block_size =
_Heap_Align_down( heap_area_size - overhead, page_size );
469b6: 9480 subl %d0,%d2 469b8: 2002 movel %d2,%d0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
469ba: 2602 movel %d2,%d3 469bc: 4c41 3002 remul %d1,%d2,%d3 469c0: 9082 subl %d2,%d0
_Heap_Block_at( first_block, first_block_size );
if (
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
|| first_block_size < min_block_size
469c2: b0ae 0014 cmpl %fp@(20),%d0
469c6: 6512 bcss 469da <_Heap_Get_first_and_last_block+0x5c><== NEVER TAKEN
) {
/* Invalid area or area too small */
return false;
}
*first_block_ptr = first_block;
469c8: 206e 0018 moveal %fp@(24),%a0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
469cc: d089 addl %a1,%d0 469ce: 2089 movel %a1,%a0@ 469d0: 206e 001c moveal %fp@(28),%a0 469d4: 2080 movel %d0,%a0@
*last_block_ptr = last_block;
return true;
469d6: 7001 moveq #1,%d0 469d8: 6002 bras 469dc <_Heap_Get_first_and_last_block+0x5e>
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
|| first_block_size < min_block_size
) {
/* Invalid area or area too small */
return false;
469da: 4200 clrb %d0
*first_block_ptr = first_block;
*last_block_ptr = last_block;
return true;
}
469dc: 4cd7 001c moveml %sp@,%d2-%d4
469e0: 4e5e unlk %fp <== NOT EXECUTED
0005b19c <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
5b19c: 4e56 0000 linkw %fp,#0 5b1a0: 202e 000c movel %fp@(12),%d0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
5b1a4: 2040 moveal %d0,%a0 5b1a6: 5188 subql #8,%a0 5b1a8: 226e 0008 moveal %fp@(8),%a1 5b1ac: 2f02 movel %d2,%sp@- 5b1ae: 2400 movel %d0,%d2 5b1b0: 4c69 2001 0010 remul %a1@(16),%d1,%d2
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
5b1b6: 2429 0020 movel %a1@(32),%d2
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
5b1ba: 91c1 subal %d1,%a0
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;
5b1bc: b488 cmpl %a0,%d2
5b1be: 620c bhis 5b1cc <_Heap_Size_of_alloc_area+0x30>
5b1c0: b1e9 0024 cmpal %a1@(36),%a0 5b1c4: 53c1 sls %d1 5b1c6: 49c1 extbl %d1 5b1c8: 4481 negl %d1 5b1ca: 6002 bras 5b1ce <_Heap_Size_of_alloc_area+0x32> 5b1cc: 4281 clrl %d1
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
5b1ce: 4a01 tstb %d1
5b1d0: 673a beqs 5b20c <_Heap_Size_of_alloc_area+0x70>
- 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;
5b1d2: 72fe moveq #-2,%d1 5b1d4: c2a8 0004 andl %a0@(4),%d1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
5b1d8: 41f0 1800 lea %a0@(00000000,%d1:l),%a0
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;
5b1dc: b488 cmpl %a0,%d2
5b1de: 620c bhis 5b1ec <_Heap_Size_of_alloc_area+0x50> <== NEVER TAKEN
5b1e0: b1e9 0024 cmpal %a1@(36),%a0 5b1e4: 53c1 sls %d1 5b1e6: 49c1 extbl %d1 5b1e8: 4481 negl %d1 5b1ea: 6002 bras 5b1ee <_Heap_Size_of_alloc_area+0x52>
5b1ec: 4281 clrl %d1 <== NOT EXECUTED
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
5b1ee: 4a01 tstb %d1
5b1f0: 671a beqs 5b20c <_Heap_Size_of_alloc_area+0x70> <== NEVER TAKEN
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;
5b1f2: 7201 moveq #1,%d1 5b1f4: c2a8 0004 andl %a0@(4),%d1
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
5b1f8: 6712 beqs 5b20c <_Heap_Size_of_alloc_area+0x70> <== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
5b1fa: 7204 moveq #4,%d1 5b1fc: 9280 subl %d0,%d1 5b1fe: 2001 movel %d1,%d0 5b200: d088 addl %a0,%d0 5b202: 226e 0010 moveal %fp@(16),%a1 5b206: 2280 movel %d0,%a1@
return true;
5b208: 7001 moveq #1,%d0 5b20a: 6002 bras 5b20e <_Heap_Size_of_alloc_area+0x72>
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
5b20c: 4200 clrb %d0
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
5b20e: 241f movel %sp@+,%d2
5b210: 4e5e unlk %fp <== NOT EXECUTED
00047416 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
47416: 4e56 ffd0 linkw %fp,#-48 4741a: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 4741e: 266e 0008 moveal %fp@(8),%a3
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;
47422: 45fa ffac lea %pc@(473d0 <_Heap_Walk_print_nothing>),%a2
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
47426: 242e 000c movel %fp@(12),%d2
uintptr_t const page_size = heap->page_size;
4742a: 282b 0010 movel %a3@(16),%d4
uintptr_t const min_block_size = heap->min_block_size;
4742e: 2a2b 0014 movel %a3@(20),%d5
Heap_Block *const first_block = heap->first_block;
47432: 2c2b 0020 movel %a3@(32),%d6
Heap_Block *const last_block = heap->last_block;
47436: 2e2b 0024 movel %a3@(36),%d7
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
4743a: 4a2e 0013 tstb %fp@(19)
4743e: 6704 beqs 47444 <_Heap_Walk+0x2e>
47440: 45fa ff96 lea %pc@(473d8 <_Heap_Walk_print>),%a2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
47444: 7003 moveq #3,%d0 47446: b0b9 0006 0e44 cmpl 60e44 <_System_state_Current>,%d0 4744c: 6600 02fc bnew 4774a <_Heap_Walk+0x334>
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)(
47450: 2f2b 000c movel %a3@(12),%sp@- 47454: 2f2b 0008 movel %a3@(8),%sp@- 47458: 2f07 movel %d7,%sp@- 4745a: 2f06 movel %d6,%sp@- 4745c: 2f2b 001c movel %a3@(28),%sp@- 47460: 2f2b 0018 movel %a3@(24),%sp@- 47464: 2f05 movel %d5,%sp@- 47466: 2f04 movel %d4,%sp@- 47468: 4879 0005 d0cb pea 5d0cb <_Status_Object_name_errors_to_status+0x5d> 4746e: 42a7 clrl %sp@- 47470: 2f02 movel %d2,%sp@- 47472: 4e92 jsr %a2@
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
47474: 4fef 002c lea %sp@(44),%sp 47478: 4a84 tstl %d4
4747a: 6608 bnes 47484 <_Heap_Walk+0x6e>
(*printer)( source, true, "page size is zero\n" );
4747c: 4879 0005 d15c pea 5d15c <_Status_Object_name_errors_to_status+0xee> 47482: 606c bras 474f0 <_Heap_Walk+0xda>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
47484: 7003 moveq #3,%d0 47486: c084 andl %d4,%d0
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
47488: 670c beqs 47496 <_Heap_Walk+0x80>
(*printer)(
4748a: 2f04 movel %d4,%sp@- 4748c: 4879 0005 d16f pea 5d16f <_Status_Object_name_errors_to_status+0x101> 47492: 6000 02ca braw 4775e <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
47496: 2205 movel %d5,%d1 47498: 4c44 1000 remul %d4,%d0,%d1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
4749c: 4a80 tstl %d0
4749e: 670c beqs 474ac <_Heap_Walk+0x96>
(*printer)(
474a0: 2f05 movel %d5,%sp@- 474a2: 4879 0005 d18d pea 5d18d <_Status_Object_name_errors_to_status+0x11f> 474a8: 6000 02b4 braw 4775e <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
474ac: 2006 movel %d6,%d0 474ae: 5080 addql #8,%d0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
474b0: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if (
474b4: 4a81 tstl %d1
474b6: 670c beqs 474c4 <_Heap_Walk+0xae>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
474b8: 2f06 movel %d6,%sp@- 474ba: 4879 0005 d1b1 pea 5d1b1 <_Status_Object_name_errors_to_status+0x143> 474c0: 6000 029c braw 4775e <_Heap_Walk+0x348>
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;
474c4: 7001 moveq #1,%d0 474c6: 2046 moveal %d6,%a0 474c8: c0a8 0004 andl %a0@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
474cc: 6608 bnes 474d6 <_Heap_Walk+0xc0>
(*printer)(
474ce: 4879 0005 d1e2 pea 5d1e2 <_Status_Object_name_errors_to_status+0x174> 474d4: 601a bras 474f0 <_Heap_Walk+0xda>
- 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;
474d6: 70fe moveq #-2,%d0 474d8: 2047 moveal %d7,%a0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
474da: 2847 moveal %d7,%a4
- 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;
474dc: c0a8 0004 andl %a0@(4),%d0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
474e0: d9c0 addal %d0,%a4
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;
474e2: 7001 moveq #1,%d0 474e4: c0ac 0004 andl %a4@(4),%d0
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
474e8: 6616 bnes 47500 <_Heap_Walk+0xea>
(*printer)(
474ea: 4879 0005 d210 pea 5d210 <_Status_Object_name_errors_to_status+0x1a2> 474f0: 4878 0001 pea 1 <ADD> 474f4: 2f02 movel %d2,%sp@- 474f6: 4e92 jsr %a2@ 474f8: 4fef 000c lea %sp@(12),%sp 474fc: 6000 009e braw 4759c <_Heap_Walk+0x186>
);
return false;
}
if (
47500: bc8c cmpl %a4,%d6
47502: 6708 beqs 4750c <_Heap_Walk+0xf6>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
47504: 4879 0005 d225 pea 5d225 <_Status_Object_name_errors_to_status+0x1b7> 4750a: 60e4 bras 474f0 <_Heap_Walk+0xda>
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
4750c: 262b 0010 movel %a3@(16),%d3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
47510: 220b movel %a3,%d1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
47512: 206b 0008 moveal %a3@(8),%a0 47516: 2d44 fff8 movel %d4,%fp@(-8) 4751a: 2d43 fffc movel %d3,%fp@(-4) 4751e: 6000 0088 braw 475a8 <_Heap_Walk+0x192>
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;
47522: b1eb 0020 cmpal %a3@(32),%a0
47526: 650c bcss 47534 <_Heap_Walk+0x11e>
47528: b1eb 0024 cmpal %a3@(36),%a0 4752c: 53c0 sls %d0 4752e: 49c0 extbl %d0 47530: 4480 negl %d0 47532: 6002 bras 47536 <_Heap_Walk+0x120> 47534: 4280 clrl %d0
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
47536: 4a00 tstb %d0
47538: 660c bnes 47546 <_Heap_Walk+0x130>
(*printer)(
4753a: 2f08 movel %a0,%sp@- 4753c: 4879 0005 d254 pea 5d254 <_Status_Object_name_errors_to_status+0x1e6> 47542: 6000 021a braw 4775e <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
47546: 4be8 0008 lea %a0@(8),%a5
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4754a: 200d movel %a5,%d0 4754c: 262e fffc movel %fp@(-4),%d3 47550: 4c43 0004 remul %d3,%d4,%d0
);
return false;
}
if (
47554: 4a84 tstl %d4
47556: 670c beqs 47564 <_Heap_Walk+0x14e>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
47558: 2f08 movel %a0,%sp@- 4755a: 4879 0005 d274 pea 5d274 <_Status_Object_name_errors_to_status+0x206> 47560: 6000 01fc braw 4775e <_Heap_Walk+0x348>
- 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;
47564: 70fe moveq #-2,%d0
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;
47566: 7601 moveq #1,%d3
- 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;
47568: c0a8 0004 andl %a0@(4),%d0
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;
4756c: c6b0 0804 andl %a0@(00000004,%d0:l),%d3
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
47570: 670c beqs 4757e <_Heap_Walk+0x168>
(*printer)(
47572: 2f08 movel %a0,%sp@- 47574: 4879 0005 d2a4 pea 5d2a4 <_Status_Object_name_errors_to_status+0x236> 4757a: 6000 01e2 braw 4775e <_Heap_Walk+0x348>
);
return false;
}
if ( free_block->prev != prev_block ) {
4757e: 2028 000c movel %a0@(12),%d0 47582: b280 cmpl %d0,%d1
47584: 671c beqs 475a2 <_Heap_Walk+0x18c>
(*printer)(
47586: 2f00 movel %d0,%sp@- 47588: 2f08 movel %a0,%sp@- 4758a: 4879 0005 d2c0 pea 5d2c0 <_Status_Object_name_errors_to_status+0x252> 47590: 4878 0001 pea 1 <ADD> 47594: 2f02 movel %d2,%sp@- 47596: 4e92 jsr %a2@ 47598: 4fef 0014 lea %sp@(20),%sp
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
4759c: 4200 clrb %d0 4759e: 6000 01ac braw 4774c <_Heap_Walk+0x336>
return false;
}
prev_block = free_block;
free_block = free_block->next;
475a2: 2208 movel %a0,%d1 475a4: 2068 0008 moveal %a0@(8),%a0
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 ) {
475a8: b7c8 cmpal %a0,%a3 475aa: 6600 ff76 bnew 47522 <_Heap_Walk+0x10c> 475ae: 282e fff8 movel %fp@(-8),%d4 475b2: 6002 bras 475b6 <_Heap_Walk+0x1a0>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
475b4: 284d moveal %a5,%a4
return true;
}
475b6: 202c 0004 movel %a4@(4),%d0
- 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;
475ba: 76fe moveq #-2,%d3 475bc: c680 andl %d0,%d3 475be: 2d40 fffc movel %d0,%fp@(-4)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
475c2: 4bf4 3800 lea %a4@(00000000,%d3:l),%a5
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;
475c6: bbeb 0020 cmpal %a3@(32),%a5
475ca: 650c bcss 475d8 <_Heap_Walk+0x1c2> <== NEVER TAKEN
475cc: bbeb 0024 cmpal %a3@(36),%a5 475d0: 53c0 sls %d0 475d2: 49c0 extbl %d0 475d4: 4480 negl %d0 475d6: 6002 bras 475da <_Heap_Walk+0x1c4>
475d8: 4280 clrl %d0 <== NOT EXECUTED
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
475da: 4a00 tstb %d0
475dc: 660c bnes 475ea <_Heap_Walk+0x1d4>
(*printer)(
475de: 2f0d movel %a5,%sp@- 475e0: 2f0c movel %a4,%sp@- 475e2: 4879 0005 d2f2 pea 5d2f2 <_Status_Object_name_errors_to_status+0x284> 475e8: 60a6 bras 47590 <_Heap_Walk+0x17a>
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;
475ea: be8c cmpl %a4,%d7 475ec: 56c0 sne %d0 475ee: 2200 movel %d0,%d1 475f0: 4481 negl %d1
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
475f2: 2003 movel %d3,%d0 475f4: 1d41 fffb moveb %d1,%fp@(-5) 475f8: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
475fc: 4a81 tstl %d1
475fe: 6714 beqs 47614 <_Heap_Walk+0x1fe>
47600: 4a2e fffb tstb %fp@(-5)
47604: 670e beqs 47614 <_Heap_Walk+0x1fe>
(*printer)(
47606: 2f03 movel %d3,%sp@- 47608: 2f0c movel %a4,%sp@- 4760a: 4879 0005 d31f pea 5d31f <_Status_Object_name_errors_to_status+0x2b1> 47610: 6000 ff7e braw 47590 <_Heap_Walk+0x17a>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
47614: ba83 cmpl %d3,%d5
47616: 6322 blss 4763a <_Heap_Walk+0x224>
47618: 4a2e fffb tstb %fp@(-5)
4761c: 671c beqs 4763a <_Heap_Walk+0x224> <== NEVER TAKEN
(*printer)(
4761e: 2f05 movel %d5,%sp@- 47620: 2f03 movel %d3,%sp@- 47622: 2f0c movel %a4,%sp@- 47624: 4879 0005 d34d pea 5d34d <_Status_Object_name_errors_to_status+0x2df> 4762a: 4878 0001 pea 1 <ADD> 4762e: 2f02 movel %d2,%sp@- 47630: 4e92 jsr %a2@
block,
block_size,
min_block_size
);
return false;
47632: 4fef 0018 lea %sp@(24),%sp 47636: 6000 ff64 braw 4759c <_Heap_Walk+0x186>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
4763a: b9cd cmpal %a5,%a4
4763c: 6514 bcss 47652 <_Heap_Walk+0x23c>
4763e: 4a2e fffb tstb %fp@(-5)
47642: 670e beqs 47652 <_Heap_Walk+0x23c>
(*printer)(
47644: 2f0d movel %a5,%sp@- 47646: 2f0c movel %a4,%sp@- 47648: 4879 0005 d378 pea 5d378 <_Status_Object_name_errors_to_status+0x30a> 4764e: 6000 ff40 braw 47590 <_Heap_Walk+0x17a>
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;
47652: 7001 moveq #1,%d0 47654: c0ae fffc andl %fp@(-4),%d0 47658: 2d40 fffc movel %d0,%fp@(-4) 4765c: 7001 moveq #1,%d0 4765e: c0ad 0004 andl %a5@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
47662: 6600 00ae bnew 47712 <_Heap_Walk+0x2fc>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
47666: 222b 0008 movel %a3@(8),%d1
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)(
4766a: 43f9 0005 d098 lea 5d098 <_Status_Object_name_errors_to_status+0x2a>,%a1
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
47670: 206c 0008 moveal %a4@(8),%a0 47674: 2d41 fff8 movel %d1,%fp@(-8)
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)(
47678: b1eb 000c cmpal %a3@(12),%a0
4767c: 6710 beqs 4768e <_Heap_Walk+0x278>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
4767e: 43f9 0005 cfe0 lea 5cfe0 <rtems_filesystem_default_pathconf+0xb4>,%a1 47684: b7c8 cmpal %a0,%a3
47686: 6606 bnes 4768e <_Heap_Walk+0x278>
47688: 43f9 0005 d0a7 lea 5d0a7 <_Status_Object_name_errors_to_status+0x39>,%a1
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 ?
4768e: 202c 000c movel %a4@(12),%d0
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)(
47692: 223c 0005 d0b1 movel #381105,%d1 47698: b0ae fff8 cmpl %fp@(-8),%d0
4769c: 6710 beqs 476ae <_Heap_Walk+0x298>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
4769e: 223c 0005 cfe0 movel #380896,%d1 476a4: b7c0 cmpal %d0,%a3
476a6: 6606 bnes 476ae <_Heap_Walk+0x298>
476a8: 223c 0005 d0c1 movel #381121,%d1
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)(
476ae: 2f09 movel %a1,%sp@- 476b0: 2f08 movel %a0,%sp@- 476b2: 2f01 movel %d1,%sp@- 476b4: 2f00 movel %d0,%sp@- 476b6: 2f03 movel %d3,%sp@- 476b8: 2f0c movel %a4,%sp@- 476ba: 4879 0005 d3ac pea 5d3ac <_Status_Object_name_errors_to_status+0x33e> 476c0: 42a7 clrl %sp@- 476c2: 2f02 movel %d2,%sp@- 476c4: 4e92 jsr %a2@
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
476c6: 2015 movel %a5@,%d0 476c8: 4fef 0024 lea %sp@(36),%sp 476cc: b083 cmpl %d3,%d0
476ce: 671e beqs 476ee <_Heap_Walk+0x2d8>
(*printer)(
476d0: 2f0d movel %a5,%sp@- 476d2: 2f00 movel %d0,%sp@- 476d4: 2f03 movel %d3,%sp@- 476d6: 2f0c movel %a4,%sp@- 476d8: 4879 0005 d3e1 pea 5d3e1 <_Status_Object_name_errors_to_status+0x373> 476de: 4878 0001 pea 1 <ADD> 476e2: 2f02 movel %d2,%sp@- 476e4: 4e92 jsr %a2@ 476e6: 4fef 001c lea %sp@(28),%sp 476ea: 6000 feb0 braw 4759c <_Heap_Walk+0x186>
);
return false;
}
if ( !prev_used ) {
476ee: 4aae fffc tstl %fp@(-4)
476f2: 660a bnes 476fe <_Heap_Walk+0x2e8>
(*printer)(
476f4: 2f0c movel %a4,%sp@- 476f6: 4879 0005 d41a pea 5d41a <_Status_Object_name_errors_to_status+0x3ac> 476fc: 6060 bras 4775e <_Heap_Walk+0x348> 476fe: 206b 0008 moveal %a3@(8),%a0 47702: 6008 bras 4770c <_Heap_Walk+0x2f6>
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
47704: b9c8 cmpal %a0,%a4
47706: 673c beqs 47744 <_Heap_Walk+0x32e>
return true;
}
free_block = free_block->next;
47708: 2068 0008 moveal %a0@(8),%a0
)
{
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 ) {
4770c: b7c8 cmpal %a0,%a3
4770e: 66f4 bnes 47704 <_Heap_Walk+0x2ee>
47710: 6044 bras 47756 <_Heap_Walk+0x340>
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
47712: 4aae fffc tstl %fp@(-4)
47716: 6716 beqs 4772e <_Heap_Walk+0x318>
(*printer)(
47718: 2f03 movel %d3,%sp@- 4771a: 2f0c movel %a4,%sp@- 4771c: 4879 0005 d449 pea 5d449 <_Status_Object_name_errors_to_status+0x3db> 47722: 42a7 clrl %sp@- 47724: 2f02 movel %d2,%sp@- 47726: 4e92 jsr %a2@ 47728: 4fef 0014 lea %sp@(20),%sp 4772c: 6016 bras 47744 <_Heap_Walk+0x32e>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
4772e: 2f14 movel %a4@,%sp@- 47730: 2f03 movel %d3,%sp@- 47732: 2f0c movel %a4,%sp@- 47734: 4879 0005 d460 pea 5d460 <_Status_Object_name_errors_to_status+0x3f2> 4773a: 42a7 clrl %sp@- 4773c: 2f02 movel %d2,%sp@- 4773e: 4e92 jsr %a2@ 47740: 4fef 0018 lea %sp@(24),%sp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
47744: bc8d cmpl %a5,%d6 47746: 6600 fe6c bnew 475b4 <_Heap_Walk+0x19e>
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
4774a: 7001 moveq #1,%d0
block = next_block;
} while ( block != first_block );
return true;
}
4774c: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5 47752: 4e5e unlk %fp 47754: 4e75 rts
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
47756: 2f0c movel %a4,%sp@- 47758: 4879 0005 d485 pea 5d485 <_Status_Object_name_errors_to_status+0x417> 4775e: 4878 0001 pea 1 <ADD> 47762: 2f02 movel %d2,%sp@- 47764: 4e92 jsr %a2@ 47766: 4fef 0010 lea %sp@(16),%sp 4776a: 6000 fe30 braw 4759c <_Heap_Walk+0x186>
...
00046bdc <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
46bdc: 4e56 0000 linkw %fp,#0 46be0: 222e 000c movel %fp@(12),%d1 46be4: 2f02 movel %d2,%sp@- 46be6: 242e 0010 movel %fp@(16),%d2
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
46bea: 13c1 0005 ec32 moveb %d1,5ec32 <_Internal_errors_What_happened+0x4>
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
46bf0: 2f02 movel %d2,%sp@-
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
46bf2: 202e 0008 movel %fp@(8),%d0
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
46bf6: 0281 0000 00ff andil #255,%d1
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
46bfc: 23c0 0005 ec2e movel %d0,5ec2e <_Internal_errors_What_happened>
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
46c02: 2f01 movel %d1,%sp@-
)
{
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
46c04: 23c2 0005 ec34 movel %d2,5ec34 <_Internal_errors_What_happened+0x6>
_User_extensions_Fatal( the_source, is_internal, the_error );
46c0a: 2f00 movel %d0,%sp@- 46c0c: 4eb9 0004 884a jsr 4884a <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
46c12: 7005 moveq #5,%d0
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
46c14: 2042 moveal %d2,%a0 46c16: 243c 0000 0700 movel #1792,%d2 46c1c: 23c0 0005 ecdc movel %d0,5ecdc <_System_state_Current> 46c22: 40c0 movew %sr,%d0 46c24: 8082 orl %d2,%d0 46c26: 46c0 movew %d0,%sr
46c28: 2008 movel %a0,%d0 <== NOT EXECUTED 46c2a: 223c dead beef movel #-559038737,%d1 <== NOT EXECUTED 46c30: 4ac8 halt <== NOT EXECUTED
46c32: 4fef 000c lea %sp@(12),%sp 46c36: 60fe bras 46c36 <_Internal_error_Occurred+0x5a>
00046c98 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
46c98: 4e56 fff0 linkw %fp,#-16 46c9c: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 46ca0: 246e 0008 moveal %fp@(8),%a2
* If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 )
46ca4: 4aaa 0014 tstl %a2@(20)
46ca8: 675e beqs 46d08 <_Objects_Allocate+0x70> <== NEVER TAKEN
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
46caa: 240a movel %a2,%d2 46cac: 0682 0000 001c addil #28,%d2 46cb2: 47f9 0004 6414 lea 46414 <_Chain_Get>,%a3 46cb8: 2f02 movel %d2,%sp@- 46cba: 4e93 jsr %a3@
if ( information->auto_extend ) {
46cbc: 588f addql #4,%sp 46cbe: 4a2a 0010 tstb %a2@(16)
46cc2: 6746 beqs 46d0a <_Objects_Allocate+0x72>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
46cc4: 4a80 tstl %d0
46cc6: 6612 bnes 46cda <_Objects_Allocate+0x42>
_Objects_Extend_information( information );
46cc8: 2f0a movel %a2,%sp@- 46cca: 4eb9 0004 6d3c jsr 46d3c <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
46cd0: 2f02 movel %d2,%sp@- 46cd2: 4e93 jsr %a3@
}
if ( the_object ) {
46cd4: 508f addql #8,%sp 46cd6: 4a80 tstl %d0
46cd8: 6730 beqs 46d0a <_Objects_Allocate+0x72>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46cda: 2040 moveal %d0,%a0 46cdc: 4281 clrl %d1 46cde: 4282 clrl %d2 46ce0: 3228 000a movew %a0@(10),%d1 46ce4: 342a 0008 movew %a2@(8),%d2
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
46ce8: 206a 002a moveal %a2@(42),%a0
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46cec: 9282 subl %d2,%d1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
46cee: 342a 0012 movew %a2@(18),%d2 46cf2: 4c42 1001 remul %d2,%d1,%d1
information->inactive_per_block[ block ]--;
46cf6: e589 lsll #2,%d1 46cf8: d1c1 addal %d1,%a0 46cfa: 5390 subql #1,%a0@
information->inactive--;
46cfc: 322a 0028 movew %a2@(40),%d1 46d00: 5381 subql #1,%d1 46d02: 3541 0028 movew %d1,%a2@(40) 46d06: 6002 bras 46d0a <_Objects_Allocate+0x72>
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
return NULL;
46d08: 4280 clrl %d0 <== NOT EXECUTED
);
}
#endif
return the_object;
}
46d0a: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
46d10: 4e5e unlk %fp <== NOT EXECUTED
00046d14 <_Objects_Close>:
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
46d14: 4280 clrl %d0
void _Objects_Close(
Objects_Information *information,
Objects_Control *the_object
)
{
46d16: 4e56 0000 linkw %fp,#0 46d1a: 206e 0008 moveal %fp@(8),%a0 46d1e: 226e 000c moveal %fp@(12),%a1 46d22: 2f0a movel %a2,%sp@- 46d24: 2468 0018 moveal %a0@(24),%a2 46d28: 3029 000a movew %a1@(10),%d0 46d2c: 42b2 0c00 clrl %a2@(00000000,%d0:l:4)
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
}
46d30: 245f moveal %sp@+,%a2 46d32: 4e5e unlk %fp
Objects_Control *the_object
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
46d34: 4ef9 0004 725c jmp 4725c <_Objects_Namespace_remove>
...
00047044 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
47044: 4e56 0000 linkw %fp,#0 47048: 2f03 movel %d3,%sp@- 4704a: 362e 000e movew %fp@(14),%d3 4704e: 2f02 movel %d2,%sp@- 47050: 242e 0008 movel %fp@(8),%d2
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
47054: 4a43 tstw %d3
47056: 673a beqs 47092 <_Objects_Get_information+0x4e>
/*
* 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 );
47058: 2f02 movel %d2,%sp@- 4705a: 4eb9 0004 b288 jsr 4b288 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
47060: 588f addql #4,%sp 47062: 4a80 tstl %d0
47064: 672c beqs 47092 <_Objects_Get_information+0x4e>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
47066: 0283 0000 ffff andil #65535,%d3 4706c: b083 cmpl %d3,%d0
4706e: 6522 bcss 47092 <_Objects_Get_information+0x4e>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
47070: 41f9 0005 eb54 lea 5eb54 <_Objects_Information_table>,%a0 47076: 2070 2c00 moveal %a0@(00000000,%d2:l:4),%a0 4707a: 4a88 tstl %a0
4707c: 6714 beqs 47092 <_Objects_Get_information+0x4e> <== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
4707e: 2030 3c00 movel %a0@(00000000,%d3:l:4),%d0
if ( !info )
47082: 6710 beqs 47094 <_Objects_Get_information+0x50> <== NEVER TAKEN
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
return NULL;
47084: 2040 moveal %d0,%a0 47086: 4a68 000e tstw %a0@(14) 4708a: 56c1 sne %d1 4708c: 49c1 extbl %d1 4708e: c081 andl %d1,%d0 47090: 6002 bras 47094 <_Objects_Get_information+0x50>
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
return NULL;
47092: 4280 clrl %d0
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
47094: 242e fff8 movel %fp@(-8),%d2 47098: 262e fffc movel %fp@(-4),%d3
4709c: 4e5e unlk %fp <== NOT EXECUTED
00053df4 <_Objects_Get_no_protection>:
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
53df4: 7001 moveq #1,%d0
if ( information->maximum >= index ) {
53df6: 4281 clrl %d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
53df8: 4e56 0000 linkw %fp,#0 53dfc: 206e 0008 moveal %fp@(8),%a0
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
53e00: 90a8 0006 subl %a0@(6),%d0 53e04: d0ae 000c addl %fp@(12),%d0
if ( information->maximum >= index ) {
53e08: 3228 000e movew %a0@(14),%d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
53e0c: 226e 0010 moveal %fp@(16),%a1
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
if ( information->maximum >= index ) {
53e10: b081 cmpl %d1,%d0
53e12: 620e bhis 53e22 <_Objects_Get_no_protection+0x2e>
if ( (the_object = information->local_table[ index ]) != NULL ) {
53e14: 2068 0018 moveal %a0@(24),%a0 53e18: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
53e1c: 6704 beqs 53e22 <_Objects_Get_no_protection+0x2e><== NEVER TAKEN
*location = OBJECTS_LOCAL;
53e1e: 4291 clrl %a1@
return the_object;
53e20: 6006 bras 53e28 <_Objects_Get_no_protection+0x34>
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
53e22: 7001 moveq #1,%d0 53e24: 2280 movel %d0,%a1@
return NULL;
53e26: 4280 clrl %d0
}
53e28: 4e5e unlk %fp <== NOT EXECUTED
000477fc <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
477fc: 4e56 fffc linkw %fp,#-4 47800: 222e 0008 movel %fp@(8),%d1 47804: 2f02 movel %d2,%sp@-
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
47806: 4a81 tstl %d1
47808: 660a bnes 47814 <_Objects_Id_to_name+0x18>
4780a: 2079 0005 ff62 moveal 5ff62 <_Per_CPU_Information+0xc>,%a0 47810: 2228 0008 movel %a0@(8),%d1 47814: 7418 moveq #24,%d2 47816: 2001 movel %d1,%d0 47818: e4a8 lsrl %d2,%d0 4781a: 143c 0007 moveb #7,%d2 4781e: c082 andl %d2,%d0
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47820: 143c 0002 moveb #2,%d2 47824: 2040 moveal %d0,%a0 47826: 5388 subql #1,%a0 47828: b488 cmpl %a0,%d2
4782a: 6540 bcss 4786c <_Objects_Id_to_name+0x70> <== NEVER TAKEN
4782c: 6048 bras 47876 <_Objects_Id_to_name+0x7a>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
4782e: 2001 movel %d1,%d0 47830: 741b moveq #27,%d2 47832: e4a8 lsrl %d2,%d0
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
47834: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
if ( !information )
47838: 4a88 tstl %a0
4783a: 6730 beqs 4786c <_Objects_Id_to_name+0x70> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
4783c: 4a28 0032 tstb %a0@(50)
47840: 662a bnes 4786c <_Objects_Id_to_name+0x70> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
47842: 486e fffc pea %fp@(-4) 47846: 2f01 movel %d1,%sp@- 47848: 2f08 movel %a0,%sp@- 4784a: 4eb9 0004 7794 jsr 47794 <_Objects_Get>
if ( !the_object )
47850: 4fef 000c lea %sp@(12),%sp 47854: 4a80 tstl %d0
47856: 6714 beqs 4786c <_Objects_Id_to_name+0x70>
return OBJECTS_INVALID_ID;
*name = the_object->name;
47858: 206e 000c moveal %fp@(12),%a0 4785c: 2240 moveal %d0,%a1 4785e: 20a9 000c movel %a1@(12),%a0@
_Thread_Enable_dispatch();
47862: 4eb9 0004 8434 jsr 48434 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
47868: 4280 clrl %d0 4786a: 6002 bras 4786e <_Objects_Id_to_name+0x72>
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;
4786c: 7003 moveq #3,%d0
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
4786e: 242e fff8 movel %fp@(-8),%d2 47872: 4e5e unlk %fp 47874: 4e75 rts
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
47876: 41f9 0005 fabc lea 5fabc <_Objects_Information_table>,%a0 4787c: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0 47880: 4a88 tstl %a0
47882: 66aa bnes 4782e <_Objects_Id_to_name+0x32>
47884: 60e6 bras 4786c <_Objects_Id_to_name+0x70>
...
00047288 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
47288: 4e56 fff4 linkw %fp,#-12 4728c: 226e 0008 moveal %fp@(8),%a1 47290: 48d7 040c moveml %d2-%d3/%a2,%sp@ 47294: 242e 000c movel %fp@(12),%d2 47298: 202e 0010 movel %fp@(16),%d0 4729c: 246e 0014 moveal %fp@(20),%a2
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
472a0: 4a8a tstl %a2
472a2: 674a beqs 472ee <_Objects_Name_to_id_u32+0x66>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
472a4: 4a82 tstl %d2
472a6: 674a beqs 472f2 <_Objects_Name_to_id_u32+0x6a> <== NEVER TAKEN
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
472a8: 3229 000e movew %a1@(14),%d1
472ac: 6744 beqs 472f2 <_Objects_Name_to_id_u32+0x6a>
472ae: 4a80 tstl %d0
472b0: 672e beqs 472e0 <_Objects_Name_to_id_u32+0x58>
(node == OBJECTS_SEARCH_ALL_NODES ||
472b2: 0c80 7fff ffff cmpil #2147483647,%d0
472b8: 6726 beqs 472e0 <_Objects_Name_to_id_u32+0x58>
node == OBJECTS_SEARCH_LOCAL_NODE ||
472ba: 7601 moveq #1,%d3 472bc: b680 cmpl %d0,%d3
472be: 6632 bnes 472f2 <_Objects_Name_to_id_u32+0x6a> <== NEVER TAKEN
472c0: 601e bras 472e0 <_Objects_Name_to_id_u32+0x58>
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
472c2: 2069 0018 moveal %a1@(24),%a0 472c6: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
if ( !the_object )
472ca: 4a88 tstl %a0
472cc: 670e beqs 472dc <_Objects_Name_to_id_u32+0x54>
continue;
if ( name == the_object->name.name_u32 ) {
472ce: b4a8 000c cmpl %a0@(12),%d2
472d2: 6608 bnes 472dc <_Objects_Name_to_id_u32+0x54>
*id = the_object->id;
472d4: 24a8 0008 movel %a0@(8),%a2@
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
472d8: 4280 clrl %d0 472da: 6018 bras 472f4 <_Objects_Name_to_id_u32+0x6c>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
472dc: 5280 addql #1,%d0 472de: 6008 bras 472e8 <_Objects_Name_to_id_u32+0x60>
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
472e0: 7001 moveq #1,%d0
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
472e2: 0281 0000 ffff andil #65535,%d1 472e8: b280 cmpl %d0,%d1
472ea: 64d6 bccs 472c2 <_Objects_Name_to_id_u32+0x3a>
472ec: 6004 bras 472f2 <_Objects_Name_to_id_u32+0x6a>
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
472ee: 7002 moveq #2,%d0 472f0: 6002 bras 472f4 <_Objects_Name_to_id_u32+0x6c>
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;
472f2: 7001 moveq #1,%d0
#endif }
472f4: 4cd7 040c moveml %sp@,%d2-%d3/%a2
472f8: 4e5e unlk %fp <== NOT EXECUTED
00047470 <_Objects_Set_name>:
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
47470: 4280 clrl %d0
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
47472: 4e56 ffec linkw %fp,#-20 47476: 48d7 3c04 moveml %d2/%a2-%a5,%sp@ 4747a: 2a6e 0008 moveal %fp@(8),%a5
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
4747e: 302d 0034 movew %a5@(52),%d0
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
47482: 246e 0010 moveal %fp@(16),%a2
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
47486: 2f00 movel %d0,%sp@-
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
47488: 286e 000c moveal %fp@(12),%a4
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
4748c: 2f0a movel %a2,%sp@- 4748e: 4eb9 0004 e6f8 jsr 4e6f8 <strnlen>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
47494: 508f addql #8,%sp
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
47496: 2640 moveal %d0,%a3
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
47498: 4a2d 0032 tstb %a5@(50)
4749c: 673c beqs 474da <_Objects_Set_name+0x6a>
char *d;
d = _Workspace_Allocate( length + 1 );
4749e: 486b 0001 pea %a3@(1) 474a2: 4eb9 0004 8e4c jsr 48e4c <_Workspace_Allocate>
if ( !d )
474a8: 588f addql #4,%sp
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
474aa: 2a40 moveal %d0,%a5
if ( !d )
474ac: 4a80 tstl %d0
474ae: 677a beqs 4752a <_Objects_Set_name+0xba> <== NEVER TAKEN
return false;
_Workspace_Free( (void *)the_object->name.name_p );
474b0: 2f2c 000c movel %a4@(12),%sp@- 474b4: 4eb9 0004 8e68 jsr 48e68 <_Workspace_Free>
the_object->name.name_p = NULL;
474ba: 42ac 000c clrl %a4@(12)
strncpy( d, name, length );
474be: 2f0b movel %a3,%sp@- 474c0: 2f0a movel %a2,%sp@- 474c2: 2f0d movel %a5,%sp@- 474c4: 4eb9 0004 e670 jsr 4e670 <strncpy>
d[length] = '\0';
the_object->name.name_p = d;
474ca: 4fef 0010 lea %sp@(16),%sp
_Workspace_Free( (void *)the_object->name.name_p );
the_object->name.name_p = NULL;
strncpy( d, name, length );
d[length] = '\0';
474ce: 4200 clrb %d0 474d0: 1b80 b800 moveb %d0,%a5@(00000000,%a3:l)
the_object->name.name_p = d;
474d4: 294d 000c movel %a5,%a4@(12) 474d8: 604c bras 47526 <_Objects_Set_name+0xb6>
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
474da: 7418 moveq #24,%d2 474dc: 1212 moveb %a2@,%d1 474de: 7020 moveq #32,%d0 474e0: 4840 swap %d0 474e2: 49c1 extbl %d1 474e4: e5a9 lsll %d2,%d1 474e6: 143c 0001 moveb #1,%d2 474ea: b48b cmpl %a3,%d2
474ec: 640a bccs 474f8 <_Objects_Set_name+0x88>
474ee: 102a 0001 moveb %a2@(1),%d0 474f2: 49c0 extbl %d0 474f4: 4840 swap %d0 474f6: 4240 clrw %d0 474f8: 7402 moveq #2,%d2 474fa: 8280 orl %d0,%d1 474fc: 203c 0000 2000 movel #8192,%d0 47502: b48b cmpl %a3,%d2
47504: 6408 bccs 4750e <_Objects_Set_name+0x9e>
47506: 102a 0002 moveb %a2@(2),%d0 4750a: 49c0 extbl %d0 4750c: e188 lsll #8,%d0 4750e: 8081 orl %d1,%d0 47510: 7203 moveq #3,%d1 47512: b28b cmpl %a3,%d1
47514: 6408 bccs 4751e <_Objects_Set_name+0xae>
47516: 142a 0003 moveb %a2@(3),%d2 4751a: 49c2 extbl %d2 4751c: 6002 bras 47520 <_Objects_Set_name+0xb0> 4751e: 7420 moveq #32,%d2 47520: 8082 orl %d2,%d0 47522: 2940 000c movel %d0,%a4@(12)
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
47526: 7001 moveq #1,%d0 47528: 6002 bras 4752c <_Objects_Set_name+0xbc>
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
4752a: 4200 clrb %d0
);
}
return true;
}
4752c: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5 47532: 4e5e unlk %fp
...
000458b0 <_POSIX_Keys_Free_memory>:
#include <rtems/posix/key.h>
void _POSIX_Keys_Free_memory(
POSIX_Keys_Control *the_key
)
{
458b0: 4e56 0000 linkw %fp,#0 458b4: 2f0b movel %a3,%sp@-
uint32_t the_api;
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ )
_Workspace_Free( the_key->Values[ the_api ] );
458b6: 47f9 0004 9910 lea 49910 <_Workspace_Free>,%a3
#include <rtems/posix/key.h>
void _POSIX_Keys_Free_memory(
POSIX_Keys_Control *the_key
)
{
458bc: 2f0a movel %a2,%sp@- 458be: 246e 0008 moveal %fp@(8),%a2
uint32_t the_api;
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ )
_Workspace_Free( the_key->Values[ the_api ] );
458c2: 2f2a 0018 movel %a2@(24),%sp@- 458c6: 4e93 jsr %a3@ 458c8: 2f2a 001c movel %a2@(28),%sp@- 458cc: 4e93 jsr %a3@ 458ce: 2d6a 0020 0008 movel %a2@(32),%fp@(8) 458d4: 508f addql #8,%sp
}
458d6: 246e fff8 moveal %fp@(-8),%a2 458da: 266e fffc moveal %fp@(-4),%a3 458de: 4e5e unlk %fp
)
{
uint32_t the_api;
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ )
_Workspace_Free( the_key->Values[ the_api ] );
458e0: 4ef9 0004 9910 jmp 49910 <_Workspace_Free>
...
0004c5a0 <_POSIX_Keys_Run_destructors>:
4c5a0: 7218 moveq #24,%d1
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
4c5a2: 4e56 ffe8 linkw %fp,#-24
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
4c5a6: 206e 0008 moveal %fp@(8),%a0
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
4c5aa: 48d7 047c moveml %d2-%d6/%a2,%sp@
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
4c5ae: 2428 0008 movel %a0@(8),%d2 4c5b2: 2002 movel %d2,%d0 4c5b4: e2a8 lsrl %d1,%d0 4c5b6: 123c 0007 moveb #7,%d1
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 ];
4c5ba: 0282 0000 ffff andil #65535,%d2 4c5c0: c081 andl %d1,%d0 4c5c2: e58a lsll #2,%d2 4c5c4: 2a00 movel %d0,%d5 4c5c6: 5a85 addql #5,%d5
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
4c5c8: 4286 clrl %d6 4c5ca: 7601 moveq #1,%d3
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
4c5cc: 7201 moveq #1,%d1
for ( index = 1 ; index <= max ; ++index ) {
4c5ce: 3c39 0005 eeee movew 5eeee <_POSIX_Keys_Information+0xe>,%d6 4c5d4: 6030 bras 4c606 <_POSIX_Keys_Run_destructors+0x66>
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
4c5d6: 2079 0005 eef8 moveal 5eef8 <_POSIX_Keys_Information+0x18>,%a0 4c5dc: 2070 4c00 moveal %a0@(00000000,%d4:l:4),%a0
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
4c5e0: 4a88 tstl %a0
4c5e2: 6720 beqs 4c604 <_POSIX_Keys_Run_destructors+0x64>
4c5e4: 4aa8 0010 tstl %a0@(16)
4c5e8: 671a beqs 4c604 <_POSIX_Keys_Run_destructors+0x64>
void *value = key->Values [ thread_api ][ thread_index ];
4c5ea: 2470 5c00 moveal %a0@(00000000,%d5:l:4),%a2 4c5ee: d5c2 addal %d2,%a2 4c5f0: 2252 moveal %a2@,%a1
if ( value != NULL ) {
4c5f2: 4a89 tstl %a1
4c5f4: 670e beqs 4c604 <_POSIX_Keys_Run_destructors+0x64><== ALWAYS TAKEN
key->Values [ thread_api ][ thread_index ] = NULL;
4c5f6: 4292 clrl %a2@ <== NOT EXECUTED
(*key->destructor)( value );
4c5f8: 2f09 movel %a1,%sp@- <== NOT EXECUTED 4c5fa: 2068 0010 moveal %a0@(16),%a0 <== NOT EXECUTED 4c5fe: 4e90 jsr %a0@ <== NOT EXECUTED 4c600: 588f addql #4,%sp <== NOT EXECUTED
done = false;
4c602: 4201 clrb %d1 <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
4c604: 5283 addql #1,%d3 4c606: 4284 clrl %d4 4c608: 3803 movew %d3,%d4 4c60a: bc84 cmpl %d4,%d6
4c60c: 64c8 bccs 4c5d6 <_POSIX_Keys_Run_destructors+0x36>
* 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 ) {
4c60e: 4a01 tstb %d1
4c610: 67b6 beqs 4c5c8 <_POSIX_Keys_Run_destructors+0x28><== NEVER TAKEN
done = false;
}
}
}
}
}
4c612: 4cee 047c ffe8 moveml %fp@(-24),%d2-%d6/%a2
4c618: 4e5e unlk %fp <== NOT EXECUTED
00049fc0 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
49fc0: 4e56 ffe4 linkw %fp,#-28 49fc4: 48d7 043c moveml %d2-%d5/%a2,%sp@
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(
49fc8: 486e fff8 pea %fp@(-8) 49fcc: 242e 0008 movel %fp@(8),%d2 49fd0: 2f02 movel %d2,%sp@- 49fd2: 4879 0006 7144 pea 67144 <_POSIX_Message_queue_Information_fds> 49fd8: 246e 0014 moveal %fp@(20),%a2 49fdc: 162e 001b moveb %fp@(27),%d3 49fe0: 4eb9 0004 ce3c jsr 4ce3c <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
49fe6: 4fef 000c lea %sp@(12),%sp 49fea: 4aae fff8 tstl %fp@(-8) 49fee: 6600 00be bnew 4a0ae <_POSIX_Message_queue_Receive_support+0xee>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
49ff2: 2040 moveal %d0,%a0 49ff4: 7803 moveq #3,%d4 49ff6: 7a01 moveq #1,%d5 49ff8: 2228 0014 movel %a0@(20),%d1 49ffc: c881 andl %d1,%d4 49ffe: ba84 cmpl %d4,%d5
4a000: 660a bnes 4a00c <_POSIX_Message_queue_Receive_support+0x4c>
_Thread_Enable_dispatch();
4a002: 4eb9 0004 dad0 jsr 4dad0 <_Thread_Enable_dispatch> 4a008: 6000 00a4 braw 4a0ae <_POSIX_Message_queue_Receive_support+0xee>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
4a00c: 2068 0010 moveal %a0@(16),%a0
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
4a010: 2028 0066 movel %a0@(102),%d0 4a014: b0ae 0010 cmpl %fp@(16),%d0
4a018: 6316 blss 4a030 <_POSIX_Message_queue_Receive_support+0x70>
_Thread_Enable_dispatch();
4a01a: 4eb9 0004 dad0 jsr 4dad0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
4a020: 4eb9 0005 3158 jsr 53158 <__errno> 4a026: 727a moveq #122,%d1 4a028: 2040 moveal %d0,%a0 4a02a: 2081 movel %d1,%a0@ 4a02c: 6000 008c braw 4a0ba <_POSIX_Message_queue_Receive_support+0xfa>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
4a030: 70ff moveq #-1,%d0 4a032: 2d40 fffc movel %d0,%fp@(-4)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
4a036: 4a03 tstb %d3
4a038: 670a beqs 4a044 <_POSIX_Message_queue_Receive_support+0x84>
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
4a03a: 0801 000e btst #14,%d1 4a03e: 57c0 seq %d0 4a040: 4480 negl %d0 4a042: 6002 bras 4a046 <_POSIX_Message_queue_Receive_support+0x86>
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
4a044: 4200 clrb %d0
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
4a046: 2f2e 001c movel %fp@(28),%sp@- 4a04a: 0280 0000 00ff andil #255,%d0 4a050: 2f00 movel %d0,%sp@- 4a052: 486e fffc pea %fp@(-4) 4a056: 2f2e 000c movel %fp@(12),%sp@- 4a05a: 2f02 movel %d2,%sp@- 4a05c: 4868 001a pea %a0@(26) 4a060: 4eb9 0004 bf28 jsr 4bf28 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
4a066: 4eb9 0004 dad0 jsr 4dad0 <_Thread_Enable_dispatch> 4a06c: 2079 0006 71b6 moveal 671b6 <_Per_CPU_Information+0xc>,%a0
if (msg_prio) {
4a072: 4fef 0018 lea %sp@(24),%sp 4a076: 4a8a tstl %a2
4a078: 670a beqs 4a084 <_POSIX_Message_queue_Receive_support+0xc4><== NEVER TAKEN
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
4a07a: 2028 0024 movel %a0@(36),%d0
4a07e: 6c02 bges 4a082 <_POSIX_Message_queue_Receive_support+0xc2>
4a080: 4480 negl %d0
*msg_prio = _POSIX_Message_queue_Priority_from_core(
4a082: 2480 movel %d0,%a2@
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
4a084: 4aa8 0034 tstl %a0@(52)
4a088: 6606 bnes 4a090 <_POSIX_Message_queue_Receive_support+0xd0>
return length_out;
4a08a: 202e fffc movel %fp@(-4),%d0 4a08e: 602c bras 4a0bc <_POSIX_Message_queue_Receive_support+0xfc>
rtems_set_errno_and_return_minus_one(
4a090: 4eb9 0005 3158 jsr 53158 <__errno> 4a096: 2079 0006 71b6 moveal 671b6 <_Per_CPU_Information+0xc>,%a0 4a09c: 2440 moveal %d0,%a2 4a09e: 2f28 0034 movel %a0@(52),%sp@- 4a0a2: 4eb9 0004 a2d8 jsr 4a2d8 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 4a0a8: 588f addql #4,%sp 4a0aa: 2480 movel %d0,%a2@ 4a0ac: 600c bras 4a0ba <_POSIX_Message_queue_Receive_support+0xfa>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
4a0ae: 4eb9 0005 3158 jsr 53158 <__errno> 4a0b4: 2040 moveal %d0,%a0 4a0b6: 7009 moveq #9,%d0 4a0b8: 2080 movel %d0,%a0@ 4a0ba: 70ff moveq #-1,%d0
}
4a0bc: 4cee 043c ffe4 moveml %fp@(-28),%d2-%d5/%a2 4a0c2: 4e5e unlk %fp
...
0004a450 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
4a450: 4e56 0000 linkw %fp,#0 4a454: 226e 0008 moveal %fp@(8),%a1
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a458: 2069 0102 moveal %a1@(258),%a0
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
4a45c: 4aa8 00d8 tstl %a0@(216)
4a460: 6634 bnes 4a496 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x46><== NEVER TAKEN
4a462: 7001 moveq #1,%d0 4a464: b0a8 00dc cmpl %a0@(220),%d0
4a468: 662c bnes 4a496 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x46>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
4a46a: 4aa8 00e0 tstl %a0@(224)
4a46e: 6726 beqs 4a496 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x46>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
4a470: 2039 0005 f00c movel 5f00c <_Thread_Dispatch_disable_level>,%d0
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
4a476: 4878 ffff pea ffffffff <LESS> 4a47a: 5380 subql #1,%d0 4a47c: 23c0 0005 f00c movel %d0,5f00c <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
4a482: 2039 0005 f00c movel 5f00c <_Thread_Dispatch_disable_level>,%d0 4a488: 2f09 movel %a1,%sp@- 4a48a: 4eb9 0004 aab0 jsr 4aab0 <_POSIX_Thread_Exit> 4a490: 508f addql #8,%sp
} else
_Thread_Enable_dispatch();
}
4a492: 4e5e unlk %fp 4a494: 4e75 rts 4a496: 4e5e unlk %fp
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();
4a498: 4ef9 0004 7eec jmp 47eec <_Thread_Enable_dispatch>
...
0004b58c <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4b58c: 4e56 ffec linkw %fp,#-20 4b590: 48d7 3c04 moveml %d2/%a2-%a5,%sp@ 4b594: 246e 000c moveal %fp@(12),%a2
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4b598: 2f12 movel %a2@,%sp@-
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
4b59a: 242e 0008 movel %fp@(8),%d2 4b59e: 266e 0010 moveal %fp@(16),%a3 4b5a2: 286e 0014 moveal %fp@(20),%a4
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
4b5a6: 4eb9 0004 b568 jsr 4b568 <_POSIX_Priority_Is_valid> 4b5ac: 588f addql #4,%sp 4b5ae: 4a00 tstb %d0
4b5b0: 677a beqs 4b62c <_POSIX_Thread_Translate_sched_param+0xa0><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4b5b2: 4293 clrl %a3@
*budget_callout = NULL;
4b5b4: 4294 clrl %a4@
if ( policy == SCHED_OTHER ) {
4b5b6: 4a82 tstl %d2
4b5b8: 6606 bnes 4b5c0 <_POSIX_Thread_Translate_sched_param+0x34>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4b5ba: 7401 moveq #1,%d2 4b5bc: 2682 movel %d2,%a3@ 4b5be: 6068 bras 4b628 <_POSIX_Thread_Translate_sched_param+0x9c>
return 0;
}
if ( policy == SCHED_FIFO ) {
4b5c0: 7001 moveq #1,%d0 4b5c2: b082 cmpl %d2,%d0
4b5c4: 6762 beqs 4b628 <_POSIX_Thread_Translate_sched_param+0x9c>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
4b5c6: 103c 0002 moveb #2,%d0 4b5ca: b082 cmpl %d2,%d0
4b5cc: 6608 bnes 4b5d6 <_POSIX_Thread_Translate_sched_param+0x4a>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4b5ce: 7202 moveq #2,%d1
return 0;
4b5d0: 4200 clrb %d0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
4b5d2: 2681 movel %d1,%a3@
return 0;
4b5d4: 6058 bras 4b62e <_POSIX_Thread_Translate_sched_param+0xa2>
}
if ( policy == SCHED_SPORADIC ) {
4b5d6: 7004 moveq #4,%d0 4b5d8: b082 cmpl %d2,%d0
4b5da: 6650 bnes 4b62c <_POSIX_Thread_Translate_sched_param+0xa0>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
4b5dc: 4aaa 0008 tstl %a2@(8)
4b5e0: 6606 bnes 4b5e8 <_POSIX_Thread_Translate_sched_param+0x5c>
4b5e2: 4aaa 000c tstl %a2@(12)
4b5e6: 6744 beqs 4b62c <_POSIX_Thread_Translate_sched_param+0xa0><== NEVER TAKEN
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
4b5e8: 4aaa 0010 tstl %a2@(16)
4b5ec: 6606 bnes 4b5f4 <_POSIX_Thread_Translate_sched_param+0x68>
4b5ee: 4aaa 0014 tstl %a2@(20)
4b5f2: 6738 beqs 4b62c <_POSIX_Thread_Translate_sched_param+0xa0><== NEVER TAKEN
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
4b5f4: 486a 0008 pea %a2@(8) 4b5f8: 4bf9 0004 94b8 lea 494b8 <_Timespec_To_ticks>,%a5 4b5fe: 4e95 jsr %a5@
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4b600: 486a 0010 pea %a2@(16)
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 ) <
4b604: 2400 movel %d0,%d2
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
4b606: 4e95 jsr %a5@
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 ) <
4b608: 508f addql #8,%sp 4b60a: b082 cmpl %d2,%d0
4b60c: 621e bhis 4b62c <_POSIX_Thread_Translate_sched_param+0xa0>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
4b60e: 2f2a 0004 movel %a2@(4),%sp@- 4b612: 4eb9 0004 b568 jsr 4b568 <_POSIX_Priority_Is_valid> 4b618: 588f addql #4,%sp 4b61a: 4a00 tstb %d0
4b61c: 670e beqs 4b62c <_POSIX_Thread_Translate_sched_param+0xa0>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
4b61e: 7003 moveq #3,%d0 4b620: 2680 movel %d0,%a3@
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
4b622: 28bc 0004 5f02 movel #286466,%a4@
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
4b628: 4280 clrl %d0 4b62a: 6002 bras 4b62e <_POSIX_Thread_Translate_sched_param+0xa2>
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
4b62c: 7016 moveq #22,%d0
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
4b62e: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5
4b634: 4e5e unlk %fp <== NOT EXECUTED
0004a69a <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
4a69a: 4e56 ffec linkw %fp,#-20 4a69e: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ 4a6a2: 246e 000c moveal %fp@(12),%a2
/*
* 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 )) )
4a6a6: 49f9 0004 807c lea 4807c <_Thread_queue_Dequeue>,%a4
{
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
4a6ac: 266a 0102 moveal %a2@(258),%a3
/*
* 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 )) )
4a6b0: 240b movel %a3,%d2 4a6b2: 0682 0000 0044 addil #68,%d2
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
4a6b8: 2f0a movel %a2,%sp@- 4a6ba: 4eb9 0004 c538 jsr 4c538 <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
4a6c0: 2f0a movel %a2,%sp@- 4a6c2: 4eb9 0004 c5a0 jsr 4c5a0 <_POSIX_Keys_Run_destructors>
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
4a6c8: 262a 0028 movel %a2@(40),%d3
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
4a6cc: 508f addql #8,%sp 4a6ce: 6008 bras 4a6d8 <_POSIX_Threads_Delete_extension+0x3e>
*(void **)the_thread->Wait.return_argument = value_ptr;
4a6d0: 2240 moveal %d0,%a1 <== NOT EXECUTED 4a6d2: 2069 0028 moveal %a1@(40),%a0 <== NOT EXECUTED 4a6d6: 2083 movel %d3,%a0@ <== 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 )) )
4a6d8: 2f02 movel %d2,%sp@- 4a6da: 4e94 jsr %a4@ 4a6dc: 588f addql #4,%sp 4a6de: 4a80 tstl %d0
4a6e0: 66ee bnes 4a6d0 <_POSIX_Threads_Delete_extension+0x36><== NEVER TAKEN
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
4a6e2: 103c 0004 moveb #4,%d0 4a6e6: b0ab 0084 cmpl %a3@(132),%d0
4a6ea: 660c bnes 4a6f8 <_POSIX_Threads_Delete_extension+0x5e>
(void) _Watchdog_Remove( &api->Sporadic_timer );
4a6ec: 486b 00a8 pea %a3@(168) 4a6f0: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove> 4a6f6: 588f addql #4,%sp
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
4a6f8: 42aa 0102 clrl %a2@(258)
_Workspace_Free( api );
4a6fc: 2d4b 0008 movel %a3,%fp@(8)
}
4a700: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4 4a706: 4e5e unlk %fp
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
_Workspace_Free( api );
4a708: 4ef9 0004 8c2c jmp 48c2c <_Workspace_Free>
00045c2c <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
45c2c: 4e56 ff98 linkw %fp,#-104 45c30: 48d7 3c7c moveml %d2-%d6/%a2-%a5,%sp@
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
45c34: 2479 0005 e024 moveal 5e024 <Configuration_POSIX_API+0x34>,%a2
maximum = Configuration_POSIX_API.number_of_initialization_threads;
45c3a: 2839 0005 e020 movel 5e020 <Configuration_POSIX_API+0x30>,%d4
if ( !user_threads || maximum == 0 )
45c40: 4a8a tstl %a2
45c42: 676a beqs 45cae <_POSIX_Threads_Initialize_user_threads_body+0x82><== NEVER TAKEN
45c44: 4a84 tstl %d4
45c46: 6766 beqs 45cae <_POSIX_Threads_Initialize_user_threads_body+0x82><== NEVER TAKEN
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
45c48: 240e movel %fp,%d2
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
status = pthread_create(
45c4a: 2a0e movel %fp,%d5
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
maximum = Configuration_POSIX_API.number_of_initialization_threads;
if ( !user_threads || maximum == 0 )
45c4c: 4283 clrl %d3
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
45c4e: 0682 ffff ffbc addil #-68,%d2 45c54: 2c3c 0004 b638 movel #308792,%d6
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
45c5a: 4bf9 0004 b664 lea 4b664 <pthread_attr_setinheritsched>,%a5
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
45c60: 49f9 0004 b69c lea 4b69c <pthread_attr_setstacksize>,%a4
status = pthread_create(
45c66: 5985 subql #4,%d5 45c68: 47f9 0004 5904 lea 45904 <pthread_create>,%a3
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
45c6e: 2f02 movel %d2,%sp@- 45c70: 2046 moveal %d6,%a0 45c72: 4e90 jsr %a0@
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
45c74: 4878 0002 pea 2 <DOUBLE_FLOAT> 45c78: 2f02 movel %d2,%sp@- 45c7a: 4e95 jsr %a5@
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
45c7c: 2f2a 0004 movel %a2@(4),%sp@- 45c80: 2f02 movel %d2,%sp@- 45c82: 4e94 jsr %a4@
status = pthread_create(
45c84: 42a7 clrl %sp@- 45c86: 2f12 movel %a2@,%sp@- 45c88: 2f02 movel %d2,%sp@- 45c8a: 2f05 movel %d5,%sp@- 45c8c: 4e93 jsr %a3@
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
45c8e: 4fef 0024 lea %sp@(36),%sp 45c92: 4a80 tstl %d0
45c94: 6710 beqs 45ca6 <_POSIX_Threads_Initialize_user_threads_body+0x7a>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
45c96: 2f00 movel %d0,%sp@- 45c98: 4878 0001 pea 1 <ADD> 45c9c: 4878 0002 pea 2 <DOUBLE_FLOAT> 45ca0: 4eb9 0004 79a8 jsr 479a8 <_Internal_error_Occurred>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
45ca6: 5283 addql #1,%d3 45ca8: 508a addql #8,%a2 45caa: b883 cmpl %d3,%d4
45cac: 66c0 bnes 45c6e <_POSIX_Threads_Initialize_user_threads_body+0x42><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
45cae: 4cee 3c7c ff98 moveml %fp@(-104),%d2-%d6/%a2-%a5
45cb4: 4e5e unlk %fp <== NOT EXECUTED
0004a822 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
4a822: 4e56 0000 linkw %fp,#0 4a826: 2f0b movel %a3,%sp@- 4a828: 2f0a movel %a2,%sp@- 4a82a: 246e 000c moveal %fp@(12),%a2
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a82e: 266a 0102 moveal %a2@(258),%a3
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
4a832: 486b 0098 pea %a3@(152) 4a836: 4eb9 0004 b56c jsr 4b56c <_Timespec_To_ticks>
*/
#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 ) {
4a83c: 588f addql #4,%sp
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;
4a83e: 2540 0076 movel %d0,%a2@(118)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
4a842: 4280 clrl %d0 4a844: 1039 0005 d1fa moveb 5d1fa <rtems_maximum_priority>,%d0 4a84a: 90ab 0088 subl %a3@(136),%d0
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
4a84e: 2540 0018 movel %d0,%a2@(24)
*/
#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 ) {
4a852: 4aaa 001c tstl %a2@(28)
4a856: 6618 bnes 4a870 <_POSIX_Threads_Sporadic_budget_TSR+0x4e><== NEVER TAKEN
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
4a858: b0aa 0014 cmpl %a2@(20),%d0
4a85c: 6412 bccs 4a870 <_POSIX_Threads_Sporadic_budget_TSR+0x4e>
_Thread_Change_priority( the_thread, new_priority, true );
4a85e: 4878 0001 pea 1 <ADD> 4a862: 2f00 movel %d0,%sp@- 4a864: 2f0a movel %a2,%sp@- 4a866: 4eb9 0004 7930 jsr 47930 <_Thread_Change_priority> 4a86c: 4fef 000c lea %sp@(12),%sp
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
4a870: 486b 0090 pea %a3@(144) 4a874: 4eb9 0004 b56c jsr 4b56c <_Timespec_To_ticks>
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
4a87a: 246e fff8 moveal %fp@(-8),%a2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4a87e: 588f addql #4,%sp
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4a880: 2740 00b4 movel %d0,%a3@(180)
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
4a884: 47eb 00a8 lea %a3@(168),%a3
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
4a888: 203c 0005 ec50 movel #388176,%d0 4a88e: 2d4b 000c movel %a3,%fp@(12)
}
4a892: 266e fffc moveal %fp@(-4),%a3 4a896: 2d40 0008 movel %d0,%fp@(8) 4a89a: 4e5e unlk %fp 4a89c: 4ef9 0004 8994 jmp 48994 <_Watchdog_Insert>
0004a8a2 <_POSIX_Threads_Sporadic_budget_callout>:
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
4a8a2: 70ff moveq #-1,%d0
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
4a8a4: 4e56 0000 linkw %fp,#0 4a8a8: 206e 0008 moveal %fp@(8),%a0
/*
* 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 */
4a8ac: 2140 0076 movel %d0,%a0@(118) 4a8b0: 4280 clrl %d0 4a8b2: 1039 0005 d1fa moveb 5d1fa <rtems_maximum_priority>,%d0
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a8b8: 2268 0102 moveal %a0@(258),%a1 4a8bc: 90a9 008c subl %a1@(140),%d0
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
4a8c0: 2140 0018 movel %d0,%a0@(24)
*/
#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 ) {
4a8c4: 4aa8 001c tstl %a0@(28)
4a8c8: 6618 bnes 4a8e2 <_POSIX_Threads_Sporadic_budget_callout+0x40><== NEVER TAKEN
/*
* 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 ) {
4a8ca: b0a8 0014 cmpl %a0@(20),%d0
4a8ce: 6312 blss 4a8e2 <_POSIX_Threads_Sporadic_budget_callout+0x40><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
4a8d0: 4878 0001 pea 1 <ADD> 4a8d4: 2f00 movel %d0,%sp@- 4a8d6: 2f08 movel %a0,%sp@- 4a8d8: 4eb9 0004 7930 jsr 47930 <_Thread_Change_priority> 4a8de: 4fef 000c lea %sp@(12),%sp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
4a8e2: 4e5e unlk %fp <== NOT EXECUTED
00045764 <_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)
{
45764: 4e56 0000 linkw %fp,#0 45768: 2f0a movel %a2,%sp@- 4576a: 246e 000c moveal %fp@(12),%a2
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
4576e: 52aa 0066 addql #1,%a2@(102)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
45772: 4aaa 0052 tstl %a2@(82)
45776: 6606 bnes 4577e <_POSIX_Timer_TSR+0x1a>
45778: 4aaa 0056 tstl %a2@(86)
4577c: 6736 beqs 457b4 <_POSIX_Timer_TSR+0x50> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
4577e: 2f0a movel %a2,%sp@- 45780: 4879 0004 5764 pea 45764 <_POSIX_Timer_TSR> 45786: 2f2a 0008 movel %a2@(8),%sp@- 4578a: 2f2a 0062 movel %a2@(98),%sp@- 4578e: 486a 0010 pea %a2@(16) 45792: 4eb9 0004 aff4 jsr 4aff4 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
45798: 4fef 0014 lea %sp@(20),%sp 4579c: 4a00 tstb %d0
4579e: 672e beqs 457ce <_POSIX_Timer_TSR+0x6a> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
457a0: 486a 006a pea %a2@(106) 457a4: 4eb9 0004 6cf4 jsr 46cf4 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
457aa: 588f addql #4,%sp 457ac: 7003 moveq #3,%d0 457ae: 1540 003c moveb %d0,%a2@(60) 457b2: 6006 bras 457ba <_POSIX_Timer_TSR+0x56>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
457b4: 7004 moveq #4,%d0 <== NOT EXECUTED 457b6: 1540 003c moveb %d0,%a2@(60) <== 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 ) ) {
457ba: 2f2a 0042 movel %a2@(66),%sp@- 457be: 2f2a 0038 movel %a2@(56),%sp@- 457c2: 4eb9 0004 abe0 jsr 4abe0 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
457c8: 508f addql #8,%sp 457ca: 42aa 0066 clrl %a2@(102)
}
457ce: 246e fffc moveal %fp@(-4),%a2 457d2: 4e5e unlk %fp
...
0004c61c <_POSIX_signals_Check_signal>:
{
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,
4c61c: 4280 clrl %d0
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c61e: 4e56 ffb4 linkw %fp,#-76
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,
4c622: 102e 0013 moveb %fp@(19),%d0
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c626: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@
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,
4c62a: 4878 0001 pea 1 <ADD> 4c62e: 2a0e movel %fp,%d5 4c630: 0685 ffff fff4 addil #-12,%d5 4c636: 2f00 movel %d0,%sp@-
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c638: 242e 000c movel %fp@(12),%d2
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,
4c63c: 2f05 movel %d5,%sp@-
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
4c63e: 246e 0008 moveal %fp@(8),%a2
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,
4c642: 2f02 movel %d2,%sp@- 4c644: 2f0a movel %a2,%sp@- 4c646: 4eb9 0004 c6f4 jsr 4c6f4 <_POSIX_signals_Clear_signals> 4c64c: 4fef 0014 lea %sp@(20),%sp 4c650: 4a00 tstb %d0 4c652: 6700 0092 beqw 4c6e6 <_POSIX_signals_Check_signal+0xca>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
4c656: 2002 movel %d2,%d0 4c658: 2602 movel %d2,%d3 4c65a: e588 lsll #2,%d0 4c65c: e98b lsll #4,%d3 4c65e: 9680 subl %d0,%d3 4c660: 2043 moveal %d3,%a0 4c662: d1fc 0005 f034 addal #389172,%a0 4c668: 7001 moveq #1,%d0 4c66a: 2668 0008 moveal %a0@(8),%a3 4c66e: b08b cmpl %a3,%d0
4c670: 6774 beqs 4c6e6 <_POSIX_signals_Check_signal+0xca><== NEVER TAKEN
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4c672: 2028 0004 movel %a0@(4),%d0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
4c676: 282a 00d0 movel %a2@(208),%d4
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4c67a: 8084 orl %d4,%d0
/* * 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,
4c67c: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0 4c682: 41e8 0020 lea %a0@(32),%a0
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
4c686: 2540 00d0 movel %d0,%a2@(208)
/* * 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,
4c68a: 4878 0028 pea 28 <OPER2+0x14> 4c68e: 2f08 movel %a0,%sp@- 4c690: 486e ffcc pea %fp@(-52) 4c694: 4eb9 0004 d588 jsr 4d588 <memcpy>
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
4c69a: 4fef 000c lea %sp@(12),%sp 4c69e: 41f9 0005 f034 lea 5f034 <_POSIX_signals_Vectors>,%a0 4c6a4: 7002 moveq #2,%d0 4c6a6: b0b0 3800 cmpl %a0@(00000000,%d3:l),%d0
4c6aa: 660e bnes 4c6ba <_POSIX_signals_Check_signal+0x9e>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
4c6ac: 42a7 clrl %sp@- 4c6ae: 2f05 movel %d5,%sp@- 4c6b0: 2f02 movel %d2,%sp@- 4c6b2: 4e93 jsr %a3@
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
4c6b4: 4fef 000c lea %sp@(12),%sp 4c6b8: 6006 bras 4c6c0 <_POSIX_signals_Check_signal+0xa4>
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
4c6ba: 2f02 movel %d2,%sp@- 4c6bc: 4e93 jsr %a3@
break;
4c6be: 588f addql #4,%sp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
4c6c0: 4878 0028 pea 28 <OPER2+0x14> 4c6c4: 486e ffcc pea %fp@(-52) 4c6c8: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0 4c6ce: 41e8 0020 lea %a0@(32),%a0 4c6d2: 2f08 movel %a0,%sp@- 4c6d4: 4eb9 0004 d588 jsr 4d588 <memcpy>
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
4c6da: 4fef 000c lea %sp@(12),%sp
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
4c6de: 2544 00d0 movel %d4,%a2@(208)
return true;
4c6e2: 7001 moveq #1,%d0 4c6e4: 6002 bras 4c6e8 <_POSIX_signals_Check_signal+0xcc>
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
return false;
4c6e6: 4200 clrb %d0
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
}
4c6e8: 4cee 0c3c ffb4 moveml %fp@(-76),%d2-%d5/%a2-%a3 4c6ee: 4e5e unlk %fp
...
0004cce0 <_POSIX_signals_Clear_process_signals>:
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
4cce0: 203c 0000 0700 movel #1792,%d0
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
4cce6: 4e56 0000 linkw %fp,#0 4ccea: 222e 0008 movel %fp@(8),%d1 4ccee: 2f03 movel %d3,%sp@- 4ccf0: 2f02 movel %d2,%sp@-
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
4ccf2: 40c2 movew %sr,%d2 4ccf4: 8082 orl %d2,%d0 4ccf6: 46c0 movew %d0,%sr
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
4ccf8: 2601 movel %d1,%d3 4ccfa: 2001 movel %d1,%d0 4ccfc: 41f9 0005 f034 lea 5f034 <_POSIX_signals_Vectors>,%a0 4cd02: e58b lsll #2,%d3 4cd04: e988 lsll #4,%d0 4cd06: 9083 subl %d3,%d0 4cd08: 7602 moveq #2,%d3 4cd0a: b6b0 0800 cmpl %a0@(00000000,%d0:l),%d3
4cd0e: 6610 bnes 4cd20 <_POSIX_signals_Clear_process_signals+0x40>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
4cd10: 2040 moveal %d0,%a0 4cd12: d1fc 0005 f22c addal #389676,%a0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4cd18: 2008 movel %a0,%d0 4cd1a: 5880 addql #4,%d0 4cd1c: b090 cmpl %a0@,%d0
4cd1e: 660e bnes 4cd2e <_POSIX_signals_Clear_process_signals+0x4e><== NEVER TAKEN
4cd20: 5381 subql #1,%d1 4cd22: 7001 moveq #1,%d0 4cd24: e3a8 lsll %d1,%d0
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
4cd26: 4680 notl %d0 4cd28: c1b9 0005 f228 andl %d0,5f228 <_POSIX_signals_Pending>
}
_ISR_Enable( level );
4cd2e: 46c2 movew %d2,%sr
}
4cd30: 241f movel %sp@+,%d2 4cd32: 261f movel %sp@+,%d3
4cd34: 4e5e unlk %fp <== NOT EXECUTED
000462dc <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
462dc: 701b moveq #27,%d0
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
462de: 4e56 fff4 linkw %fp,#-12 462e2: 48d7 001c moveml %d2-%d4,%sp@ 462e6: 242e 0008 movel %fp@(8),%d2 462ea: 7601 moveq #1,%d3
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
462ec: 2200 movel %d0,%d1 462ee: 5381 subql #1,%d1 462f0: 2803 movel %d3,%d4 462f2: e3ac lsll %d1,%d4 462f4: 2204 movel %d4,%d1
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
462f6: c282 andl %d2,%d1
462f8: 6626 bnes 46320 <_POSIX_signals_Get_lowest+0x44> <== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
462fa: 5280 addql #1,%d0 462fc: 123c 0020 moveb #32,%d1 46300: b280 cmpl %d0,%d1
46302: 66e8 bnes 462ec <_POSIX_signals_Get_lowest+0x10>
46304: 7001 moveq #1,%d0 46306: 7601 moveq #1,%d3
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
46308: 2200 movel %d0,%d1 4630a: 5381 subql #1,%d1 4630c: 2803 movel %d3,%d4 4630e: e3ac lsll %d1,%d4 46310: 2204 movel %d4,%d1
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
46312: c282 andl %d2,%d1
46314: 660a bnes 46320 <_POSIX_signals_Get_lowest+0x44>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
46316: 5280 addql #1,%d0 46318: 123c 001b moveb #27,%d1 4631c: b280 cmpl %d0,%d1
4631e: 66e8 bnes 46308 <_POSIX_signals_Get_lowest+0x2c> <== ALWAYS TAKEN
* a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; }
46320: 4cd7 001c moveml %sp@,%d2-%d4
46324: 4e5e unlk %fp <== NOT EXECUTED
0004a482 <_POSIX_signals_Post_switch_extension>:
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
4a482: 4e56 ffec linkw %fp,#-20
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a486: 206e 0008 moveal %fp@(8),%a0
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
4a48a: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4a48e: 2468 0102 moveal %a0@(258),%a2
/*
* 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;
4a492: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0 4a498: 2628 0034 movel %a0@(52),%d3
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
4a49c: 4a8a tstl %a2
4a49e: 677a beqs 4a51a <_POSIX_signals_Post_switch_extension+0x98><== NEVER TAKEN
*
* 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 );
4a4a0: 283c 0000 0700 movel #1792,%d4
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
4a4a6: 47f9 0004 c61c lea 4c61c <_POSIX_signals_Check_signal>,%a3
*
* 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 );
4a4ac: 2004 movel %d4,%d0 4a4ae: 40c1 movew %sr,%d1 4a4b0: 8081 orl %d1,%d0 4a4b2: 46c0 movew %d0,%sr
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
4a4b4: 2039 0005 f228 movel 5f228 <_POSIX_signals_Pending>,%d0
* 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 &
4a4ba: 242a 00d0 movel %a2@(208),%d2 4a4be: 4682 notl %d2
(api->signals_pending | _POSIX_signals_Pending)) ) {
4a4c0: 80aa 00d4 orl %a2@(212),%d0
* 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 &
4a4c4: c082 andl %d2,%d0
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
4a4c6: 46c1 movew %d1,%sr
* 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 &
4a4c8: 4a80 tstl %d0
4a4ca: 660c bnes 4a4d8 <_POSIX_signals_Post_switch_extension+0x56>
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
}
_Thread_Executing->Wait.return_code = hold_errno;
4a4cc: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0 4a4d2: 2143 0034 movel %d3,%a0@(52) 4a4d6: 6042 bras 4a51a <_POSIX_signals_Post_switch_extension+0x98>
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4a4d8: 741b moveq #27,%d2
_POSIX_signals_Check_signal( api, signo, false );
4a4da: 42a7 clrl %sp@- 4a4dc: 2f02 movel %d2,%sp@- 4a4de: 2f0a movel %a2,%sp@- 4a4e0: 4e93 jsr %a3@
_POSIX_signals_Check_signal( api, signo, true );
4a4e2: 4878 0001 pea 1 <ADD> 4a4e6: 2f02 movel %d2,%sp@-
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4a4e8: 5282 addql #1,%d2
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
4a4ea: 2f0a movel %a2,%sp@- 4a4ec: 4e93 jsr %a3@
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4a4ee: 4fef 0018 lea %sp@(24),%sp 4a4f2: 7020 moveq #32,%d0 4a4f4: b082 cmpl %d2,%d0
4a4f6: 66e2 bnes 4a4da <_POSIX_signals_Post_switch_extension+0x58>
4a4f8: 7401 moveq #1,%d2
_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 );
4a4fa: 42a7 clrl %sp@- 4a4fc: 2f02 movel %d2,%sp@- 4a4fe: 2f0a movel %a2,%sp@- 4a500: 4e93 jsr %a3@
_POSIX_signals_Check_signal( api, signo, true );
4a502: 4878 0001 pea 1 <ADD> 4a506: 2f02 movel %d2,%sp@-
_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++ ) {
4a508: 5282 addql #1,%d2
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
4a50a: 2f0a movel %a2,%sp@- 4a50c: 4e93 jsr %a3@
_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++ ) {
4a50e: 4fef 0018 lea %sp@(24),%sp 4a512: 701b moveq #27,%d0 4a514: b082 cmpl %d2,%d0
4a516: 66e2 bnes 4a4fa <_POSIX_signals_Post_switch_extension+0x78>
4a518: 6092 bras 4a4ac <_POSIX_signals_Post_switch_extension+0x2a>
_POSIX_signals_Check_signal( api, signo, true );
}
}
_Thread_Executing->Wait.return_code = hold_errno;
}
4a51a: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3
4a520: 4e5e unlk %fp <== NOT EXECUTED
0005ae80 <_POSIX_signals_Unblock_thread>:
5ae80: 7201 moveq #1,%d1
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
5ae82: 4e56 fff4 linkw %fp,#-12 5ae86: 226e 0010 moveal %fp@(16),%a1 5ae8a: 48d7 040c moveml %d2-%d3/%a2,%sp@ 5ae8e: 242e 000c movel %fp@(12),%d2 5ae92: 2002 movel %d2,%d0 5ae94: 5380 subql #1,%d0 5ae96: 246e 0008 moveal %fp@(8),%a2 5ae9a: e1a9 lsll %d0,%d1
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
5ae9c: 202a 0010 movel %a2@(16),%d0 5aea0: 2600 movel %d0,%d3 5aea2: 0283 1000 8000 andil #268468224,%d3
{
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
5aea8: 206a 0102 moveal %a2@(258),%a0
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
5aeac: 0c83 1000 8000 cmpil #268468224,%d3
5aeb2: 6650 bnes 5af04 <_POSIX_signals_Unblock_thread+0x84>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
5aeb4: 2001 movel %d1,%d0 5aeb6: c0aa 0030 andl %a2@(48),%d0
5aeba: 660c bnes 5aec8 <_POSIX_signals_Unblock_thread+0x48>
5aebc: 2028 00d0 movel %a0@(208),%d0 5aec0: 4680 notl %d0 5aec2: c280 andl %d0,%d1 5aec4: 6700 00a8 beqw 5af6e <_POSIX_signals_Unblock_thread+0xee>
the_thread->Wait.return_code = EINTR;
5aec8: 7004 moveq #4,%d0
the_info = (siginfo_t *) the_thread->Wait.return_argument;
5aeca: 206a 0028 moveal %a2@(40),%a0
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
the_thread->Wait.return_code = EINTR;
5aece: 2540 0034 movel %d0,%a2@(52)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
5aed2: 4a89 tstl %a1
5aed4: 660e bnes 5aee4 <_POSIX_signals_Unblock_thread+0x64>
the_info->si_signo = signo;
the_info->si_code = SI_USER;
5aed6: 7201 moveq #1,%d1
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
5aed8: 2082 movel %d2,%a0@
the_info->si_code = SI_USER;
5aeda: 2141 0004 movel %d1,%a0@(4)
the_info->si_value.sival_int = 0;
5aede: 42a8 0008 clrl %a0@(8) 5aee2: 6012 bras 5aef6 <_POSIX_signals_Unblock_thread+0x76>
} else {
*the_info = *info;
5aee4: 4878 000c pea c <OPER1> 5aee8: 2f09 movel %a1,%sp@- 5aeea: 2f08 movel %a0,%sp@- 5aeec: 4eb9 0004 d588 jsr 4d588 <memcpy> 5aef2: 4fef 000c lea %sp@(12),%sp
}
_Thread_queue_Extract_with_proxy( the_thread );
5aef6: 2f0a movel %a2,%sp@- 5aef8: 4eb9 0004 8388 jsr 48388 <_Thread_queue_Extract_with_proxy>
return true;
5aefe: 588f addql #4,%sp 5af00: 7001 moveq #1,%d0 5af02: 606c bras 5af70 <_POSIX_signals_Unblock_thread+0xf0>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
5af04: 2428 00d0 movel %a0@(208),%d2 5af08: 4682 notl %d2 5af0a: c282 andl %d2,%d1
5af0c: 6760 beqs 5af6e <_POSIX_signals_Unblock_thread+0xee>
* 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 ) ) {
5af0e: 0800 001c btst #28,%d0
5af12: 673e beqs 5af52 <_POSIX_signals_Unblock_thread+0xd2>
the_thread->Wait.return_code = EINTR;
5af14: 7204 moveq #4,%d1 5af16: 2541 0034 movel %d1,%a2@(52)
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
5af1a: 2200 movel %d0,%d1 5af1c: 0281 0003 bee0 andil #245472,%d1
/*
* 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) )
5af22: 670c beqs 5af30 <_POSIX_signals_Unblock_thread+0xb0>
_Thread_queue_Extract_with_proxy( the_thread );
5af24: 2f0a movel %a2,%sp@- 5af26: 4eb9 0004 8388 jsr 48388 <_Thread_queue_Extract_with_proxy> 5af2c: 588f addql #4,%sp 5af2e: 603e bras 5af6e <_POSIX_signals_Unblock_thread+0xee>
else if ( _States_Is_delaying(the_thread->current_state) ) {
5af30: 44c0 movew %d0,%ccr
5af32: 6a3a bpls 5af6e <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
5af34: 486a 0048 pea %a2@(72) 5af38: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
5af3e: 2f3c 1003 fff8 movel #268697592,%sp@- 5af44: 2f0a movel %a2,%sp@- 5af46: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state> 5af4c: 4fef 000c lea %sp@(12),%sp 5af50: 601c bras 5af6e <_POSIX_signals_Unblock_thread+0xee>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
5af52: 4a80 tstl %d0
5af54: 6618 bnes 5af6e <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
5af56: 4ab9 0005 eff6 tstl 5eff6 <_Per_CPU_Information+0x8>
5af5c: 6710 beqs 5af6e <_POSIX_signals_Unblock_thread+0xee>
5af5e: b5f9 0005 effa cmpal 5effa <_Per_CPU_Information+0xc>,%a2
5af64: 6608 bnes 5af6e <_POSIX_signals_Unblock_thread+0xee><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
5af66: 7001 moveq #1,%d0 5af68: 13c0 0005 f006 moveb %d0,5f006 <_Per_CPU_Information+0x18>
}
}
return false;
5af6e: 4200 clrb %d0
}
5af70: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 5af76: 4e5e unlk %fp
...
0004bb9e <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
4bb9e: 4e56 ffec linkw %fp,#-20 4bba2: 48d7 3c04 moveml %d2/%a2-%a5,%sp@ 4bba6: 286e 0008 moveal %fp@(8),%a4 4bbaa: 246e 000c moveal %fp@(12),%a2
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
4bbae: 4a8a tstl %a2 4bbb0: 6700 0110 beqw 4bcc2 <_RBTree_Extract_unprotected+0x124>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
4bbb4: b5ec 0008 cmpal %a4@(8),%a2
4bbb8: 661a bnes 4bbd4 <_RBTree_Extract_unprotected+0x36>
if (the_node->child[RBT_RIGHT])
4bbba: 202a 0008 movel %a2@(8),%d0
4bbbe: 6706 beqs 4bbc6 <_RBTree_Extract_unprotected+0x28>
the_rbtree->first[RBT_LEFT] = the_node->child[RBT_RIGHT];
4bbc0: 2940 0008 movel %d0,%a4@(8) 4bbc4: 600e bras 4bbd4 <_RBTree_Extract_unprotected+0x36>
else {
the_rbtree->first[RBT_LEFT] = the_node->parent;
4bbc6: 2012 movel %a2@,%d0 4bbc8: 2940 0008 movel %d0,%a4@(8)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
4bbcc: b08c cmpl %a4,%d0
4bbce: 6604 bnes 4bbd4 <_RBTree_Extract_unprotected+0x36>
the_rbtree->first[RBT_LEFT]))
the_rbtree->first[RBT_LEFT] = NULL;
4bbd0: 42ac 0008 clrl %a4@(8) 4bbd4: 2a6a 0004 moveal %a2@(4),%a5
}
}
/* check if max needs to be updated: note, min can equal max (1 element) */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
4bbd8: b5ec 000c cmpal %a4@(12),%a2
4bbdc: 6618 bnes 4bbf6 <_RBTree_Extract_unprotected+0x58>
if (the_node->child[RBT_LEFT])
4bbde: 4a8d tstl %a5
4bbe0: 6706 beqs 4bbe8 <_RBTree_Extract_unprotected+0x4a>
the_rbtree->first[RBT_RIGHT] = the_node->child[RBT_LEFT];
4bbe2: 294d 000c movel %a5,%a4@(12) 4bbe6: 600e bras 4bbf6 <_RBTree_Extract_unprotected+0x58>
else {
the_rbtree->first[RBT_RIGHT] = the_node->parent;
4bbe8: 2012 movel %a2@,%d0 4bbea: 2940 000c movel %d0,%a4@(12)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
4bbee: b08c cmpl %a4,%d0
4bbf0: 6604 bnes 4bbf6 <_RBTree_Extract_unprotected+0x58>
the_rbtree->first[RBT_RIGHT]))
the_rbtree->first[RBT_RIGHT] = NULL;
4bbf2: 42ac 000c clrl %a4@(12)
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
4bbf6: 264d moveal %a5,%a3 4bbf8: 4a8d tstl %a5
4bbfa: 6778 beqs 4bc74 <_RBTree_Extract_unprotected+0xd6>
4bbfc: 4aaa 0008 tstl %a2@(8)
4bc00: 6604 bnes 4bc06 <_RBTree_Extract_unprotected+0x68>
4bc02: 6078 bras 4bc7c <_RBTree_Extract_unprotected+0xde>
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
4bc04: 2640 moveal %d0,%a3 4bc06: 202b 0008 movel %a3@(8),%d0
4bc0a: 66f8 bnes 4bc04 <_RBTree_Extract_unprotected+0x66>
* target's position (target is the right child of target->parent)
* when target vacates it. if there is no child, then target->parent
* should become NULL. This may cause the coloring to be violated.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = target->child[RBT_LEFT];
4bc0c: 2a6b 0004 moveal %a3@(4),%a5
if(leaf) {
4bc10: 4a8d tstl %a5
4bc12: 6704 beqs 4bc18 <_RBTree_Extract_unprotected+0x7a>
leaf->parent = target->parent;
4bc14: 2a93 movel %a3@,%a5@ 4bc16: 600a bras 4bc22 <_RBTree_Extract_unprotected+0x84>
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
4bc18: 2f0b movel %a3,%sp@- 4bc1a: 4eb9 0004 ba58 jsr 4ba58 <_RBTree_Extract_validate_unprotected> 4bc20: 588f addql #4,%sp
}
victim_color = target->color;
dir = target != target->parent->child[0];
4bc22: 2053 moveal %a3@,%a0 4bc24: b7e8 0004 cmpal %a0@(4),%a3 4bc28: 56c1 sne %d1
target->parent->child[dir] = leaf;
4bc2a: 7401 moveq #1,%d2
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
4bc2c: 49c1 extbl %d1
target->parent->child[dir] = leaf;
4bc2e: 9481 subl %d1,%d2 4bc30: 218d 2c00 movel %a5,%a0@(00000000,%d2:l:4)
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
the_node->parent->child[dir] = target;
4bc34: 7401 moveq #1,%d2
victim_color = target->color;
dir = target != target->parent->child[0];
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
4bc36: 2052 moveal %a2@,%a0 4bc38: b5e8 0004 cmpal %a0@(4),%a2 4bc3c: 56c1 sne %d1
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
4bc3e: 202b 000c movel %a3@(12),%d0
dir = target != target->parent->child[0];
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
4bc42: 49c1 extbl %d1
the_node->parent->child[dir] = target;
4bc44: 9481 subl %d1,%d2 4bc46: 218b 2c00 movel %a3,%a0@(00000000,%d2:l:4)
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
4bc4a: 276a 0008 0008 movel %a2@(8),%a3@(8)
if (the_node->child[RBT_RIGHT])
4bc50: 206a 0008 moveal %a2@(8),%a0 4bc54: 4a88 tstl %a0
4bc56: 6702 beqs 4bc5a <_RBTree_Extract_unprotected+0xbc><== NEVER TAKEN
the_node->child[RBT_RIGHT]->parent = target;
4bc58: 208b movel %a3,%a0@
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
4bc5a: 276a 0004 0004 movel %a2@(4),%a3@(4)
if (the_node->child[RBT_LEFT])
4bc60: 206a 0004 moveal %a2@(4),%a0 4bc64: 4a88 tstl %a0
4bc66: 6702 beqs 4bc6a <_RBTree_Extract_unprotected+0xcc>
the_node->child[RBT_LEFT]->parent = target;
4bc68: 208b movel %a3,%a0@
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
4bc6a: 2692 movel %a2@,%a3@
target->color = the_node->color;
4bc6c: 276a 000c 000c movel %a2@(12),%a3@(12) 4bc72: 602c bras 4bca0 <_RBTree_Extract_unprotected+0x102>
* the_node's location in the tree. This may cause the coloring to be
* violated. We will fix it later.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
4bc74: 2a6a 0008 moveal %a2@(8),%a5
if( leaf ) {
4bc78: 4a8d tstl %a5
4bc7a: 6704 beqs 4bc80 <_RBTree_Extract_unprotected+0xe2>
leaf->parent = the_node->parent;
4bc7c: 2a92 movel %a2@,%a5@ 4bc7e: 600a bras 4bc8a <_RBTree_Extract_unprotected+0xec>
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
4bc80: 2f0a movel %a2,%sp@- 4bc82: 4eb9 0004 ba58 jsr 4ba58 <_RBTree_Extract_validate_unprotected> 4bc88: 588f addql #4,%sp
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
4bc8a: 2052 moveal %a2@,%a0 4bc8c: b5e8 0004 cmpal %a0@(4),%a2 4bc90: 56c1 sne %d1
the_node->parent->child[dir] = leaf;
4bc92: 7401 moveq #1,%d2
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
4bc94: 49c1 extbl %d1
the_node->parent->child[dir] = leaf;
4bc96: 9481 subl %d1,%d2
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
4bc98: 202a 000c movel %a2@(12),%d0
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
the_node->parent->child[dir] = leaf;
4bc9c: 218d 2c00 movel %a5,%a0@(00000000,%d2:l:4)
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
4bca0: 4a80 tstl %d0
4bca2: 6608 bnes 4bcac <_RBTree_Extract_unprotected+0x10e>
if (leaf) {
4bca4: 4a8d tstl %a5
4bca6: 6704 beqs 4bcac <_RBTree_Extract_unprotected+0x10e>
leaf->color = RBT_BLACK; /* case 2 */
4bca8: 42ad 000c clrl %a5@(12)
/* Wipe the_node */
_RBTree_Set_off_rbtree(the_node);
/* set root to black, if it exists */
if (the_rbtree->root) the_rbtree->root->color = RBT_BLACK;
4bcac: 206c 0004 moveal %a4@(4),%a0
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree(
RBTree_Node *node
)
{
node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL;
4bcb0: 42aa 0008 clrl %a2@(8) 4bcb4: 42aa 0004 clrl %a2@(4) 4bcb8: 4292 clrl %a2@ 4bcba: 4a88 tstl %a0
4bcbc: 6704 beqs 4bcc2 <_RBTree_Extract_unprotected+0x124>
4bcbe: 42a8 000c clrl %a0@(12)
}
4bcc2: 4cee 3c04 ffec moveml %fp@(-20),%d2/%a2-%a5
4bcc8: 4e5e unlk %fp <== NOT EXECUTED
0004ba58 <_RBTree_Extract_validate_unprotected>:
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
RBTree_Node *the_node
)
{
4ba58: 4e56 ffe8 linkw %fp,#-24 4ba5c: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@ 4ba60: 266e 0008 moveal %fp@(8),%a3
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
4ba64: 2453 moveal %a3@,%a2
if(!parent->parent) return;
4ba66: 4a92 tstl %a2@ 4ba68: 6700 012a beqw 4bb94 <_RBTree_Extract_validate_unprotected+0x13c>
sibling = _RBTree_Sibling(the_node);
4ba6c: 2f0b movel %a3,%sp@- 4ba6e: 49fa ff6c lea %pc@(4b9dc <_RBTree_Sibling>),%a4 4ba72: 4e94 jsr %a4@ 4ba74: 588f addql #4,%sp
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
_RBTree_Rotate(parent, dir);
4ba76: 4bfa ff8e lea %pc@(4ba06 <_RBTree_Rotate>),%a5
RBTree_Direction dir;
parent = the_node->parent;
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
4ba7a: 2040 moveal %d0,%a0
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
4ba7c: 6000 00ec braw 4bb6a <_RBTree_Extract_validate_unprotected+0x112>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4ba80: 4a88 tstl %a0
4ba82: 6730 beqs 4bab4 <_RBTree_Extract_validate_unprotected+0x5c><== NEVER TAKEN
4ba84: 7001 moveq #1,%d0 4ba86: b0a8 000c cmpl %a0@(12),%d0
4ba8a: 6628 bnes 4bab4 <_RBTree_Extract_validate_unprotected+0x5c>
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
4ba8c: b7ea 0004 cmpal %a2@(4),%a3 4ba90: 56c2 sne %d2
* 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;
4ba92: 2540 000c movel %d0,%a2@(12)
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
4ba96: 49c2 extbl %d2 4ba98: 4482 negl %d2
* 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;
4ba9a: 42a8 000c clrl %a0@(12)
dir = the_node != parent->child[0];
_RBTree_Rotate(parent, dir);
4ba9e: 2f02 movel %d2,%sp@- 4baa0: 2f0a movel %a2,%sp@- 4baa2: 4e95 jsr %a5@
sibling = parent->child[!dir];
4baa4: 508f addql #8,%sp 4baa6: 4a82 tstl %d2 4baa8: 57c0 seq %d0 4baaa: 7201 moveq #1,%d1 4baac: 49c0 extbl %d0 4baae: 9280 subl %d0,%d1 4bab0: 2072 1c00 moveal %a2@(00000000,%d1:l:4),%a0
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4bab4: 2268 0008 moveal %a0@(8),%a1 4bab8: 4a89 tstl %a1
4baba: 670e beqs 4baca <_RBTree_Extract_validate_unprotected+0x72> * This function maintains the properties of the red-black tree. * * @note It does NOT disable interrupts to ensure the atomicity * of the extract operation. */ void _RBTree_Extract_validate_unprotected(
4babc: 7001 moveq #1,%d0 4babe: b0a9 000c cmpl %a1@(12),%d0 4bac2: 57c0 seq %d0 4bac4: 49c0 extbl %d0 4bac6: 4480 negl %d0 4bac8: 6002 bras 4bacc <_RBTree_Extract_validate_unprotected+0x74> 4baca: 4280 clrl %d0
_RBTree_Rotate(parent, dir);
sibling = parent->child[!dir];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4bacc: 4a00 tstb %d0
4bace: 6630 bnes 4bb00 <_RBTree_Extract_validate_unprotected+0xa8>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
4bad0: 2268 0004 moveal %a0@(4),%a1 4bad4: 4a89 tstl %a1
4bad6: 670e beqs 4bae6 <_RBTree_Extract_validate_unprotected+0x8e> * This function maintains the properties of the red-black tree. * * @note It does NOT disable interrupts to ensure the atomicity * of the extract operation. */ void _RBTree_Extract_validate_unprotected(
4bad8: 7201 moveq #1,%d1 4bada: b2a9 000c cmpl %a1@(12),%d1 4bade: 57c0 seq %d0 4bae0: 49c0 extbl %d0 4bae2: 4480 negl %d0 4bae4: 6002 bras 4bae8 <_RBTree_Extract_validate_unprotected+0x90> 4bae6: 4280 clrl %d0
_RBTree_Rotate(parent, dir);
sibling = parent->child[!dir];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
4bae8: 4a00 tstb %d0
4baea: 6614 bnes 4bb00 <_RBTree_Extract_validate_unprotected+0xa8>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
4baec: 7001 moveq #1,%d0 4baee: 2140 000c movel %d0,%a0@(12) 4baf2: b0aa 000c cmpl %a2@(12),%d0 4baf6: 6600 008c bnew 4bb84 <_RBTree_Extract_validate_unprotected+0x12c>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
4bafa: 42aa 000c clrl %a2@(12)
break;
4bafe: 6078 bras 4bb78 <_RBTree_Extract_validate_unprotected+0x120>
* 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];
4bb00: b7ea 0004 cmpal %a2@(4),%a3 4bb04: 56c2 sne %d2 4bb06: 49c2 extbl %d2 4bb08: 4482 negl %d2
if (!_RBTree_Is_red(sibling->child[!dir])) {
4bb0a: 57c3 seq %d3 4bb0c: 49c3 extbl %d3 4bb0e: 4483 negl %d3 4bb10: 2270 3c04 moveal %a0@(00000004,%d3:l:4),%a1 4bb14: 4a89 tstl %a1
4bb16: 670e beqs 4bb26 <_RBTree_Extract_validate_unprotected+0xce> * This function maintains the properties of the red-black tree. * * @note It does NOT disable interrupts to ensure the atomicity * of the extract operation. */ void _RBTree_Extract_validate_unprotected(
4bb18: 7201 moveq #1,%d1 4bb1a: b2a9 000c cmpl %a1@(12),%d1 4bb1e: 57c0 seq %d0 4bb20: 49c0 extbl %d0 4bb22: 4480 negl %d0 4bb24: 6002 bras 4bb28 <_RBTree_Extract_validate_unprotected+0xd0> 4bb26: 4280 clrl %d0
* 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[!dir])) {
4bb28: 4a00 tstb %d0
4bb2a: 6620 bnes 4bb4c <_RBTree_Extract_validate_unprotected+0xf4>
sibling->color = RBT_RED;
4bb2c: 7001 moveq #1,%d0
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
4bb2e: 7201 moveq #1,%d1
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
4bb30: 2270 2c04 moveal %a0@(00000004,%d2:l:4),%a1
* 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[!dir])) {
sibling->color = RBT_RED;
4bb34: 2140 000c movel %d0,%a0@(12)
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
4bb38: b581 eorl %d2,%d1
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[!dir])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
4bb3a: 42a9 000c clrl %a1@(12)
_RBTree_Rotate(sibling, !dir);
4bb3e: 2f01 movel %d1,%sp@- 4bb40: 2f08 movel %a0,%sp@- 4bb42: 4eba fec2 jsr %pc@(4ba06 <_RBTree_Rotate>)
sibling = parent->child[!dir];
4bb46: 508f addql #8,%sp 4bb48: 2072 3c04 moveal %a2@(00000004,%d3:l:4),%a0
}
sibling->color = parent->color;
4bb4c: 216a 000c 000c movel %a2@(12),%a0@(12)
parent->color = RBT_BLACK;
sibling->child[!dir]->color = RBT_BLACK;
4bb52: 2070 3c04 moveal %a0@(00000004,%d3:l:4),%a0
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
sibling = parent->child[!dir];
}
sibling->color = parent->color;
parent->color = RBT_BLACK;
4bb56: 42aa 000c clrl %a2@(12)
sibling->child[!dir]->color = RBT_BLACK;
4bb5a: 42a8 000c clrl %a0@(12)
_RBTree_Rotate(parent, dir);
4bb5e: 2f02 movel %d2,%sp@- 4bb60: 2f0a movel %a2,%sp@- 4bb62: 4eba fea2 jsr %pc@(4ba06 <_RBTree_Rotate>)
break; /* done */
4bb66: 508f addql #8,%sp 4bb68: 600e bras 4bb78 <_RBTree_Extract_validate_unprotected+0x120>
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) {
4bb6a: 7001 moveq #1,%d0 4bb6c: b0ab 000c cmpl %a3@(12),%d0
4bb70: 6706 beqs 4bb78 <_RBTree_Extract_validate_unprotected+0x120>
4bb72: 4a92 tstl %a2@ 4bb74: 6600 ff0a bnew 4ba80 <_RBTree_Extract_validate_unprotected+0x28>
sibling->child[!dir]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4bb78: 2053 moveal %a3@,%a0 4bb7a: 4a90 tstl %a0@
4bb7c: 6616 bnes 4bb94 <_RBTree_Extract_validate_unprotected+0x13c>
4bb7e: 42ab 000c clrl %a3@(12) 4bb82: 6010 bras 4bb94 <_RBTree_Extract_validate_unprotected+0x13c>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
4bb84: 2412 movel %a2@,%d2
sibling = _RBTree_Sibling(the_node);
4bb86: 264a moveal %a2,%a3 4bb88: 2f0a movel %a2,%sp@-
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
4bb8a: 2442 moveal %d2,%a2
sibling = _RBTree_Sibling(the_node);
4bb8c: 4e94 jsr %a4@ 4bb8e: 588f addql #4,%sp 4bb90: 2040 moveal %d0,%a0 4bb92: 60d6 bras 4bb6a <_RBTree_Extract_validate_unprotected+0x112>
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
}
4bb94: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
4bb9a: 4e5e unlk %fp <== NOT EXECUTED
00048ae4 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
48ae4: 4e56 ffec linkw %fp,#-20 48ae8: 202e 001c movel %fp@(28),%d0 48aec: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 48af0: 246e 0008 moveal %fp@(8),%a2 48af4: 262e 0014 movel %fp@(20),%d3 48af8: 282e 0018 movel %fp@(24),%d4
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
48afc: 4a8a tstl %a2
48afe: 6734 beqs 48b34 <_RBTree_Initialize+0x50> <== NEVER TAKEN
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
48b00: 4292 clrl %a2@
the_rbtree->root = NULL; the_rbtree->first[0] = NULL; the_rbtree->first[1] = NULL; the_rbtree->compare_function = compare_function;
48b02: 256e 000c 0010 movel %fp@(12),%a2@(16)
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
48b08: 242e 0010 movel %fp@(16),%d2
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
the_rbtree->root = NULL;
48b0c: 42aa 0004 clrl %a2@(4)
while ( count-- ) {
_RBTree_Insert(the_rbtree, next);
48b10: 47f9 0004 8ab8 lea 48ab8 <_RBTree_Insert>,%a3
the_rbtree->first[0] = NULL;
48b16: 42aa 0008 clrl %a2@(8)
the_rbtree->first[1] = NULL;
48b1a: 42aa 000c clrl %a2@(12)
the_rbtree->compare_function = compare_function; the_rbtree->is_unique = is_unique;
48b1e: 1540 0014 moveb %d0,%a2@(20)
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
48b22: 600c bras 48b30 <_RBTree_Initialize+0x4c>
_RBTree_Insert(the_rbtree, next);
48b24: 2f02 movel %d2,%sp@-
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
48b26: d484 addl %d4,%d2 48b28: 5383 subql #1,%d3
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
_RBTree_Insert(the_rbtree, next);
48b2a: 2f0a movel %a2,%sp@- 48b2c: 4e93 jsr %a3@
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
48b2e: 508f addql #8,%sp
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
48b30: 4a83 tstl %d3
48b32: 66f0 bnes 48b24 <_RBTree_Initialize+0x40>
_RBTree_Insert(the_rbtree, next);
next = (RBTree_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
}
48b34: 4cee 0c1c ffec moveml %fp@(-20),%d2-%d4/%a2-%a3 48b3a: 4e5e unlk %fp
...
0004b9dc <_RBTree_Sibling>:
* exists, and NULL if not.
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
RBTree_Node *the_node
)
{
4b9dc: 4e56 0000 linkw %fp,#0 4b9e0: 226e 0008 moveal %fp@(8),%a1
if(!the_node) return NULL;
4b9e4: 4a89 tstl %a1
4b9e6: 6718 beqs 4ba00 <_RBTree_Sibling+0x24> if(!(the_node->parent)) return NULL;
4b9e8: 2051 moveal %a1@,%a0 4b9ea: 4a88 tstl %a0
4b9ec: 6712 beqs 4ba00 <_RBTree_Sibling+0x24> <== NEVER TAKEN
if(!(the_node->parent->parent)) return NULL;
4b9ee: 4a90 tstl %a0@
4b9f0: 670e beqs 4ba00 <_RBTree_Sibling+0x24>
if(the_node == the_node->parent->child[RBT_LEFT])
4b9f2: 2028 0004 movel %a0@(4),%d0 4b9f6: b089 cmpl %a1,%d0
4b9f8: 6608 bnes 4ba02 <_RBTree_Sibling+0x26>
return the_node->parent->child[RBT_RIGHT];
4b9fa: 2028 0008 movel %a0@(8),%d0 4b9fe: 6002 bras 4ba02 <_RBTree_Sibling+0x26>
RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
4ba00: 4280 clrl %d0
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
else
return the_node->parent->child[RBT_LEFT];
}
4ba02: 4e5e unlk %fp <== NOT EXECUTED
0004bd4a <_RBTree_Validate_insert_unprotected>:
* append operation.
*/
void _RBTree_Validate_insert_unprotected(
RBTree_Node *the_node
)
{
4bd4a: 4e56 fff0 linkw %fp,#-16 4bd4e: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 4bd52: 266e 0008 moveal %fp@(8),%a3
}
the_node->parent->color = RBT_BLACK;
g->color = RBT_RED;
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
4bd56: 49fa ffa0 lea %pc@(4bcf8 <_RBTree_Rotate>),%a4
RBTree_Node *u,*g;
/* note: the insert root case is handled already */
/* if the parent is black, nothing needs to be done
* otherwise may need to loop a few times */
while (_RBTree_Is_red(_RBTree_Parent(the_node))) {
4bd5a: 604e bras 4bdaa <_RBTree_Validate_insert_unprotected+0x60>
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(!(the_node->parent->parent->parent)) return NULL;
4bd5c: 4a92 tstl %a2@
4bd5e: 6762 beqs 4bdc2 <_RBTree_Validate_insert_unprotected+0x78><== NEVER TAKEN
{
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])
4bd60: 226a 0004 moveal %a2@(4),%a1 4bd64: b3c8 cmpal %a0,%a1
4bd66: 6604 bnes 4bd6c <_RBTree_Validate_insert_unprotected+0x22>
return the_node->parent->child[RBT_RIGHT];
4bd68: 226a 0008 moveal %a2@(8),%a1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4bd6c: 4a89 tstl %a1
4bd6e: 6752 beqs 4bdc2 <_RBTree_Validate_insert_unprotected+0x78>
4bd70: 7001 moveq #1,%d0 4bd72: b0a9 000c cmpl %a1@(12),%d0
4bd76: 664a bnes 4bdc2 <_RBTree_Validate_insert_unprotected+0x78>
u = _RBTree_Parent_sibling(the_node);
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
4bd78: 42a8 000c clrl %a0@(12)
u->color = RBT_BLACK;
g->color = RBT_RED;
4bd7c: 264a moveal %a2,%a3
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
4bd7e: 42a9 000c clrl %a1@(12)
g->color = RBT_RED;
4bd82: 2540 000c movel %d0,%a2@(12) 4bd86: 6022 bras 4bdaa <_RBTree_Validate_insert_unprotected+0x60>
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
4bd88: 2f02 movel %d2,%sp@- 4bd8a: 2f08 movel %a0,%sp@- 4bd8c: 4e94 jsr %a4@
the_node = the_node->child[pdir];
4bd8e: 508f addql #8,%sp 4bd90: 2673 2c04 moveal %a3@(00000004,%d2:l:4),%a3
}
the_node->parent->color = RBT_BLACK;
4bd94: 2053 moveal %a3@,%a0
g->color = RBT_RED;
4bd96: 7001 moveq #1,%d0
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
4bd98: 42a8 000c clrl %a0@(12)
g->color = RBT_RED;
4bd9c: 2540 000c movel %d0,%a2@(12)
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
4bda0: 9082 subl %d2,%d0 4bda2: 2f00 movel %d0,%sp@- 4bda4: 2f0a movel %a2,%sp@- 4bda6: 4e94 jsr %a4@ 4bda8: 508f addql #8,%sp
ISR_Level level;
_ISR_Disable( level );
return _RBTree_Insert_unprotected( tree, node );
_ISR_Enable( level );
}
4bdaa: 2053 moveal %a3@,%a0
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
4bdac: 2450 moveal %a0@,%a2 4bdae: 4a8a tstl %a2
4bdb0: 670a beqs 4bdbc <_RBTree_Validate_insert_unprotected+0x72>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
4bdb2: 7001 moveq #1,%d0 4bdb4: b0a8 000c cmpl %a0@(12),%d0
4bdb8: 6622 bnes 4bddc <_RBTree_Validate_insert_unprotected+0x92>
4bdba: 60a0 bras 4bd5c <_RBTree_Validate_insert_unprotected+0x12>
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
4bdbc: 42ab 000c clrl %a3@(12) 4bdc0: 601a bras 4bddc <_RBTree_Validate_insert_unprotected+0x92>
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
4bdc2: b1ea 0004 cmpal %a2@(4),%a0 4bdc6: 56c2 sne %d2
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
4bdc8: b7e8 0004 cmpal %a0@(4),%a3 4bdcc: 56c0 sne %d0
RBTree_Direction pdir = the_node->parent != g->child[0];
4bdce: 49c2 extbl %d2 4bdd0: 4482 negl %d2
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
4bdd2: 49c0 extbl %d0 4bdd4: 4480 negl %d0
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
4bdd6: b480 cmpl %d0,%d2
4bdd8: 66ae bnes 4bd88 <_RBTree_Validate_insert_unprotected+0x3e>
4bdda: 60b8 bras 4bd94 <_RBTree_Validate_insert_unprotected+0x4a>
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
}
4bddc: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
4bde2: 4e5e unlk %fp <== NOT EXECUTED
00057a68 <_Region_Process_queue>:
*/
void _Region_Process_queue(
Region_Control *the_region
)
{
57a68: 4e56 ffe4 linkw %fp,#-28
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
57a6c: 2039 0007 6b3c movel 76b3c <_Thread_Dispatch_disable_level>,%d0 57a72: 5280 addql #1,%d0 57a74: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@ 57a78: 23c0 0007 6b3c movel %d0,76b3c <_Thread_Dispatch_disable_level> 57a7e: 266e 0008 moveal %fp@(8),%a3
return _Thread_Dispatch_disable_level;
57a82: 2039 0007 6b3c movel 76b3c <_Thread_Dispatch_disable_level>,%d0
* NOTE: Be sure to disable dispatching before unlocking the mutex * since we do not want to open a window where a context * switch could occur. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator();
57a88: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@-
/*
* NOTE: The following loop is O(n) where n is the number of
* threads whose memory request is satisfied.
*/
for ( ; ; ) {
the_thread = _Thread_queue_First( &the_region->Wait_queue );
57a8e: 240b movel %a3,%d2
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
Region_Control *the_region,
uintptr_t size
)
{
return _Heap_Allocate( &the_region->Memory, size );
57a90: 260b movel %a3,%d3 57a92: 0682 0000 0010 addil #16,%d2 57a98: 0683 0000 0068 addil #104,%d3 57a9e: 4bf9 0005 2ec8 lea 52ec8 <_Heap_Allocate_aligned_with_boundary>,%a5
if ( the_segment == NULL )
break;
*(void **)the_thread->Wait.return_argument = the_segment;
the_region->number_of_used_blocks += 1;
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
57aa4: 49f9 0005 80ec lea 580ec <_Thread_queue_Extract>,%a4
* NOTE: Be sure to disable dispatching before unlocking the mutex * since we do not want to open a window where a context * switch could occur. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator();
57aaa: 4eb9 0005 2428 jsr 52428 <_API_Mutex_Unlock> 57ab0: 588f addql #4,%sp
/*
* NOTE: The following loop is O(n) where n is the number of
* threads whose memory request is satisfied.
*/
for ( ; ; ) {
the_thread = _Thread_queue_First( &the_region->Wait_queue );
57ab2: 283c 0005 81e8 movel #360936,%d4 57ab8: 2f02 movel %d2,%sp@- 57aba: 2044 moveal %d4,%a0 57abc: 4e90 jsr %a0@
if ( the_thread == NULL )
57abe: 588f addql #4,%sp
/*
* NOTE: The following loop is O(n) where n is the number of
* threads whose memory request is satisfied.
*/
for ( ; ; ) {
the_thread = _Thread_queue_First( &the_region->Wait_queue );
57ac0: 2440 moveal %d0,%a2
if ( the_thread == NULL )
57ac2: 4a80 tstl %d0
57ac4: 672c beqs 57af2 <_Region_Process_queue+0x8a>
57ac6: 42a7 clrl %sp@- 57ac8: 42a7 clrl %sp@- 57aca: 2f2a 0024 movel %a2@(36),%sp@- 57ace: 2f03 movel %d3,%sp@- 57ad0: 4e95 jsr %a5@
the_segment = (void **) _Region_Allocate_segment(
the_region,
the_thread->Wait.count
);
if ( the_segment == NULL )
57ad2: 4fef 0010 lea %sp@(16),%sp 57ad6: 4a80 tstl %d0
57ad8: 6718 beqs 57af2 <_Region_Process_queue+0x8a> <== NEVER TAKEN
break;
*(void **)the_thread->Wait.return_argument = the_segment;
57ada: 206a 0028 moveal %a2@(40),%a0 57ade: 2080 movel %d0,%a0@
the_region->number_of_used_blocks += 1;
57ae0: 52ab 0064 addql #1,%a3@(100)
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
57ae4: 2f0a movel %a2,%sp@- 57ae6: 2f02 movel %d2,%sp@- 57ae8: 4e94 jsr %a4@
the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
}
57aea: 508f addql #8,%sp
break;
*(void **)the_thread->Wait.return_argument = the_segment;
the_region->number_of_used_blocks += 1;
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
57aec: 42aa 0034 clrl %a2@(52)
}
57af0: 60c6 bras 57ab8 <_Region_Process_queue+0x50>
_Thread_Enable_dispatch(); }
57af2: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5 57af8: 4e5e unlk %fp
*(void **)the_thread->Wait.return_argument = the_segment;
the_region->number_of_used_blocks += 1;
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
57afa: 4ef9 0005 4ab4 jmp 54ab4 <_Thread_Enable_dispatch>
00047b10 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
47b10: 4e56 0000 linkw %fp,#0 47b14: 2f0a movel %a2,%sp@-
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
47b16: 4878 0018 pea 18 <OPER2+0x4>
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
47b1a: 246e 0008 moveal %fp@(8),%a2
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
47b1e: 4eb9 0004 933c jsr 4933c <_Workspace_Allocate>
if ( sched ) {
47b24: 588f addql #4,%sp 47b26: 4a80 tstl %d0
47b28: 670e beqs 47b38 <_Scheduler_EDF_Allocate+0x28> <== NEVER TAKEN
the_thread->scheduler_info = sched;
47b2a: 2540 008a movel %d0,%a2@(138)
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
47b2e: 2040 moveal %d0,%a0
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
47b30: 7202 moveq #2,%d1
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
if ( sched ) {
the_thread->scheduler_info = sched;
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
47b32: 208a movel %a2,%a0@
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
47b34: 2141 0014 movel %d1,%a0@(20)
}
return sched;
}
47b38: 246e fffc moveal %fp@(-4),%a2
47b3c: 4e5e unlk %fp <== NOT EXECUTED
00047b40 <_Scheduler_EDF_Block>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Block(
Thread_Control *the_thread
)
{
47b40: 4e56 0000 linkw %fp,#0 47b44: 2f02 movel %d2,%sp@- 47b46: 242e 0008 movel %fp@(8),%d2
_Scheduler_EDF_Extract( the_thread );
47b4a: 2f02 movel %d2,%sp@- 47b4c: 4eb9 0004 7bb8 jsr 47bb8 <_Scheduler_EDF_Extract>
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
47b52: 588f addql #4,%sp 47b54: b4b9 0006 04a6 cmpl 604a6 <_Per_CPU_Information+0x10>,%d2
47b5a: 6606 bnes 47b62 <_Scheduler_EDF_Block+0x22> <== NEVER TAKEN
_Scheduler_EDF_Schedule();
47b5c: 4eb9 0004 7cd8 jsr 47cd8 <_Scheduler_EDF_Schedule>
if ( _Thread_Is_executing( the_thread ) )
47b62: b4b9 0006 04a2 cmpl 604a2 <_Per_CPU_Information+0xc>,%d2
47b68: 6608 bnes 47b72 <_Scheduler_EDF_Block+0x32> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
47b6a: 7001 moveq #1,%d0 47b6c: 13c0 0006 04ae moveb %d0,604ae <_Per_CPU_Information+0x18>
}
47b72: 242e fffc movel %fp@(-4),%d2 47b76: 4e5e unlk %fp
...
00047be4 <_Scheduler_EDF_Free>:
#include <rtems/score/wkspace.h>
void _Scheduler_EDF_Free(
Thread_Control *the_thread
)
{
47be4: 4e56 0000 linkw %fp,#0
_Workspace_Free( the_thread->scheduler_info );
47be8: 206e 0008 moveal %fp@(8),%a0 47bec: 2d68 008a 0008 movel %a0@(138),%fp@(8)
}
47bf2: 4e5e unlk %fp
void _Scheduler_EDF_Free(
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
47bf4: 4ef9 0004 9358 jmp 49358 <_Workspace_Free>
...
00047c9c <_Scheduler_EDF_Release_job>:
void _Scheduler_EDF_Release_job(
Thread_Control *the_thread,
uint32_t deadline
)
{
47c9c: 4e56 0000 linkw %fp,#0 47ca0: 206e 0008 moveal %fp@(8),%a0 47ca4: 202e 000c movel %fp@(12),%d0
Priority_Control new_priority;
if (deadline) {
47ca8: 670e beqs 47cb8 <_Scheduler_EDF_Release_job+0x1c><== NEVER TAKEN
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
47caa: 2239 0006 0142 movel 60142 <_Watchdog_Ticks_since_boot>,%d1 47cb0: d081 addl %d1,%d0 47cb2: 0880 001f bclr #31,%d0 47cb6: 6004 bras 47cbc <_Scheduler_EDF_Release_job+0x20>
& ~SCHEDULER_EDF_PRIO_MSB;
}
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
47cb8: 2028 00ac movel %a0@(172),%d0 <== NOT EXECUTED
}
the_thread->real_priority = new_priority;
47cbc: 2140 0018 movel %d0,%a0@(24)
_Thread_Change_priority(the_thread, new_priority, true);
47cc0: 4878 0001 pea 1 <ADD> 47cc4: 2f00 movel %d0,%sp@- 47cc6: 2f08 movel %a0,%sp@- 47cc8: 4eb9 0004 7fdc jsr 47fdc <_Thread_Change_priority> 47cce: 4fef 000c lea %sp@(12),%sp
}
47cd2: 4e5e unlk %fp
...
00047cfc <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
47cfc: 4e56 0000 linkw %fp,#0 47d00: 2f0a movel %a2,%sp@- 47d02: 246e 0008 moveal %fp@(8),%a2
_Scheduler_EDF_Enqueue(the_thread);
47d06: 2f0a movel %a2,%sp@- 47d08: 4eb9 0004 7b88 jsr 47b88 <_Scheduler_EDF_Enqueue> 47d0e: 2f2a 0014 movel %a2@(20),%sp@-
* 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(
47d12: 2079 0006 04a6 moveal 604a6 <_Per_CPU_Information+0x10>,%a0 47d18: 2f28 0014 movel %a0@(20),%sp@- 47d1c: 2079 0005 e6fe moveal 5e6fe <_Scheduler+0x30>,%a0 47d22: 4e90 jsr %a0@ 47d24: 4fef 000c lea %sp@(12),%sp 47d28: 4a80 tstl %d0
47d2a: 6c20 bges 47d4c <_Scheduler_EDF_Unblock+0x50>
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
47d2c: 2079 0006 04a2 moveal 604a2 <_Per_CPU_Information+0xc>,%a0
* 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;
47d32: 23ca 0006 04a6 movel %a2,604a6 <_Per_CPU_Information+0x10>
if ( _Thread_Executing->is_preemptible ||
47d38: 4a28 0074 tstb %a0@(116)
47d3c: 6606 bnes 47d44 <_Scheduler_EDF_Unblock+0x48> <== ALWAYS TAKEN
47d3e: 4aaa 0014 tstl %a2@(20) <== NOT EXECUTED 47d42: 6608 bnes 47d4c <_Scheduler_EDF_Unblock+0x50> <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
47d44: 7001 moveq #1,%d0 47d46: 13c0 0006 04ae moveb %d0,604ae <_Per_CPU_Information+0x18>
} }
47d4c: 246e fffc moveal %fp@(-4),%a2
47d50: 4e5e unlk %fp <== NOT EXECUTED
00047d54 <_Scheduler_EDF_Update>:
{
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
47d54: 7002 moveq #2,%d0
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
47d56: 4e56 0000 linkw %fp,#0 47d5a: 2f0a movel %a2,%sp@- 47d5c: 246e 0008 moveal %fp@(8),%a2
Scheduler_EDF_Per_thread *sched_info =
47d60: 206a 008a moveal %a2@(138),%a0
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
47d64: 2f02 movel %d2,%sp@-
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
if (sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN) {
47d66: b0a8 0014 cmpl %a0@(20),%d0
47d6a: 6618 bnes 47d84 <_Scheduler_EDF_Update+0x30>
/* Shifts the priority to the region of background tasks. */
the_thread->Start.initial_priority |= (SCHEDULER_EDF_PRIO_MSB);
47d6c: 202a 00ac movel %a2@(172),%d0 47d70: 08c0 001f bset #31,%d0 47d74: 2540 00ac movel %d0,%a2@(172)
the_thread->real_priority = the_thread->Start.initial_priority;
47d78: 2540 0018 movel %d0,%a2@(24)
the_thread->current_priority = the_thread->Start.initial_priority;
47d7c: 2540 0014 movel %d0,%a2@(20)
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
47d80: 42a8 0014 clrl %a0@(20)
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
47d84: 7001 moveq #1,%d0 47d86: b0a8 0014 cmpl %a0@(20),%d0
47d8a: 664c bnes 47dd8 <_Scheduler_EDF_Update+0x84> <== ALWAYS TAKEN
Thread_Control *the_thread
)
{
Scheduler_EDF_Per_thread *sched_info =
(Scheduler_EDF_Per_thread*)the_thread->scheduler_info;
RBTree_Node *the_node = &(sched_info->Node);
47d8c: 2408 movel %a0,%d2 <== NOT EXECUTED 47d8e: 5882 addql #4,%d2 <== NOT EXECUTED
the_thread->current_priority = the_thread->Start.initial_priority;
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
_RBTree_Extract(&_Scheduler_EDF_Ready_queue, the_node);
47d90: 2f02 movel %d2,%sp@- <== NOT EXECUTED 47d92: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED 47d98: 4eb9 0004 bccc jsr 4bccc <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert(&_Scheduler_EDF_Ready_queue, the_node);
47d9e: 2f02 movel %d2,%sp@- <== NOT EXECUTED 47da0: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED 47da6: 4eb9 0004 be90 jsr 4be90 <_RBTree_Insert> <== NOT EXECUTED
_Scheduler_EDF_Schedule();
47dac: 4eb9 0004 7cd8 jsr 47cd8 <_Scheduler_EDF_Schedule> <== NOT EXECUTED
if ( _Thread_Executing != _Thread_Heir ) {
47db2: 2079 0006 04a2 moveal 604a2 <_Per_CPU_Information+0xc>,%a0 <== NOT EXECUTED 47db8: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED 47dbc: b1f9 0006 04a6 cmpal 604a6 <_Per_CPU_Information+0x10>,%a0 <== NOT EXECUTED 47dc2: 6714 beqs 47dd8 <_Scheduler_EDF_Update+0x84> <== NOT EXECUTED
if ( _Thread_Executing->is_preemptible ||
47dc4: 4a28 0074 tstb %a0@(116) <== NOT EXECUTED 47dc8: 6606 bnes 47dd0 <_Scheduler_EDF_Update+0x7c> <== NOT EXECUTED 47dca: 4aaa 0014 tstl %a2@(20) <== NOT EXECUTED 47dce: 6608 bnes 47dd8 <_Scheduler_EDF_Update+0x84> <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
47dd0: 7001 moveq #1,%d0 <== NOT EXECUTED 47dd2: 13c0 0006 04ae moveb %d0,604ae <_Per_CPU_Information+0x18> <== NOT EXECUTED
}
}
}
47dd8: 242e fff8 movel %fp@(-8),%d2 47ddc: 246e fffc moveal %fp@(-4),%a2
47de0: 4e5e unlk %fp <== NOT EXECUTED
00047de4 <_Scheduler_EDF_Yield>:
Thread_Control *executing = _Thread_Executing;
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
47de4: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
47dea: 4e56 fff4 linkw %fp,#-12 <== NOT EXECUTED 47dee: 48d7 040c moveml %d2-%d3/%a2,%sp@ <== NOT EXECUTED
Scheduler_EDF_Per_thread *first_info;
RBTree_Node *first_node;
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
47df2: 2479 0006 04a2 moveal 604a2 <_Per_CPU_Information+0xc>,%a2 <== NOT EXECUTED
Scheduler_EDF_Per_thread *executing_info =
47df8: 262a 008a movel %a2@(138),%d3 <== NOT EXECUTED
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
47dfc: 40c2 movew %sr,%d2 <== NOT EXECUTED 47dfe: 8082 orl %d2,%d0 <== NOT EXECUTED 47e00: 46c0 movew %d0,%sr <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _RBTree_Has_only_one_node(
const RBTree_Control *the_rbtree
)
{
if(!the_rbtree) return NULL; /* TODO: expected behavior? */
return (the_rbtree->root->child[RBT_LEFT] == NULL && the_rbtree->root->child[RBT_RIGHT] == NULL);
47e02: 2079 0006 04bc moveal 604bc <_Scheduler_EDF_Ready_queue+0x4>,%a0<== NOT EXECUTED 47e08: 4aa8 0004 tstl %a0@(4) <== NOT EXECUTED 47e0c: 660c bnes 47e1a <_Scheduler_EDF_Yield+0x36> <== NOT EXECUTED
#include <rtems/score/isr.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
47e0e: 4aa8 0008 tstl %a0@(8) <== NOT EXECUTED 47e12: 57c0 seq %d0 <== NOT EXECUTED 47e14: 49c0 extbl %d0 <== NOT EXECUTED 47e16: 4480 negl %d0 <== NOT EXECUTED 47e18: 6002 bras 47e1c <_Scheduler_EDF_Yield+0x38> <== NOT EXECUTED 47e1a: 4280 clrl %d0 <== NOT EXECUTED
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
if ( !_RBTree_Has_only_one_node(&_Scheduler_EDF_Ready_queue) ) {
47e1c: 4a00 tstb %d0 <== NOT EXECUTED 47e1e: 6652 bnes 47e72 <_Scheduler_EDF_Yield+0x8e> <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
47e20: 5883 addql #4,%d3 <== NOT EXECUTED
if ( !_RBTree_Has_only_one_node(&_Scheduler_EDF_Ready_queue) ) {
/*
* 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 );
47e22: 2f03 movel %d3,%sp@- <== NOT EXECUTED 47e24: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED 47e2a: 4eb9 0004 bccc jsr 4bccc <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node );
47e30: 2f03 movel %d3,%sp@- <== NOT EXECUTED 47e32: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED 47e38: 4eb9 0004 be90 jsr 4be90 <_RBTree_Insert> <== NOT EXECUTED
_ISR_Flash( level );
47e3e: 203c 0000 0700 movel #1792,%d0 <== NOT EXECUTED 47e44: 46c2 movew %d2,%sr <== NOT EXECUTED 47e46: 8082 orl %d2,%d0 <== NOT EXECUTED 47e48: 46c0 movew %d0,%sr <== NOT EXECUTED
if ( _Thread_Is_heir( executing ) ) {
47e4a: 4fef 0010 lea %sp@(16),%sp <== NOT EXECUTED 47e4e: b5f9 0006 04a6 cmpal 604a6 <_Per_CPU_Information+0x10>,%a2 <== NOT EXECUTED 47e54: 6624 bnes 47e7a <_Scheduler_EDF_Yield+0x96> <== NOT EXECUTED
first_node = _RBTree_Peek( &_Scheduler_EDF_Ready_queue, RBT_LEFT );
47e56: 42a7 clrl %sp@- <== NOT EXECUTED 47e58: 4879 0006 04b8 pea 604b8 <_Scheduler_EDF_Ready_queue> <== NOT EXECUTED 47e5e: 4eb9 0004 bebc jsr 4bebc <_RBTree_Peek> <== NOT EXECUTED
first_info =
_RBTree_Container_of(first_node, Scheduler_EDF_Per_thread, Node);
_Thread_Heir = first_info->thread;
47e64: 508f addql #8,%sp <== NOT EXECUTED 47e66: 2040 moveal %d0,%a0 <== NOT EXECUTED 47e68: 5988 subql #4,%a0 <== NOT EXECUTED 47e6a: 23d0 0006 04a6 movel %a0@,604a6 <_Per_CPU_Information+0x10><== NOT EXECUTED 47e70: 6008 bras 47e7a <_Scheduler_EDF_Yield+0x96> <== NOT EXECUTED
}
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
47e72: b5f9 0006 04a6 cmpal 604a6 <_Per_CPU_Information+0x10>,%a2 <== NOT EXECUTED 47e78: 6708 beqs 47e82 <_Scheduler_EDF_Yield+0x9e> <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
47e7a: 7001 moveq #1,%d0 <== NOT EXECUTED 47e7c: 13c0 0006 04ae moveb %d0,604ae <_Per_CPU_Information+0x18> <== NOT EXECUTED
_ISR_Enable( level );
47e82: 46c2 movew %d2,%sr <== NOT EXECUTED
}
47e84: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 <== NOT EXECUTED 47e8a: 4e5e unlk %fp <== NOT EXECUTED
...
00047434 <_Scheduler_Handler_initialization>:
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
47434: 4e56 0000 linkw %fp,#0
(*_Scheduler.Operations.initialize)(); }
47438: 4e5e unlk %fp
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
(*_Scheduler.Operations.initialize)();
4743a: 2279 0005 d2a2 moveal 5d2a2 <_Scheduler+0x4>,%a1 47440: 4ed1 jmp %a1@
...
0004760c <_Scheduler_priority_Free>:
#include <rtems/score/wkspace.h>
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
4760c: 4e56 0000 linkw %fp,#0
_Workspace_Free( the_thread->scheduler_info );
47610: 206e 0008 moveal %fp@(8),%a0 47614: 2d68 008a 0008 movel %a0@(138),%fp@(8)
}
4761a: 4e5e unlk %fp
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
4761c: 4ef9 0004 8c2c jmp 48c2c <_Workspace_Free>
...
00047704 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
47704: 4e56 0000 linkw %fp,#0 47708: 2f0a movel %a2,%sp@-
Thread_Control *executing;
executing = _Thread_Executing;
4770a: 2479 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a2
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
47710: 4a2a 0074 tstb %a2@(116)
47714: 6758 beqs 4776e <_Scheduler_priority_Tick+0x6a>
return;
if ( !_States_Is_ready( executing->current_state ) )
47716: 4aaa 0010 tstl %a2@(16)
4771a: 6652 bnes 4776e <_Scheduler_priority_Tick+0x6a>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
4771c: 202a 007a movel %a2@(122),%d0 47720: 7201 moveq #1,%d1 47722: b280 cmpl %d0,%d1
47724: 6248 bhis 4776e <_Scheduler_priority_Tick+0x6a>
47726: 123c 0002 moveb #2,%d1 4772a: b280 cmpl %d0,%d1
4772c: 640a bccs 47738 <_Scheduler_priority_Tick+0x34>
4772e: 123c 0003 moveb #3,%d1 47732: b280 cmpl %d0,%d1
47734: 6638 bnes 4776e <_Scheduler_priority_Tick+0x6a> <== NEVER TAKEN
47736: 6020 bras 47758 <_Scheduler_priority_Tick+0x54>
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 ) {
47738: 202a 0076 movel %a2@(118),%d0 4773c: 5380 subql #1,%d0 4773e: 2540 0076 movel %d0,%a2@(118)
47742: 6e2a bgts 4776e <_Scheduler_priority_Tick+0x6a>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
47744: 2079 0005 d2aa moveal 5d2aa <_Scheduler+0xc>,%a0 4774a: 4e90 jsr %a0@
* 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;
4774c: 41f9 0005 eb50 lea 5eb50 <_Thread_Ticks_per_timeslice>,%a0 47752: 2550 0076 movel %a0@,%a2@(118) 47756: 6016 bras 4776e <_Scheduler_priority_Tick+0x6a>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
47758: 202a 0076 movel %a2@(118),%d0 4775c: 5380 subql #1,%d0 4775e: 2540 0076 movel %d0,%a2@(118)
47762: 660a bnes 4776e <_Scheduler_priority_Tick+0x6a> (*executing->budget_callout)( executing );
47764: 2f0a movel %a2,%sp@- 47766: 206a 007e moveal %a2@(126),%a0 4776a: 4e90 jsr %a0@ 4776c: 588f addql #4,%sp
break;
#endif
}
}
4776e: 246e fffc moveal %fp@(-4),%a2 47772: 4e5e unlk %fp
...
000461dc <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
461dc: 4e56 0000 linkw %fp,#0 461e0: 206e 0008 moveal %fp@(8),%a0 461e4: 2f03 movel %d3,%sp@-
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
461e6: 2039 0005 efd8 movel 5efd8 <Configuration+0xc>,%d0
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
461ec: 2f02 movel %d2,%sp@-
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) ||
461ee: 4a88 tstl %a0
461f0: 6762 beqs 46254 <_TOD_Validate+0x78> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
461f2: 243c 000f 4240 movel #1000000,%d2 461f8: 4c40 2002 remul %d0,%d2,%d2
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
461fc: b4a8 0018 cmpl %a0@(24),%d2
46200: 6352 blss 46254 <_TOD_Validate+0x78>
(the_tod->ticks >= ticks_per_second) ||
46202: 763b moveq #59,%d3 46204: b6a8 0014 cmpl %a0@(20),%d3
46208: 654a bcss 46254 <_TOD_Validate+0x78>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
4620a: b6a8 0010 cmpl %a0@(16),%d3
4620e: 6544 bcss 46254 <_TOD_Validate+0x78>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
46210: 7017 moveq #23,%d0 46212: b0a8 000c cmpl %a0@(12),%d0
46216: 653c bcss 46254 <_TOD_Validate+0x78>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
46218: 2028 0004 movel %a0@(4),%d0
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) ||
4621c: 6736 beqs 46254 <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->month == 0) ||
4621e: 720c moveq #12,%d1 46220: b280 cmpl %d0,%d1
46222: 6530 bcss 46254 <_TOD_Validate+0x78>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
46224: 2410 movel %a0@,%d2
(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) ||
46226: 0c82 0000 07c3 cmpil #1987,%d2
4622c: 6326 blss 46254 <_TOD_Validate+0x78>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
4622e: 2228 0008 movel %a0@(8),%d1
(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) ||
46232: 6720 beqs 46254 <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
46234: 163c 0003 moveb #3,%d3 46238: 41f9 0005 e058 lea 5e058 <_TOD_Days_per_month>,%a0 4623e: c483 andl %d3,%d2
46240: 6606 bnes 46248 <_TOD_Validate+0x6c>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
46242: 2030 0c34 movel %a0@(00000034,%d0:l:4),%d0 46246: 6004 bras 4624c <_TOD_Validate+0x70>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
46248: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
4624c: b081 cmpl %d1,%d0 4624e: 54c0 scc %d0 46250: 4480 negl %d0 46252: 6002 bras 46256 <_TOD_Validate+0x7a>
(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;
46254: 4200 clrb %d0
if ( the_tod->day > days_in_month )
return false;
return true;
}
46256: 241f movel %sp@+,%d2 46258: 261f movel %sp@+,%d3 4625a: 4e5e unlk %fp
...
00047930 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47930: 4e56 fff0 linkw %fp,#-16 47934: 48d7 041c moveml %d2-%d4/%a2,%sp@ 47938: 246e 0008 moveal %fp@(8),%a2
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
4793c: 282a 0010 movel %a2@(16),%d4
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47940: 242e 000c movel %fp@(12),%d2
/* * 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 );
47944: 2f0a movel %a2,%sp@-
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47946: 162e 0013 moveb %fp@(19),%d3
/* * 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 );
4794a: 4eb9 0004 8548 jsr 48548 <_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 )
47950: 588f addql #4,%sp 47952: b4aa 0014 cmpl %a2@(20),%d2
47956: 670c beqs 47964 <_Thread_Change_priority+0x34>
_Thread_Set_priority( the_thread, new_priority );
47958: 2f02 movel %d2,%sp@- 4795a: 2f0a movel %a2,%sp@- 4795c: 4eb9 0004 84ec jsr 484ec <_Thread_Set_priority> 47962: 508f addql #8,%sp
_ISR_Disable( level );
47964: 203c 0000 0700 movel #1792,%d0 4796a: 40c2 movew %sr,%d2 4796c: 8082 orl %d2,%d0 4796e: 46c0 movew %d0,%sr 47970: 7204 moveq #4,%d1
/*
* 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;
47972: 202a 0010 movel %a2@(16),%d0 47976: c284 andl %d4,%d1
if ( state != STATES_TRANSIENT ) {
47978: 7804 moveq #4,%d4 4797a: b880 cmpl %d0,%d4
4797c: 672e beqs 479ac <_Thread_Change_priority+0x7c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
4797e: 4a81 tstl %d1
47980: 6608 bnes 4798a <_Thread_Change_priority+0x5a> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
47982: 72fb moveq #-5,%d1 47984: c280 andl %d0,%d1 47986: 2541 0010 movel %d1,%a2@(16)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
4798a: 46c2 movew %d2,%sr
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
4798c: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
47992: 676c beqs 47a00 <_Thread_Change_priority+0xd0>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
47994: 2d4a 000c movel %a2,%fp@(12) 47998: 2d6a 0044 0008 movel %a2@(68),%fp@(8)
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
4799e: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 479a4: 4e5e unlk %fp
/* 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 );
479a6: 4ef9 0004 844c jmp 4844c <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
479ac: 4a81 tstl %d1
479ae: 661e bnes 479ce <_Thread_Change_priority+0x9e> <== NEVER TAKEN
* 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 );
479b0: 42aa 0010 clrl %a2@(16)
if ( prepend_it )
479b4: 4a03 tstb %d3
479b6: 670a beqs 479c2 <_Thread_Change_priority+0x92>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
479b8: 2f0a movel %a2,%sp@- 479ba: 2079 0005 d2c6 moveal 5d2c6 <_Scheduler+0x28>,%a0 479c0: 6008 bras 479ca <_Thread_Change_priority+0x9a>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
479c2: 2079 0005 d2c2 moveal 5d2c2 <_Scheduler+0x24>,%a0 479c8: 2f0a movel %a2,%sp@- 479ca: 4e90 jsr %a0@ 479cc: 588f addql #4,%sp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
479ce: 203c 0000 0700 movel #1792,%d0 479d4: 46c2 movew %d2,%sr 479d6: 8082 orl %d2,%d0 479d8: 46c0 movew %d0,%sr
* 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();
479da: 2079 0005 d2a6 moveal 5d2a6 <_Scheduler+0x8>,%a0 479e0: 4e90 jsr %a0@
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
479e2: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
* 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() &&
479e8: b1f9 0005 effe cmpal 5effe <_Per_CPU_Information+0x10>,%a0
479ee: 670e beqs 479fe <_Thread_Change_priority+0xce>
479f0: 4a28 0074 tstb %a0@(116)
479f4: 6708 beqs 479fe <_Thread_Change_priority+0xce>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
479f6: 7801 moveq #1,%d4 479f8: 13c4 0005 f006 moveb %d4,5f006 <_Per_CPU_Information+0x18>
_ISR_Enable( level );
479fe: 46c2 movew %d2,%sr
}
47a00: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 47a06: 4e5e unlk %fp
...
00047be4 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
47be4: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
47be8: 486e fffc pea %fp@(-4) 47bec: 2f2e 0008 movel %fp@(8),%sp@- 47bf0: 4eb9 0004 7da8 jsr 47da8 <_Thread_Get>
switch ( location ) {
47bf6: 508f addql #8,%sp 47bf8: 4aae fffc tstl %fp@(-4)
47bfc: 6624 bnes 47c22 <_Thread_Delay_ended+0x3e> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
47bfe: 2f3c 1000 0018 movel #268435480,%sp@- 47c04: 2f00 movel %d0,%sp@- 47c06: 4eb9 0004 7a0c jsr 47a0c <_Thread_Clear_state> 47c0c: 508f addql #8,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
47c0e: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0 47c14: 5380 subql #1,%d0 47c16: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47c1c: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
47c22: 4e5e unlk %fp
...
00047c28 <_Thread_Dispatch>:
* INTERRUPT LATENCY:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
47c28: 4e56 ffd0 linkw %fp,#-48
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
47c2c: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0 47c32: 5280 addql #1,%d0 47c34: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47c3a: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0 47c40: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
47c44: 223c 0000 0700 movel #1792,%d1
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
47c4a: 2479 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
47c50: 40c0 movew %sr,%d0 47c52: 8280 orl %d0,%d1 47c54: 46c1 movew %d1,%sr
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47c56: 260e movel %fp,%d3
_Timestamp_Subtract(
47c58: 240e movel %fp,%d2
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47c5a: 0683 ffff fff0 addil #-16,%d3 47c60: 2a3c 0004 af48 movel #307016,%d5
_Timestamp_Subtract(
47c66: 5182 subql #8,%d2 47c68: 283c 0004 86dc movel #296668,%d4
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
47c6e: 4bf9 0004 86a4 lea 486a4 <_Timespec_Add_to>,%a5
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
47c74: 49f9 0004 895c lea 4895c <_User_extensions_Thread_switch>,%a4
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
47c7a: 6000 00d2 braw 47d4e <_Thread_Dispatch+0x126>
heir = _Thread_Heir;
47c7e: 2679 0005 effe moveal 5effe <_Per_CPU_Information+0x10>,%a3
_Thread_Dispatch_necessary = false;
47c84: 4201 clrb %d1
_Thread_Executing = heir;
47c86: 23cb 0005 effa movel %a3,5effa <_Per_CPU_Information+0xc>
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
47c8c: 13c1 0005 f006 moveb %d1,5f006 <_Per_CPU_Information+0x18>
/*
* 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 )
47c92: b5cb cmpal %a3,%a2 47c94: 6700 00c2 beqw 47d58 <_Thread_Dispatch+0x130>
*/
#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 )
47c98: 7201 moveq #1,%d1 47c9a: b2ab 007a cmpl %a3@(122),%d1
47c9e: 660a bnes 47caa <_Thread_Dispatch+0x82>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
47ca0: 41f9 0005 eb50 lea 5eb50 <_Thread_Ticks_per_timeslice>,%a0 47ca6: 2750 0076 movel %a0@,%a3@(118)
_ISR_Enable( level );
47caa: 46c0 movew %d0,%sr
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47cac: 2f03 movel %d3,%sp@- 47cae: 2045 moveal %d5,%a0 47cb0: 4e90 jsr %a0@
_Timestamp_Subtract(
47cb2: 2044 moveal %d4,%a0 47cb4: 2f02 movel %d2,%sp@- 47cb6: 2f03 movel %d3,%sp@- 47cb8: 4879 0005 f008 pea 5f008 <_Per_CPU_Information+0x1a> 47cbe: 4e90 jsr %a0@
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
47cc0: 2f02 movel %d2,%sp@- 47cc2: 486a 0082 pea %a2@(130) 47cc6: 4e95 jsr %a5@
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
47cc8: 2079 0005 ec1e moveal 5ec1e <_Thread_libc_reent>,%a0 47cce: 4fef 0018 lea %sp@(24),%sp
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
47cd2: 202e fff0 movel %fp@(-16),%d0 47cd6: 222e fff4 movel %fp@(-12),%d1 47cda: 23c0 0005 f008 movel %d0,5f008 <_Per_CPU_Information+0x1a> 47ce0: 23c1 0005 f00c movel %d1,5f00c <_Per_CPU_Information+0x1e>
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
47ce6: 4a88 tstl %a0
47ce8: 6708 beqs 47cf2 <_Thread_Dispatch+0xca> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
47cea: 2550 00fa movel %a0@,%a2@(250)
*_Thread_libc_reent = heir->libc_reent;
47cee: 20ab 00fa movel %a3@(250),%a0@
}
_User_extensions_Thread_switch( executing, heir );
47cf2: 2f0b movel %a3,%sp@- 47cf4: 2f0a movel %a2,%sp@- 47cf6: 4e94 jsr %a4@
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
47cf8: 486b 00c2 pea %a3@(194) 47cfc: 486a 00c2 pea %a2@(194) 47d00: 4eb9 0004 8c7c jsr 48c7c <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
47d06: 4fef 0010 lea %sp@(16),%sp 47d0a: 4aaa 00f6 tstl %a2@(246)
47d0e: 672c beqs 47d3c <_Thread_Dispatch+0x114>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
47d10: 2079 0005 ec1a moveal 5ec1a <_Thread_Allocated_fp>,%a0 47d16: b1ca cmpal %a2,%a0
47d18: 6722 beqs 47d3c <_Thread_Dispatch+0x114>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
47d1a: 4a88 tstl %a0
47d1c: 670c beqs 47d2a <_Thread_Dispatch+0x102>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
47d1e: 4868 00f6 pea %a0@(246) 47d22: 4eb9 0004 8dc2 jsr 48dc2 <_CPU_Context_save_fp> 47d28: 588f addql #4,%sp
_Context_Restore_fp( &executing->fp_context );
47d2a: 486a 00f6 pea %a2@(246) 47d2e: 4eb9 0004 8de4 jsr 48de4 <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
47d34: 588f addql #4,%sp 47d36: 23ca 0005 ec1a movel %a2,5ec1a <_Thread_Allocated_fp>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
47d3c: 2479 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
47d42: 223c 0000 0700 movel #1792,%d1 47d48: 40c0 movew %sr,%d0 47d4a: 8280 orl %d0,%d1 47d4c: 46c1 movew %d1,%sr
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
47d4e: 1239 0005 f006 moveb 5f006 <_Per_CPU_Information+0x18>,%d1 47d54: 6600 ff28 bnew 47c7e <_Thread_Dispatch+0x56>
_ISR_Disable( level );
}
post_switch:
_ISR_Enable( level );
47d58: 46c0 movew %d0,%sr
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
47d5a: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0 47d60: 5380 subql #1,%d0 47d62: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47d68: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
_Thread_Unnest_dispatch();
_API_extensions_Run_postswitch();
47d6e: 4eb9 0004 6288 jsr 46288 <_API_extensions_Run_postswitch>
}
47d74: 4cee 3c3c ffd0 moveml %fp@(-48),%d2-%d5/%a2-%a5 47d7a: 4e5e unlk %fp
...
00047da8 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
47da8: 4e56 0000 linkw %fp,#0 47dac: 202e 0008 movel %fp@(8),%d0 47db0: 2f03 movel %d3,%sp@- 47db2: 206e 000c moveal %fp@(12),%a0 47db6: 2f02 movel %d2,%sp@-
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 ) ) {
47db8: 4a80 tstl %d0
47dba: 661e bnes 47dda <_Thread_Get+0x32>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
47dbc: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0 47dc2: 5280 addql #1,%d0 47dc4: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47dca: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
47dd0: 4290 clrl %a0@
tp = _Thread_Executing;
47dd2: 2039 0005 effa movel 5effa <_Per_CPU_Information+0xc>,%d0
goto done;
47dd8: 6044 bras 47e1e <_Thread_Get+0x76>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
47dda: 7418 moveq #24,%d2 47ddc: 2200 movel %d0,%d1 47dde: e4a9 lsrl %d2,%d1 47de0: 7607 moveq #7,%d3
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47de2: 143c 0002 moveb #2,%d2
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
47de6: c283 andl %d3,%d1
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47de8: 2241 moveal %d1,%a1 47dea: 5389 subql #1,%a1 47dec: b489 cmpl %a1,%d2
47dee: 643a bccs 47e2a <_Thread_Get+0x82>
47df0: 6014 bras 47e06 <_Thread_Get+0x5e>
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
47df2: 43f9 0005 eb54 lea 5eb54 <_Objects_Information_table>,%a1 47df8: 2271 1c00 moveal %a1@(00000000,%d1:l:4),%a1
* 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 ) {
47dfc: 4a89 tstl %a1
47dfe: 6706 beqs 47e06 <_Thread_Get+0x5e>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
47e00: 2229 0004 movel %a1@(4),%d1
if ( !information ) {
47e04: 6608 bnes 47e0e <_Thread_Get+0x66>
*location = OBJECTS_ERROR;
47e06: 7001 moveq #1,%d0 47e08: 2080 movel %d0,%a0@
{
uint32_t the_api;
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
47e0a: 4280 clrl %d0
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
goto done;
47e0c: 6010 bras 47e1e <_Thread_Get+0x76>
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
47e0e: 2f08 movel %a0,%sp@- 47e10: 2f00 movel %d0,%sp@- 47e12: 2f01 movel %d1,%sp@- 47e14: 4eb9 0004 70f8 jsr 470f8 <_Objects_Get> 47e1a: 4fef 000c lea %sp@(12),%sp
done:
return tp;
}
47e1e: 242e fff8 movel %fp@(-8),%d2 47e22: 262e fffc movel %fp@(-4),%d3 47e26: 4e5e unlk %fp 47e28: 4e75 rts
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
47e2a: 761b moveq #27,%d3 47e2c: 2400 movel %d0,%d2 47e2e: e6aa lsrl %d3,%d2
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
47e30: 163c 0001 moveb #1,%d3 47e34: b682 cmpl %d2,%d3
47e36: 67ba beqs 47df2 <_Thread_Get+0x4a>
47e38: 60cc bras 47e06 <_Thread_Get+0x5e>
...
0004cb84 <_Thread_Handler>:
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4cb84: 4e56 0000 linkw %fp,#0 4cb88: 2f0a movel %a2,%sp@-
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
4cb8a: 2479 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a2
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4cb90: 2f02 movel %d2,%sp@-
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
4cb92: 222a 00a8 movel %a2@(168),%d1
_ISR_Set_level(level);
4cb96: 40c0 movew %sr,%d0 4cb98: e189 lsll #8,%d1 4cb9a: 0280 0000 f8ff andil #63743,%d0 4cba0: 8081 orl %d1,%d0 4cba2: 46c0 movew %d0,%sr
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
doneConstructors = true;
4cba4: 7001 moveq #1,%d0
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
4cba6: 1439 0005 e358 moveb 5e358 <doneConstructors.3399>,%d2
doneConstructors = true;
4cbac: 13c0 0005 e358 moveb %d0,5e358 <doneConstructors.3399>
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
4cbb2: 4aaa 00f6 tstl %a2@(246)
4cbb6: 6720 beqs 4cbd8 <_Thread_Handler+0x54>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
4cbb8: 2079 0005 ec1a moveal 5ec1a <_Thread_Allocated_fp>,%a0 4cbbe: b1ca cmpal %a2,%a0
4cbc0: 6716 beqs 4cbd8 <_Thread_Handler+0x54>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
4cbc2: 4a88 tstl %a0
4cbc4: 670c beqs 4cbd2 <_Thread_Handler+0x4e>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
4cbc6: 4868 00f6 pea %a0@(246) 4cbca: 4eb9 0004 8dc2 jsr 48dc2 <_CPU_Context_save_fp> 4cbd0: 588f addql #4,%sp
_Thread_Allocated_fp = executing;
4cbd2: 23ca 0005 ec1a movel %a2,5ec1a <_Thread_Allocated_fp>
/* * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing );
4cbd8: 2f0a movel %a2,%sp@- 4cbda: 4eb9 0004 87d8 jsr 487d8 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
4cbe0: 4eb9 0004 7d80 jsr 47d80 <_Thread_Enable_dispatch>
/*
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (doCons) /* && (volatile void *)_init) */ {
4cbe6: 588f addql #4,%sp 4cbe8: 4a02 tstb %d2
4cbea: 6606 bnes 4cbf2 <_Thread_Handler+0x6e>
INIT_NAME ();
4cbec: 4eb9 0005 b2a8 jsr 5b2a8 <_init>
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
4cbf2: 202a 0092 movel %a2@(146),%d0
4cbf6: 6606 bnes 4cbfe <_Thread_Handler+0x7a>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
4cbf8: 2f2a 009a movel %a2@(154),%sp@- 4cbfc: 600a bras 4cc08 <_Thread_Handler+0x84>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
4cbfe: 7201 moveq #1,%d1 4cc00: b280 cmpl %d0,%d1
4cc02: 6610 bnes 4cc14 <_Thread_Handler+0x90> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
4cc04: 2f2a 0096 movel %a2@(150),%sp@- 4cc08: 206a 008e moveal %a2@(142),%a0 4cc0c: 4e90 jsr %a0@
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
4cc0e: 588f addql #4,%sp 4cc10: 2540 0028 movel %d0,%a2@(40)
* was placed in return_argument. This assumed that if it returned
* anything (which is not supporting in all APIs), then it would be
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
4cc14: 2f0a movel %a2,%sp@- 4cc16: 4eb9 0004 8810 jsr 48810 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
4cc1c: 4878 0005 pea 5 <COMPARE> 4cc20: 4878 0001 pea 1 <ADD> 4cc24: 42a7 clrl %sp@- 4cc26: 4eb9 0004 6bdc jsr 46bdc <_Internal_error_Occurred>
00047e3c <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
47e3c: 4e56 ffe4 linkw %fp,#-28 47e40: 222e 0010 movel %fp@(16),%d1 47e44: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@ 47e48: 246e 000c moveal %fp@(12),%a2 47e4c: 242e 0014 movel %fp@(20),%d2 47e50: 2a2e 001c movel %fp@(28),%d5 47e54: 282e 0024 movel %fp@(36),%d4 47e58: 162e 001b moveb %fp@(27),%d3 47e5c: 1c2e 0023 moveb %fp@(35),%d6
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
47e60: 42aa 00fe clrl %a2@(254) 47e64: 42aa 0102 clrl %a2@(258)
extensions_area = NULL;
the_thread->libc_reent = NULL;
47e68: 42aa 00fa clrl %a2@(250)
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
47e6c: 4a81 tstl %d1
47e6e: 6624 bnes 47e94 <_Thread_Initialize+0x58>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
47e70: 2f02 movel %d2,%sp@- 47e72: 2f0a movel %a2,%sp@- 47e74: 4eb9 0004 8584 jsr 48584 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
47e7a: 508f addql #8,%sp 47e7c: 4a80 tstl %d0 47e7e: 6700 0152 beqw 47fd2 <_Thread_Initialize+0x196> 47e82: b480 cmpl %d0,%d2 47e84: 6200 014c bhiw 47fd2 <_Thread_Initialize+0x196>
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
47e88: 222a 00be movel %a2@(190),%d1
the_thread->Start.core_allocated_stack = true;
47e8c: 7401 moveq #1,%d2 47e8e: 1542 00b0 moveb %d2,%a2@(176) 47e92: 6008 bras 47e9c <_Thread_Initialize+0x60>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
47e94: 4200 clrb %d0 47e96: 1540 00b0 moveb %d0,%a2@(176) 47e9a: 2002 movel %d2,%d0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
47e9c: 2541 00b6 movel %d1,%a2@(182)
the_stack->size = size;
47ea0: 2540 00b2 movel %d0,%a2@(178)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
47ea4: 4a03 tstb %d3
47ea6: 6714 beqs 47ebc <_Thread_Initialize+0x80>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
47ea8: 4878 001c pea 1c <OPER2+0x8> 47eac: 4eb9 0004 8c10 jsr 48c10 <_Workspace_Allocate>
if ( !fp_area )
47eb2: 588f addql #4,%sp
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
47eb4: 2600 movel %d0,%d3
if ( !fp_area )
47eb6: 6606 bnes 47ebe <_Thread_Initialize+0x82>
47eb8: 6000 00e4 braw 47f9e <_Thread_Initialize+0x162>
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
47ebc: 4283 clrl %d3
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
47ebe: 2039 0005 ec2a movel 5ec2a <_Thread_Maximum_extensions>,%d0
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area )
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
47ec4: 2543 00f6 movel %d3,%a2@(246)
the_thread->Start.fp_context = fp_area;
47ec8: 2543 00ba movel %d3,%a2@(186)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
47ecc: 42aa 0050 clrl %a2@(80)
the_watchdog->routine = routine;
47ed0: 42aa 0064 clrl %a2@(100)
the_watchdog->id = id;
47ed4: 42aa 0068 clrl %a2@(104)
the_watchdog->user_data = user_data;
47ed8: 42aa 006c clrl %a2@(108)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
47edc: 4a80 tstl %d0
47ede: 6718 beqs 47ef8 <_Thread_Initialize+0xbc>
extensions_area = _Workspace_Allocate(
47ee0: e588 lsll #2,%d0 47ee2: 2040 moveal %d0,%a0 47ee4: 4868 0004 pea %a0@(4) 47ee8: 4eb9 0004 8c10 jsr 48c10 <_Workspace_Allocate>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
47eee: 588f addql #4,%sp
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
47ef0: 2400 movel %d0,%d2
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
47ef2: 6606 bnes 47efa <_Thread_Initialize+0xbe>
47ef4: 6000 00aa braw 47fa0 <_Thread_Initialize+0x164>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
47ef8: 4282 clrl %d2
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
47efa: 2542 0106 movel %d2,%a2@(262)
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
47efe: 6718 beqs 47f18 <_Thread_Initialize+0xdc>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
47f00: 2239 0005 ec2a movel 5ec2a <_Thread_Maximum_extensions>,%d1 47f06: 4280 clrl %d0 47f08: 600a bras 47f14 <_Thread_Initialize+0xd8>
the_thread->extensions[i] = NULL;
47f0a: 206a 0106 moveal %a2@(262),%a0 47f0e: 42b0 0c00 clrl %a0@(00000000,%d0:l:4)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
47f12: 5280 addql #1,%d0 47f14: b280 cmpl %d0,%d1
47f16: 64f2 bccs 47f0a <_Thread_Initialize+0xce>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
47f18: 2544 00a0 movel %d4,%a2@(160)
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
47f1c: 7002 moveq #2,%d0
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
47f1e: 1546 009e moveb %d6,%a2@(158)
the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout;
47f22: 256e 0028 00a4 movel %fp@(40),%a2@(164)
switch ( budget_algorithm ) {
47f28: b084 cmpl %d4,%d0
47f2a: 660a bnes 47f36 <_Thread_Initialize+0xfa>
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
47f2c: 41f9 0005 eb50 lea 5eb50 <_Thread_Ticks_per_timeslice>,%a0 47f32: 2550 0076 movel %a0@,%a2@(118)
#endif
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
47f36: 7001 moveq #1,%d0
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
47f38: 256e 002c 00a8 movel %fp@(44),%a2@(168)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
47f3e: 2079 0005 d2b6 moveal 5d2b6 <_Scheduler+0x18>,%a0
the_thread->current_state = STATES_DORMANT;
47f44: 2540 0010 movel %d0,%a2@(16)
the_thread->Wait.queue = NULL;
47f48: 42aa 0044 clrl %a2@(68)
the_thread->resource_count = 0;
47f4c: 42aa 001c clrl %a2@(28)
the_thread->real_priority = priority;
47f50: 2545 0018 movel %d5,%a2@(24)
the_thread->Start.initial_priority = priority;
47f54: 2545 00ac movel %d5,%a2@(172) 47f58: 2f0a movel %a2,%sp@- 47f5a: 4e90 jsr %a0@
sched =_Scheduler_Allocate( the_thread ); if ( !sched )
47f5c: 588f addql #4,%sp 47f5e: 2800 movel %d0,%d4
47f60: 6740 beqs 47fa2 <_Thread_Initialize+0x166> <== NEVER TAKEN
goto failed;
_Thread_Set_priority( the_thread, priority );
47f62: 2f05 movel %d5,%sp@- 47f64: 2f0a movel %a2,%sp@- 47f66: 4eb9 0004 84ec jsr 484ec <_Thread_Set_priority>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
47f6c: 206e 0008 moveal %fp@(8),%a0 47f70: 4280 clrl %d0 47f72: 2068 0018 moveal %a0@(24),%a0 47f76: 302a 000a movew %a2@(10),%d0
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
47f7a: 42aa 0082 clrl %a2@(130) 47f7e: 42aa 0086 clrl %a2@(134) 47f82: 218a 0c00 movel %a2,%a0@(00000000,%d0:l:4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
47f86: 256e 0030 000c movel %fp@(48),%a2@(12)
* enabled when we get here. We want to be able to run the * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread );
47f8c: 2f0a movel %a2,%sp@- 47f8e: 4eb9 0004 8894 jsr 48894 <_User_extensions_Thread_create>
if ( extension_status )
47f94: 4fef 000c lea %sp@(12),%sp 47f98: 4a00 tstb %d0
47f9a: 6706 beqs 47fa2 <_Thread_Initialize+0x166>
47f9c: 6038 bras 47fd6 <_Thread_Initialize+0x19a>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
47f9e: 4282 clrl %d2
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
47fa0: 4284 clrl %d4
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
47fa2: 2f2a 00fa movel %a2@(250),%sp@- 47fa6: 47f9 0004 8c2c lea 48c2c <_Workspace_Free>,%a3 47fac: 4e93 jsr %a3@
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
47fae: 2f2a 00fe movel %a2@(254),%sp@- 47fb2: 4e93 jsr %a3@ 47fb4: 2f2a 0102 movel %a2@(258),%sp@- 47fb8: 4e93 jsr %a3@
_Workspace_Free( extensions_area );
47fba: 2f02 movel %d2,%sp@- 47fbc: 4e93 jsr %a3@
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
47fbe: 2f03 movel %d3,%sp@- 47fc0: 4e93 jsr %a3@
#endif
_Workspace_Free( sched );
47fc2: 2f04 movel %d4,%sp@- 47fc4: 4e93 jsr %a3@
_Thread_Stack_Free( the_thread );
47fc6: 2f0a movel %a2,%sp@- 47fc8: 4eb9 0004 85d0 jsr 485d0 <_Thread_Stack_Free>
return false;
47fce: 4fef 001c lea %sp@(28),%sp
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
47fd2: 4200 clrb %d0 47fd4: 6002 bras 47fd8 <_Thread_Initialize+0x19c>
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
47fd6: 7001 moveq #1,%d0
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
47fd8: 4cee 0c7c ffe4 moveml %fp@(-28),%d2-%d6/%a2-%a3 47fde: 4e5e unlk %fp
...
00048ae8 <_Thread_Restart>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
48ae8: 7001 moveq #1,%d0
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
48aea: 4e56 0000 linkw %fp,#0 48aee: 2f0a movel %a2,%sp@- 48af0: 246e 0008 moveal %fp@(8),%a2 48af4: c0aa 0010 andl %a2@(16),%d0
if ( !_States_Is_dormant( the_thread->current_state ) ) {
48af8: 6664 bnes 48b5e <_Thread_Restart+0x76>
_Thread_Set_transient( the_thread );
48afa: 2f0a movel %a2,%sp@- 48afc: 4eb9 0004 8bc8 jsr 48bc8 <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
48b02: 2f2e 0010 movel %fp@(16),%sp@- 48b06: 2f2e 000c movel %fp@(12),%sp@- 48b0a: 2f0a movel %a2,%sp@- 48b0c: 4eb9 0004 bc2c jsr 4bc2c <_Thread_Reset>
_Thread_Load_environment( the_thread );
48b12: 2f0a movel %a2,%sp@- 48b14: 4eb9 0004 b970 jsr 4b970 <_Thread_Load_environment>
_Thread_Ready( the_thread );
48b1a: 2f0a movel %a2,%sp@- 48b1c: 4eb9 0004 bbfc jsr 4bbfc <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
48b22: 2f0a movel %a2,%sp@- 48b24: 4eb9 0004 8f9c jsr 48f9c <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
48b2a: 4fef 001c lea %sp@(28),%sp 48b2e: b5f9 0005 f902 cmpal 5f902 <_Per_CPU_Information+0xc>,%a2
48b34: 662c bnes 48b62 <_Thread_Restart+0x7a>
*/
RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )
{
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( _Thread_Executing->fp_context != NULL )
48b36: 4aaa 00f6 tstl %a2@(246)
48b3a: 670c beqs 48b48 <_Thread_Restart+0x60>
_Context_Restore_fp( &_Thread_Executing->fp_context );
48b3c: 486a 00f6 pea %a2@(246) 48b40: 4eb9 0004 94a4 jsr 494a4 <_CPU_Context_restore_fp> 48b46: 588f addql #4,%sp
#endif
_CPU_Context_Restart_self( &_Thread_Executing->Registers );
48b48: 2079 0005 f902 moveal 5f902 <_Per_CPU_Information+0xc>,%a0 48b4e: 41e8 00c2 lea %a0@(194),%a0 48b52: 2f08 movel %a0,%sp@- 48b54: 4eb9 0004 9352 jsr 49352 <_CPU_Context_Restart_self>
48b5a: 588f addql #4,%sp <== NOT EXECUTED 48b5c: 6004 bras 48b62 <_Thread_Restart+0x7a> <== NOT EXECUTED
_Thread_Restart_self();
return true;
}
return false;
48b5e: 4200 clrb %d0 48b60: 6002 bras 48b64 <_Thread_Restart+0x7c>
_User_extensions_Thread_restart( the_thread );
if ( _Thread_Is_executing ( the_thread ) )
_Thread_Restart_self();
return true;
48b62: 7001 moveq #1,%d0
}
return false;
}
48b64: 246e fffc moveal %fp@(-4),%a2
48b68: 4e5e unlk %fp <== NOT EXECUTED
000485d0 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
485d0: 4e56 0000 linkw %fp,#0 485d4: 206e 0008 moveal %fp@(8),%a0
#if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
485d8: 4a28 00b0 tstb %a0@(176)
485dc: 671c beqs 485fa <_Thread_Stack_Free+0x2a> <== NEVER TAKEN
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
485de: 2279 0005 d1e0 moveal 5d1e0 <Configuration+0x24>,%a1
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
485e4: 2d68 00b6 0008 movel %a0@(182),%fp@(8)
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
485ea: 4a89 tstl %a1
485ec: 6704 beqs 485f2 <_Thread_Stack_Free+0x22>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
485ee: 4e5e unlk %fp
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
485f0: 4ed1 jmp %a1@
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
485f2: 4e5e unlk %fp
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
485f4: 4ef9 0004 8c2c jmp 48c2c <_Workspace_Free>
}
485fa: 4e5e unlk %fp <== NOT EXECUTED
...
000478e0 <_Thread_blocking_operation_Cancel>:
/*
* 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 ) ) {
478e0: 7202 moveq #2,%d1
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
478e2: 4e56 0000 linkw %fp,#0 478e6: 202e 0010 movel %fp@(16),%d0 478ea: 2f0a movel %a2,%sp@- 478ec: 246e 000c moveal %fp@(12),%a2
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
478f0: 42aa 0044 clrl %a2@(68)
/*
* 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 ) ) {
478f4: b2aa 0050 cmpl %a2@(80),%d1
478f8: 6618 bnes 47912 <_Thread_blocking_operation_Cancel+0x32>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
478fa: 123c 0003 moveb #3,%d1 478fe: 2541 0050 movel %d1,%a2@(80)
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
47902: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
47904: 486a 0048 pea %a2@(72) 47908: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove> 4790e: 588f addql #4,%sp 47910: 6002 bras 47914 <_Thread_blocking_operation_Cancel+0x34>
} else
_ISR_Enable( level );
47912: 46c0 movew %d0,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
47914: 2d4a 0008 movel %a2,%fp@(8)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
47918: 246e fffc moveal %fp@(-4),%a2 4791c: 203c 1003 fff8 movel #268697592,%d0 47922: 2d40 000c movel %d0,%fp@(12) 47926: 4e5e unlk %fp 47928: 4ef9 0004 7a0c jmp 47a0c <_Thread_Clear_state>
...
0004cc2c <_Thread_queue_Extract_fifo>:
Thread_Control *the_thread
)
{
ISR_Level level;
_ISR_Disable( level );
4cc2c: 223c 0000 0700 movel #1792,%d1
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
4cc32: 4e56 0000 linkw %fp,#0 4cc36: 2f0a movel %a2,%sp@- 4cc38: 246e 000c moveal %fp@(12),%a2
ISR_Level level;
_ISR_Disable( level );
4cc3c: 40c0 movew %sr,%d0 4cc3e: 8280 orl %d0,%d1 4cc40: 46c1 movew %d1,%sr 4cc42: 222a 0010 movel %a2@(16),%d1 4cc46: 0281 0003 bee0 andil #245472,%d1
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4cc4c: 660a bnes 4cc58 <_Thread_queue_Extract_fifo+0x2c>
_ISR_Enable( level );
4cc4e: 46c0 movew %d0,%sr
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
4cc50: 246e fffc moveal %fp@(-4),%a2 4cc54: 4e5e unlk %fp 4cc56: 4e75 rts
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4cc58: 2252 moveal %a2@,%a1
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4cc5a: 7202 moveq #2,%d1
previous = the_node->previous;
4cc5c: 206a 0004 moveal %a2@(4),%a0
next->previous = previous;
4cc60: 2348 0004 movel %a0,%a1@(4)
previous->next = next;
4cc64: 2089 movel %a1,%a0@
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
4cc66: 42aa 0044 clrl %a2@(68)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4cc6a: b2aa 0050 cmpl %a2@(80),%d1
4cc6e: 6704 beqs 4cc74 <_Thread_queue_Extract_fifo+0x48>
_ISR_Enable( level );
4cc70: 46c0 movew %d0,%sr 4cc72: 6014 bras 4cc88 <_Thread_queue_Extract_fifo+0x5c> 4cc74: 7203 moveq #3,%d1 4cc76: 2541 0050 movel %d1,%a2@(80)
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4cc7a: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
4cc7c: 486a 0048 pea %a2@(72) 4cc80: 4eb9 0004 8ab8 jsr 48ab8 <_Watchdog_Remove> 4cc86: 588f addql #4,%sp
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4cc88: 2d4a 0008 movel %a2,%fp@(8)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
4cc8c: 246e fffc moveal %fp@(-4),%a2 4cc90: 203c 1003 fff8 movel #268697592,%d0 4cc96: 2d40 000c movel %d0,%fp@(12) 4cc9a: 4e5e unlk %fp 4cc9c: 4ef9 0004 7a0c jmp 47a0c <_Thread_Clear_state>
...
0004844c <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
4844c: 4e56 fff0 linkw %fp,#-16 48450: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 48454: 246e 0008 moveal %fp@(8),%a2 48458: 266e 000c moveal %fp@(12),%a3
/* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue )
4845c: 4a8a tstl %a2
4845e: 6746 beqs 484a6 <_Thread_queue_Requeue+0x5a> <== NEVER TAKEN
/*
* 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 ) {
48460: 7001 moveq #1,%d0 48462: b0aa 0034 cmpl %a2@(52),%d0
48466: 663e bnes 484a6 <_Thread_queue_Requeue+0x5a> <== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
48468: 303c 0700 movew #1792,%d0 4846c: 40c2 movew %sr,%d2 4846e: 8082 orl %d2,%d0 48470: 46c0 movew %d0,%sr 48472: 202b 0010 movel %a3@(16),%d0 48476: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4847c: 6726 beqs 484a4 <_Thread_queue_Requeue+0x58> <== NEVER TAKEN
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;
4847e: 7001 moveq #1,%d0 48480: 2540 0030 movel %d0,%a2@(48)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
48484: 4878 0001 pea 1 <ADD> 48488: 2f0b movel %a3,%sp@- 4848a: 2f0a movel %a2,%sp@- 4848c: 4eb9 0004 b434 jsr 4b434 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
48492: 486e fffc pea %fp@(-4) 48496: 2f0b movel %a3,%sp@- 48498: 2f0a movel %a2,%sp@- 4849a: 4eb9 0004 8250 jsr 48250 <_Thread_queue_Enqueue_priority> 484a0: 4fef 0018 lea %sp@(24),%sp
}
_ISR_Enable( level );
484a4: 46c2 movew %d2,%sr
} }
484a6: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
484ac: 4e5e unlk %fp <== NOT EXECUTED
000484b0 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
484b0: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
484b4: 486e fffc pea %fp@(-4) 484b8: 2f2e 0008 movel %fp@(8),%sp@- 484bc: 4eb9 0004 7da8 jsr 47da8 <_Thread_Get>
switch ( location ) {
484c2: 508f addql #8,%sp 484c4: 4aae fffc tstl %fp@(-4)
484c8: 661e bnes 484e8 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
484ca: 2f00 movel %d0,%sp@- 484cc: 4eb9 0004 b4f8 jsr 4b4f8 <_Thread_queue_Process_timeout>
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
return _Thread_Dispatch_disable_level;
484d2: 588f addql #4,%sp
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
484d4: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0 484da: 5380 subql #1,%d0 484dc: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
484e2: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
_Thread_Unnest_dispatch();
break;
}
}
484e8: 4e5e unlk %fp <== NOT EXECUTED
000519e0 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
519e0: 4e56 ffc0 linkw %fp,#-64
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
519e4: 200e movel %fp,%d0 519e6: 41ee ffec lea %fp@(-20),%a0 519ea: 5180 subql #8,%d0 519ec: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 519f0: 246e 0008 moveal %fp@(8),%a2 519f4: 2e0e movel %fp,%d7 519f6: 260e movel %fp,%d3 519f8: 0687 ffff ffe8 addil #-24,%d7 519fe: 0683 ffff fff4 addil #-12,%d3
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a04: 2a0a movel %a2,%d5
/*
* 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 );
51a06: 240a movel %a2,%d2
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a08: 0685 0000 0030 addil #48,%d5
/*
* 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 );
51a0e: 0682 0000 0068 addil #104,%d2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
51a14: 2c08 movel %a0,%d6 51a16: 2800 movel %d0,%d4
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
51a18: 2d48 ffe8 movel %a0,%fp@(-24)
head->previous = NULL;
51a1c: 42ae ffec clrl %fp@(-20)
tail->previous = head;
51a20: 2d47 fff0 movel %d7,%fp@(-16)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
51a24: 2d40 fff4 movel %d0,%fp@(-12)
head->previous = NULL;
51a28: 42ae fff8 clrl %fp@(-8)
tail->previous = head;
51a2c: 2d43 fffc movel %d3,%fp@(-4)
{
/*
* 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;
51a30: 2547 0078 movel %d7,%a2@(120)
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a34: 47f9 0005 586c lea 5586c <_Watchdog_Adjust_to_chain>,%a3
/*
* 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 );
51a3a: 4bf9 0005 57ec lea 557ec <_Watchdog_Adjust>,%a5
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
51a40: 2039 0007 6c3e movel 76c3e <_Watchdog_Ticks_since_boot>,%d0
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
51a46: 222a 003c movel %a2@(60),%d1
watchdogs->last_snapshot = snapshot;
51a4a: 2540 003c movel %d0,%a2@(60)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51a4e: 9081 subl %d1,%d0 51a50: 2f03 movel %d3,%sp@- 51a52: 2f00 movel %d0,%sp@- 51a54: 2f05 movel %d5,%sp@- 51a56: 4e93 jsr %a3@
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
51a58: 2879 0007 6bc6 moveal 76bc6 <_TOD_Now>,%a4
/*
* 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 ) {
51a5e: 4fef 000c lea %sp@(12),%sp
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
51a62: 202a 0074 movel %a2@(116),%d0
/*
* 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 ) {
51a66: b08c cmpl %a4,%d0
51a68: 640e bccs 51a78 <_Timer_server_Body+0x98>
/*
* 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 );
51a6a: 2f03 movel %d3,%sp@- 51a6c: 220c movel %a4,%d1 51a6e: 9280 subl %d0,%d1 51a70: 2f01 movel %d1,%sp@- 51a72: 2f02 movel %d2,%sp@- 51a74: 4e93 jsr %a3@ 51a76: 6010 bras 51a88 <_Timer_server_Body+0xa8>
} else if ( snapshot < last_snapshot ) {
51a78: b08c cmpl %a4,%d0
51a7a: 6310 blss 51a8c <_Timer_server_Body+0xac>
/*
* 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 );
51a7c: 908c subl %a4,%d0 51a7e: 2f00 movel %d0,%sp@- 51a80: 4878 0001 pea 1 <ADD> 51a84: 2f02 movel %d2,%sp@- 51a86: 4e95 jsr %a5@ 51a88: 4fef 000c lea %sp@(12),%sp
}
watchdogs->last_snapshot = snapshot;
51a8c: 254c 0074 movel %a4,%a2@(116)
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
51a90: 49f9 0005 58f8 lea 558f8 <_Watchdog_Insert>,%a4
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
51a96: 202a 0078 movel %a2@(120),%d0 51a9a: 2f00 movel %d0,%sp@- 51a9c: 4eb9 0005 24c0 jsr 524c0 <_Chain_Get>
if ( timer == NULL ) {
51aa2: 588f addql #4,%sp
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
51aa4: 2040 moveal %d0,%a0
if ( timer == NULL ) {
51aa6: 4a80 tstl %d0
51aa8: 6724 beqs 51ace <_Timer_server_Body+0xee> <== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51aaa: 2028 0038 movel %a0@(56),%d0 <== NOT EXECUTED 51aae: 7201 moveq #1,%d1 <== NOT EXECUTED 51ab0: b280 cmpl %d0,%d1 <== NOT EXECUTED 51ab2: 6608 bnes 51abc <_Timer_server_Body+0xdc> <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
51ab4: 4868 0010 pea %a0@(16) <== NOT EXECUTED 51ab8: 2f05 movel %d5,%sp@- <== NOT EXECUTED 51aba: 600c bras 51ac8 <_Timer_server_Body+0xe8> <== NOT EXECUTED
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
51abc: 7203 moveq #3,%d1 <== NOT EXECUTED 51abe: b280 cmpl %d0,%d1 <== NOT EXECUTED 51ac0: 66d4 bnes 51a96 <_Timer_server_Body+0xb6> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
51ac2: 4868 0010 pea %a0@(16) <== NOT EXECUTED 51ac6: 2f02 movel %d2,%sp@- <== NOT EXECUTED 51ac8: 4e94 jsr %a4@ <== NOT EXECUTED 51aca: 508f addql #8,%sp <== NOT EXECUTED 51acc: 60c8 bras 51a96 <_Timer_server_Body+0xb6> <== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
51ace: 203c 0000 0700 movel #1792,%d0 51ad4: 40c1 movew %sr,%d1 51ad6: 8081 orl %d1,%d0 51ad8: 46c0 movew %d0,%sr
if ( _Chain_Is_empty( insert_chain ) ) {
51ada: bcae ffe8 cmpl %fp@(-24),%d6
51ade: 6612 bnes 51af2 <_Timer_server_Body+0x112> <== NEVER TAKEN
ts->insert_chain = NULL;
51ae0: 42aa 0078 clrl %a2@(120)
_ISR_Enable( level );
51ae4: 46c1 movew %d1,%sr
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
51ae6: 367c 0700 moveaw #1792,%a3
_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 ) ) {
51aea: b8ae fff4 cmpl %fp@(-12),%d4
51aee: 6608 bnes 51af8 <_Timer_server_Body+0x118>
51af0: 603e bras 51b30 <_Timer_server_Body+0x150>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
51af2: 46c1 movew %d1,%sr <== NOT EXECUTED 51af4: 6000 ff4a braw 51a40 <_Timer_server_Body+0x60> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
51af8: 200b movel %a3,%d0 51afa: 40c1 movew %sr,%d1 51afc: 8081 orl %d1,%d0 51afe: 46c0 movew %d0,%sr
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
51b00: 206e fff4 moveal %fp@(-12),%a0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
51b04: b888 cmpl %a0,%d4
51b06: 6722 beqs 51b2a <_Timer_server_Body+0x14a>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
51b08: 2250 moveal %a0@,%a1
head->next = new_first;
new_first->previous = head;
51b0a: 2343 0004 movel %d3,%a1@(4)
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
51b0e: 42a8 0008 clrl %a0@(8)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
51b12: 2d49 fff4 movel %a1,%fp@(-12)
_ISR_Enable( level );
51b16: 46c1 movew %d1,%sr
/*
* 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 );
51b18: 2f28 0024 movel %a0@(36),%sp@- 51b1c: 2f28 0020 movel %a0@(32),%sp@- 51b20: 2068 001c moveal %a0@(28),%a0 51b24: 4e90 jsr %a0@
}
51b26: 508f addql #8,%sp 51b28: 60ce bras 51af8 <_Timer_server_Body+0x118>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
51b2a: 46c1 movew %d1,%sr 51b2c: 6000 ff02 braw 51a30 <_Timer_server_Body+0x50>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
51b30: 47f9 0005 5a1c lea 55a1c <_Watchdog_Remove>,%a3
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
51b36: 4200 clrb %d0 51b38: 1540 007c moveb %d0,%a2@(124)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
51b3c: 4eba fdc2 jsr %pc@(51900 <_Thread_Disable_dispatch>)
_Thread_Set_state( ts->thread, STATES_DELAYING );
51b40: 4878 0008 pea 8 <DIVIDE_BY_ZERO> 51b44: 2f12 movel %a2@,%sp@- 51b46: 4eb9 0005 52bc jsr 552bc <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
51b4c: 2f0a movel %a2,%sp@- 51b4e: 4eba fdcc jsr %pc@(5191c <_Timer_server_Reset_interval_system_watchdog>)
_Timer_server_Reset_tod_system_watchdog( ts );
51b52: 2f0a movel %a2,%sp@- 51b54: 4eba fe26 jsr %pc@(5197c <_Timer_server_Reset_tod_system_watchdog>)
_Thread_Enable_dispatch();
51b58: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
ts->active = true;
51b5e: 7201 moveq #1,%d1 51b60: 1541 007c moveb %d1,%a2@(124)
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
51b64: 486a 0008 pea %a2@(8) 51b68: 4e93 jsr %a3@
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
51b6a: 486a 0040 pea %a2@(64) 51b6e: 4e93 jsr %a3@ 51b70: 4fef 0018 lea %sp@(24),%sp 51b74: 6000 feba braw 51a30 <_Timer_server_Body+0x50>
00051b78 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
51b78: 4e56 fff0 linkw %fp,#-16 51b7c: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 51b80: 246e 0008 moveal %fp@(8),%a2 51b84: 266e 000c moveal %fp@(12),%a3
if ( ts->insert_chain == NULL ) {
51b88: 202a 0078 movel %a2@(120),%d0 51b8c: 6600 00ea bnew 51c78 <_Timer_server_Schedule_operation_method+0x100>
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
51b90: 4eba fd6e jsr %pc@(51900 <_Thread_Disable_dispatch>)
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51b94: 202b 0038 movel %a3@(56),%d0 51b98: 7201 moveq #1,%d1 51b9a: b280 cmpl %d0,%d1
51b9c: 665c bnes 51bfa <_Timer_server_Schedule_operation_method+0x82>
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
51b9e: 203c 0000 0700 movel #1792,%d0 51ba4: 40c2 movew %sr,%d2 51ba6: 8082 orl %d2,%d0 51ba8: 46c0 movew %d0,%sr
snapshot = _Watchdog_Ticks_since_boot;
51baa: 2039 0007 6c3e movel 76c3e <_Watchdog_Ticks_since_boot>,%d0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
51bb0: 43ea 0034 lea %a2@(52),%a1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
51bb4: 222a 003c movel %a2@(60),%d1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
51bb8: 206a 0030 moveal %a2@(48),%a0
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
51bbc: b3c8 cmpal %a0,%a1
51bbe: 6716 beqs 51bd6 <_Timer_server_Schedule_operation_method+0x5e>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
51bc0: 2240 moveal %d0,%a1 51bc2: 93c1 subal %d1,%a1
delta_interval = first_watchdog->delta_interval;
51bc4: 2228 0010 movel %a0@(16),%d1
if (delta_interval > delta) {
51bc8: b3c1 cmpal %d1,%a1
51bca: 6404 bccs 51bd0 <_Timer_server_Schedule_operation_method+0x58>
delta_interval -= delta;
51bcc: 9289 subl %a1,%d1 51bce: 6002 bras 51bd2 <_Timer_server_Schedule_operation_method+0x5a>
} else {
delta_interval = 0;
51bd0: 4281 clrl %d1
}
first_watchdog->delta_interval = delta_interval;
51bd2: 2141 0010 movel %d1,%a0@(16)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
51bd6: 2540 003c movel %d0,%a2@(60)
_ISR_Enable( level );
51bda: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
51bdc: 486b 0010 pea %a3@(16) 51be0: 486a 0030 pea %a2@(48) 51be4: 4eb9 0005 58f8 jsr 558f8 <_Watchdog_Insert>
if ( !ts->active ) {
51bea: 508f addql #8,%sp 51bec: 102a 007c moveb %a2@(124),%d0
51bf0: 6678 bnes 51c6a <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_interval_system_watchdog( ts );
51bf2: 2f0a movel %a2,%sp@- 51bf4: 4eba fd26 jsr %pc@(5191c <_Timer_server_Reset_interval_system_watchdog>) 51bf8: 606e bras 51c68 <_Timer_server_Schedule_operation_method+0xf0>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
51bfa: 7203 moveq #3,%d1 51bfc: b280 cmpl %d0,%d1
51bfe: 666a bnes 51c6a <_Timer_server_Schedule_operation_method+0xf2>
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
51c00: 203c 0000 0700 movel #1792,%d0 51c06: 40c2 movew %sr,%d2 51c08: 8082 orl %d2,%d0 51c0a: 46c0 movew %d0,%sr
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
51c0c: 200a movel %a2,%d0 51c0e: 0680 0000 006c addil #108,%d0
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
51c14: 2239 0007 6bc6 movel 76bc6 <_TOD_Now>,%d1
last_snapshot = ts->TOD_watchdogs.last_snapshot;
51c1a: 226a 0074 moveal %a2@(116),%a1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
51c1e: 206a 0068 moveal %a2@(104),%a0
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
51c22: b088 cmpl %a0,%d0
51c24: 6720 beqs 51c46 <_Timer_server_Schedule_operation_method+0xce>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
51c26: 2028 0010 movel %a0@(16),%d0
if ( snapshot > last_snapshot ) {
51c2a: b3c1 cmpal %d1,%a1
51c2c: 640c bccs 51c3a <_Timer_server_Schedule_operation_method+0xc2>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
51c2e: 2841 moveal %d1,%a4 51c30: 99c9 subal %a1,%a4
if (delta_interval > delta) {
51c32: b9c0 cmpal %d0,%a4
51c34: 640a bccs 51c40 <_Timer_server_Schedule_operation_method+0xc8><== NEVER TAKEN
delta_interval -= delta;
51c36: 908c subl %a4,%d0 51c38: 6008 bras 51c42 <_Timer_server_Schedule_operation_method+0xca>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
51c3a: d089 addl %a1,%d0
delta_interval += delta;
51c3c: 9081 subl %d1,%d0 51c3e: 6002 bras 51c42 <_Timer_server_Schedule_operation_method+0xca>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
51c40: 4280 clrl %d0 <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
51c42: 2140 0010 movel %d0,%a0@(16)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
51c46: 2541 0074 movel %d1,%a2@(116)
_ISR_Enable( level );
51c4a: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
51c4c: 486b 0010 pea %a3@(16) 51c50: 486a 0068 pea %a2@(104) 51c54: 4eb9 0005 58f8 jsr 558f8 <_Watchdog_Insert>
if ( !ts->active ) {
51c5a: 508f addql #8,%sp 51c5c: 102a 007c moveb %a2@(124),%d0
51c60: 6608 bnes 51c6a <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_tod_system_watchdog( ts );
51c62: 2f0a movel %a2,%sp@- 51c64: 4eba fd16 jsr %pc@(5197c <_Timer_server_Reset_tod_system_watchdog>) 51c68: 588f addql #4,%sp
* 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 );
}
}
51c6a: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 51c70: 4e5e unlk %fp
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
51c72: 4ef9 0005 4ab4 jmp 54ab4 <_Thread_Enable_dispatch>
* 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 );
51c78: 202a 0078 movel %a2@(120),%d0 <== NOT EXECUTED 51c7c: 2d4b 000c movel %a3,%fp@(12) <== NOT EXECUTED
} }
51c80: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 <== 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 );
51c86: 2d40 0008 movel %d0,%fp@(8) <== NOT EXECUTED
} }
51c8a: 4e5e unlk %fp <== 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 );
51c8c: 4ef9 0005 2460 jmp 52460 <_Chain_Append> <== NOT EXECUTED
00048724 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
48724: 4e56 ffe8 linkw %fp,#-24
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
48728: 203c 0005 ece4 movel #388324,%d0 4872e: 23c0 0005 ece0 movel %d0,5ece0 <_User_extensions_List>
head->previous = NULL; tail->previous = head;
48734: 203c 0005 ece0 movel #388320,%d0 4873a: 23c0 0005 ece8 movel %d0,5ece8 <_User_extensions_List+0x8>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
48740: 203c 0005 eba0 movel #388000,%d0 48746: 23c0 0005 eb9c movel %d0,5eb9c <_User_extensions_Switches_list>
head->previous = NULL; tail->previous = head;
4874c: 203c 0005 eb9c movel #387996,%d0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
48752: 42b9 0005 ece4 clrl 5ece4 <_User_extensions_List+0x4> 48758: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
User_extensions_Control *extension;
uint32_t i;
uint32_t number_of_extensions;
User_extensions_Table *initial_extensions;
number_of_extensions = Configuration.number_of_initial_extensions;
4875c: 2839 0005 d1f2 movel 5d1f2 <Configuration+0x36>,%d4
initial_extensions = Configuration.User_extension_table;
48762: 2639 0005 d1f6 movel 5d1f6 <Configuration+0x3a>,%d3 48768: 42b9 0005 eba0 clrl 5eba0 <_User_extensions_Switches_list+0x4>
tail->previous = head;
4876e: 23c0 0005 eba4 movel %d0,5eba4 <_User_extensions_Switches_list+0x8>
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
48774: 4a83 tstl %d3
48776: 6754 beqs 487cc <_User_extensions_Handler_initialization+0xa8><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
48778: 7434 moveq #52,%d2 4877a: 4c04 2800 mulsl %d4,%d2
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
4877e: 49f9 0004 d588 lea 4d588 <memcpy>,%a4
_User_extensions_Add_set( extension );
48784: 47f9 0004 b5c0 lea 4b5c0 <_User_extensions_Add_set>,%a3
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
4878a: 2f02 movel %d2,%sp@- 4878c: 4eb9 0004 8c46 jsr 48c46 <_Workspace_Allocate_or_fatal_error> 48792: 2440 moveal %d0,%a2
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
48794: 2f02 movel %d2,%sp@-
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
48796: 4282 clrl %d2
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
48798: 42a7 clrl %sp@- 4879a: 2f00 movel %d0,%sp@- 4879c: 4eb9 0004 d5f8 jsr 4d5f8 <memset>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
487a2: 4fef 0010 lea %sp@(16),%sp 487a6: 6020 bras 487c8 <_User_extensions_Handler_initialization+0xa4>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
487a8: 4878 0020 pea 20 <OPER2+0xc> 487ac: 5282 addql #1,%d2 487ae: 2f03 movel %d3,%sp@- 487b0: 486a 0014 pea %a2@(20) 487b4: 0683 0000 0020 addil #32,%d3 487ba: 4e94 jsr %a4@
_User_extensions_Add_set( extension );
487bc: 2f0a movel %a2,%sp@-
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
487be: 45ea 0034 lea %a2@(52),%a2 487c2: 4e93 jsr %a3@
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
487c4: 4fef 0010 lea %sp@(16),%sp 487c8: b882 cmpl %d2,%d4
487ca: 66dc bnes 487a8 <_User_extensions_Handler_initialization+0x84>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
487cc: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4 487d2: 4e5e unlk %fp
...
00049c60 <_Watchdog_Adjust>:
Watchdog_Interval units
)
{
ISR_Level level;
_ISR_Disable( level );
49c60: 327c 0700 moveaw #1792,%a1 49c64: 2209 movel %a1,%d1
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
49c66: 4e56 ffec linkw %fp,#-20 49c6a: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ 49c6e: 266e 0008 moveal %fp@(8),%a3 49c72: 262e 000c movel %fp@(12),%d3 49c76: 242e 0010 movel %fp@(16),%d2
ISR_Level level;
_ISR_Disable( level );
49c7a: 40c0 movew %sr,%d0 49c7c: 8280 orl %d0,%d1 49c7e: 46c1 movew %d1,%sr
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
49c80: 244b moveal %a3,%a2 49c82: 205a moveal %a2@+,%a0
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
49c84: b5c8 cmpal %a0,%a2
49c86: 674c beqs 49cd4 <_Watchdog_Adjust+0x74>
switch ( direction ) {
49c88: 4a83 tstl %d3
49c8a: 673c beqs 49cc8 <_Watchdog_Adjust+0x68>
49c8c: 7201 moveq #1,%d1 49c8e: b283 cmpl %d3,%d1
49c90: 6642 bnes 49cd4 <_Watchdog_Adjust+0x74> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
49c92: d5a8 0010 addl %d2,%a0@(16)
break;
49c96: 603c bras 49cd4 <_Watchdog_Adjust+0x74>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
49c98: 2053 moveal %a3@,%a0
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
49c9a: 2228 0010 movel %a0@(16),%d1 49c9e: b282 cmpl %d2,%d1
49ca0: 6308 blss 49caa <_Watchdog_Adjust+0x4a>
_Watchdog_First( header )->delta_interval -= units;
49ca2: 9282 subl %d2,%d1 49ca4: 2141 0010 movel %d1,%a0@(16)
break;
49ca8: 602a bras 49cd4 <_Watchdog_Adjust+0x74>
} else {
units -= _Watchdog_First( header )->delta_interval;
49caa: 9481 subl %d1,%d2
_Watchdog_First( header )->delta_interval = 1;
49cac: 7201 moveq #1,%d1 49cae: 2141 0010 movel %d1,%a0@(16)
_ISR_Enable( level );
49cb2: 46c0 movew %d0,%sr
_Watchdog_Tickle( header );
49cb4: 2f0b movel %a3,%sp@- 49cb6: 4e94 jsr %a4@
_ISR_Disable( level );
49cb8: 2203 movel %d3,%d1 49cba: 40c0 movew %sr,%d0 49cbc: 8280 orl %d0,%d1 49cbe: 46c1 movew %d1,%sr
if ( _Chain_Is_empty( header ) )
49cc0: 588f addql #4,%sp 49cc2: b5d3 cmpal %a3@,%a2
49cc4: 660a bnes 49cd0 <_Watchdog_Adjust+0x70>
49cc6: 600c bras 49cd4 <_Watchdog_Adjust+0x74>
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
_Watchdog_Tickle( header );
49cc8: 49f9 0004 9e80 lea 49e80 <_Watchdog_Tickle>,%a4
_ISR_Disable( level );
49cce: 2609 movel %a1,%d3
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
49cd0: 4a82 tstl %d2
49cd2: 66c4 bnes 49c98 <_Watchdog_Adjust+0x38> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
49cd4: 46c0 movew %d0,%sr
}
49cd6: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4
49cdc: 4e5e unlk %fp <== NOT EXECUTED
00048ab8 <_Watchdog_Remove>:
{
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
48ab8: 203c 0000 0700 movel #1792,%d0
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
48abe: 4e56 0000 linkw %fp,#0 48ac2: 206e 0008 moveal %fp@(8),%a0 48ac6: 2f0a movel %a2,%sp@- 48ac8: 2f02 movel %d2,%sp@-
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
48aca: 40c1 movew %sr,%d1 48acc: 8081 orl %d1,%d0 48ace: 46c0 movew %d0,%sr
previous_state = the_watchdog->state;
48ad0: 2028 0008 movel %a0@(8),%d0
switch ( previous_state ) {
48ad4: 7401 moveq #1,%d2 48ad6: b480 cmpl %d0,%d2
48ad8: 670c beqs 48ae6 <_Watchdog_Remove+0x2e> 48ada: 6242 bhis 48b1e <_Watchdog_Remove+0x66>
48adc: 143c 0003 moveb #3,%d2 48ae0: b480 cmpl %d0,%d2
48ae2: 653a bcss 48b1e <_Watchdog_Remove+0x66> <== NEVER TAKEN
48ae4: 6006 bras 48aec <_Watchdog_Remove+0x34>
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
48ae6: 42a8 0008 clrl %a0@(8)
break;
48aea: 6032 bras 48b1e <_Watchdog_Remove+0x66>
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
48aec: 2250 moveal %a0@,%a1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
48aee: 42a8 0008 clrl %a0@(8)
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
48af2: 4a91 tstl %a1@
48af4: 6708 beqs 48afe <_Watchdog_Remove+0x46>
next_watchdog->delta_interval += the_watchdog->delta_interval;
48af6: 2428 0010 movel %a0@(16),%d2 48afa: d5a9 0010 addl %d2,%a1@(16)
if ( _Watchdog_Sync_count )
48afe: 2479 0005 ec96 moveal 5ec96 <_Watchdog_Sync_count>,%a2 48b04: 4a8a tstl %a2
48b06: 670c beqs 48b14 <_Watchdog_Remove+0x5c>
_Watchdog_Sync_level = _ISR_Nest_level;
48b08: 45f9 0005 eff6 lea 5eff6 <_Per_CPU_Information+0x8>,%a2 48b0e: 23d2 0005 ec3c movel %a2@,5ec3c <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
48b14: 2468 0004 moveal %a0@(4),%a2
next->previous = previous;
48b18: 234a 0004 movel %a2,%a1@(4)
previous->next = next;
48b1c: 2489 movel %a1,%a2@
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
48b1e: 2279 0005 ec9a moveal 5ec9a <_Watchdog_Ticks_since_boot>,%a1 48b24: 2149 0018 movel %a1,%a0@(24)
_ISR_Enable( level );
48b28: 46c1 movew %d1,%sr
return( previous_state ); }
48b2a: 241f movel %sp@+,%d2 48b2c: 245f moveal %sp@+,%a2 48b2e: 4e5e unlk %fp
...
00045f10 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
45f10: 4e56 ffe8 linkw %fp,#-24 45f14: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
45f18: 4879 0006 12c8 pea 612c8 <aio_request_queue> 45f1e: 49f9 0004 6fe0 lea 46fe0 <pthread_mutex_lock>,%a4
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
45f24: 242e 0008 movel %fp@(8),%d2 45f28: 246e 000c moveal %fp@(12),%a2
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
45f2c: 4e94 jsr %a4@
if (fcntl (fildes, F_GETFD) < 0) {
45f2e: 4878 0001 pea 1 <ADD> 45f32: 2f02 movel %d2,%sp@- 45f34: 4eb9 0004 c41c jsr 4c41c <fcntl> 45f3a: 4fef 000c lea %sp@(12),%sp 45f3e: 4a80 tstl %d0
45f40: 6c1c bges 45f5e <aio_cancel+0x4e>
pthread_mutex_unlock(&aio_request_queue.mutex);
45f42: 4879 0006 12c8 pea 612c8 <aio_request_queue> 45f48: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
45f4e: 4eb9 0004 f1bc jsr 4f1bc <__errno> 45f54: 7209 moveq #9,%d1 45f56: 2040 moveal %d0,%a0 45f58: 2081 movel %d1,%a0@ 45f5a: 6000 00f6 braw 46052 <aio_cancel+0x142>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
45f5e: 4a8a tstl %a2 45f60: 6600 00d2 bnew 46034 <aio_cancel+0x124>
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
45f64: 42a7 clrl %sp@- 45f66: 47f9 0004 62ba lea 462ba <rtems_aio_search_fd>,%a3 45f6c: 2f02 movel %d2,%sp@- 45f6e: 4879 0006 1310 pea 61310 <aio_request_queue+0x48> 45f74: 4e93 jsr %a3@
if (r_chain == NULL) {
45f76: 4fef 000c lea %sp@(12),%sp
/* 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);
45f7a: 2440 moveal %d0,%a2
if (r_chain == NULL) {
45f7c: 4a80 tstl %d0
45f7e: 667c bnes 45ffc <aio_cancel+0xec>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
45f80: 203c 0006 1320 movel #398112,%d0 45f86: b0b9 0006 131c cmpl 6131c <aio_request_queue+0x54>,%d0 45f8c: 6700 012c beqw 460ba <aio_cancel+0x1aa>
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
45f90: 42a7 clrl %sp@- 45f92: 2f02 movel %d2,%sp@- 45f94: 4879 0006 131c pea 6131c <aio_request_queue+0x54> 45f9a: 4e93 jsr %a3@
if (r_chain == NULL) {
45f9c: 4fef 000c lea %sp@(12),%sp
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)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
45fa0: 2400 movel %d0,%d2
if (r_chain == NULL) {
45fa2: 6616 bnes 45fba <aio_cancel+0xaa>
pthread_mutex_unlock(&aio_request_queue.mutex);
45fa4: 4879 0006 12c8 pea 612c8 <aio_request_queue>
return AIO_ALLDONE;
45faa: 143c 0002 moveb #2,%d2
AIO_printf ("Request chain not on [WQ]\n");
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);
45fae: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return AIO_ALLDONE;
45fb4: 588f addql #4,%sp 45fb6: 6000 0144 braw 460fc <aio_cancel+0x1ec>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
45fba: 2f00 movel %d0,%sp@-
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);
45fbc: 2602 movel %d2,%d3 45fbe: 0683 0000 001c addil #28,%d3 45fc4: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
45fca: 2f02 movel %d2,%sp@- 45fcc: 4eb9 0004 660c jsr 4660c <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
45fd2: 2f03 movel %d3,%sp@- 45fd4: 4eb9 0004 6da8 jsr 46da8 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
45fda: 2f03 movel %d3,%sp@- 45fdc: 4eb9 0004 6a94 jsr 46a94 <pthread_cond_destroy>
free (r_chain);
45fe2: 2f02 movel %d2,%sp@- 45fe4: 4eb9 0004 33b4 jsr 433b4 <free>
pthread_mutex_unlock (&aio_request_queue.mutex);
45fea: 4879 0006 12c8 pea 612c8 <aio_request_queue> 45ff0: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return AIO_CANCELED;
45ff6: 4fef 0018 lea %sp@(24),%sp 45ffa: 6032 bras 4602e <aio_cancel+0x11e>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
45ffc: 2400 movel %d0,%d2 45ffe: 0682 0000 001c addil #28,%d2 46004: 2f02 movel %d2,%sp@- 46006: 4e94 jsr %a4@ 46008: 2f0a movel %a2,%sp@- 4600a: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
46010: 2f0a movel %a2,%sp@-
pthread_mutex_unlock (&r_chain->mutex);
46012: 45f9 0004 7078 lea 47078 <pthread_mutex_unlock>,%a2
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
46018: 4eb9 0004 660c jsr 4660c <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
4601e: 2f02 movel %d2,%sp@- 46020: 4e92 jsr %a2@
pthread_mutex_unlock (&aio_request_queue.mutex);
46022: 4879 0006 12c8 pea 612c8 <aio_request_queue> 46028: 4e92 jsr %a2@
return AIO_CANCELED;
4602a: 4fef 0014 lea %sp@(20),%sp 4602e: 4282 clrl %d2 46030: 6000 00ca braw 460fc <aio_cancel+0x1ec>
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
46034: 2612 movel %a2@,%d3 46036: b483 cmpl %d3,%d2
46038: 6720 beqs 4605a <aio_cancel+0x14a>
pthread_mutex_unlock (&aio_request_queue.mutex);
4603a: 4879 0006 12c8 pea 612c8 <aio_request_queue> 46040: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
46046: 4eb9 0004 f1bc jsr 4f1bc <__errno> 4604c: 2040 moveal %d0,%a0 4604e: 7016 moveq #22,%d0 46050: 2080 movel %d0,%a0@ 46052: 588f addql #4,%sp 46054: 74ff moveq #-1,%d2 46056: 6000 00a4 braw 460fc <aio_cancel+0x1ec>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
4605a: 42a7 clrl %sp@- 4605c: 4bf9 0004 62ba lea 462ba <rtems_aio_search_fd>,%a5 46062: 2f03 movel %d3,%sp@- 46064: 4879 0006 1310 pea 61310 <aio_request_queue+0x48> 4606a: 4e95 jsr %a5@
if (r_chain == NULL) {
4606c: 4fef 000c lea %sp@(12),%sp
if (aiocbp->aio_fildes != fildes) {
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);
46070: 2640 moveal %d0,%a3
if (r_chain == NULL) {
46072: 4a80 tstl %d0
46074: 6656 bnes 460cc <aio_cancel+0x1bc>
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
46076: 203c 0006 1320 movel #398112,%d0 4607c: b0b9 0006 131c cmpl 6131c <aio_request_queue+0x54>,%d0
46082: 6736 beqs 460ba <aio_cancel+0x1aa> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
46084: 42a7 clrl %sp@- 46086: 2f03 movel %d3,%sp@- 46088: 4879 0006 131c pea 6131c <aio_request_queue+0x54> 4608e: 4e95 jsr %a5@
if (r_chain == NULL) {
46090: 4fef 000c lea %sp@(12),%sp 46094: 4a80 tstl %d0
46096: 67a2 beqs 4603a <aio_cancel+0x12a>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
46098: 2f0a movel %a2,%sp@- 4609a: 2040 moveal %d0,%a0 4609c: 4868 0008 pea %a0@(8) 460a0: 4eb9 0004 6662 jsr 46662 <rtems_aio_remove_req>
pthread_mutex_unlock (&aio_request_queue.mutex);
460a6: 4879 0006 12c8 pea 612c8 <aio_request_queue>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
460ac: 2400 movel %d0,%d2
pthread_mutex_unlock (&aio_request_queue.mutex);
460ae: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return result;
460b4: 4fef 000c lea %sp@(12),%sp 460b8: 6042 bras 460fc <aio_cancel+0x1ec>
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
460ba: 4879 0006 12c8 pea 612c8 <aio_request_queue> <== NOT EXECUTED
return AIO_ALLDONE;
460c0: 7402 moveq #2,%d2 <== 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);
460c2: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
460c8: 588f addql #4,%sp <== NOT EXECUTED 460ca: 6030 bras 460fc <aio_cancel+0x1ec> <== NOT EXECUTED
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
460cc: 2600 movel %d0,%d3 460ce: 0683 0000 001c addil #28,%d3 460d4: 2f03 movel %d3,%sp@- 460d6: 4e94 jsr %a4@
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
460d8: 2f0a movel %a2,%sp@- 460da: 486b 0008 pea %a3@(8)
pthread_mutex_unlock (&r_chain->mutex);
460de: 45f9 0004 7078 lea 47078 <pthread_mutex_unlock>,%a2
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
460e4: 4eb9 0004 6662 jsr 46662 <rtems_aio_remove_req> 460ea: 2400 movel %d0,%d2
pthread_mutex_unlock (&r_chain->mutex);
460ec: 2f03 movel %d3,%sp@- 460ee: 4e92 jsr %a2@
pthread_mutex_unlock (&aio_request_queue.mutex);
460f0: 4879 0006 12c8 pea 612c8 <aio_request_queue> 460f6: 4e92 jsr %a2@
return result;
460f8: 4fef 0014 lea %sp@(20),%sp
} return AIO_ALLDONE; }
460fc: 2002 movel %d2,%d0 460fe: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
46104: 4e5e unlk %fp <== NOT EXECUTED
00046118 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
46118: 203c 0000 2000 movel #8192,%d0
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
4611e: 4e56 0000 linkw %fp,#0 46122: 2f0a movel %a2,%sp@- 46124: 246e 000c moveal %fp@(12),%a2
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
46128: b0ae 0008 cmpl %fp@(8),%d0
4612c: 671a beqs 46148 <aio_fsync+0x30>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
4612e: 7216 moveq #22,%d1 46130: 70ff moveq #-1,%d0 46132: 2541 0030 movel %d1,%a2@(48) 46136: 2540 0034 movel %d0,%a2@(52) 4613a: 4eb9 0004 f1bc jsr 4f1bc <__errno> 46140: 2040 moveal %d0,%a0 46142: 7016 moveq #22,%d0 46144: 2080 movel %d0,%a0@ 46146: 607e bras 461c6 <aio_fsync+0xae>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
46148: 4878 0003 pea 3 <DIVIDE> 4614c: 2f12 movel %a2@,%sp@- 4614e: 4eb9 0004 c41c jsr 4c41c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
46154: 508f addql #8,%sp 46156: 7203 moveq #3,%d1 46158: c081 andl %d1,%d0 4615a: 123c 0001 moveb #1,%d1 4615e: 5380 subql #1,%d0 46160: b280 cmpl %d0,%d1
46162: 641a bccs 4617e <aio_fsync+0x66>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
46164: 72ff moveq #-1,%d1 46166: 7009 moveq #9,%d0 46168: 2541 0034 movel %d1,%a2@(52) 4616c: 2540 0030 movel %d0,%a2@(48) 46170: 4eb9 0004 f1bc jsr 4f1bc <__errno> 46176: 7209 moveq #9,%d1 46178: 2040 moveal %d0,%a0 4617a: 2081 movel %d1,%a0@ 4617c: 6048 bras 461c6 <aio_fsync+0xae>
req = malloc (sizeof (rtems_aio_request));
4617e: 4878 0018 pea 18 <OPER2+0x4> 46182: 4eb9 0004 38dc jsr 438dc <malloc>
if (req == NULL)
46188: 588f addql #4,%sp 4618a: 4a80 tstl %d0
4618c: 661c bnes 461aa <aio_fsync+0x92> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
4618e: 103c 000b moveb #11,%d0 <== NOT EXECUTED 46192: 72ff moveq #-1,%d1 <== NOT EXECUTED 46194: 2540 0030 movel %d0,%a2@(48) <== NOT EXECUTED 46198: 2541 0034 movel %d1,%a2@(52) <== NOT EXECUTED 4619c: 4eb9 0004 f1bc jsr 4f1bc <__errno> <== NOT EXECUTED 461a2: 2040 moveal %d0,%a0 <== NOT EXECUTED 461a4: 700b moveq #11,%d0 <== NOT EXECUTED 461a6: 2080 movel %d0,%a0@ <== NOT EXECUTED 461a8: 601c bras 461c6 <aio_fsync+0xae> <== NOT EXECUTED
req->aiocbp = aiocbp;
461aa: 2040 moveal %d0,%a0
req->aiocbp->aio_lio_opcode = LIO_SYNC;
461ac: 7203 moveq #3,%d1
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
461ae: 214a 0014 movel %a2,%a0@(20)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
461b2: 2541 002c movel %d1,%a2@(44)
return rtems_aio_enqueue (req);
}
461b6: 246e fffc moveal %fp@(-4),%a2
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
461ba: 2d40 0008 movel %d0,%fp@(8)
}
461be: 4e5e unlk %fp
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
461c0: 4ef9 0004 66bc jmp 466bc <rtems_aio_enqueue>
}
461c6: 246e fffc moveal %fp@(-4),%a2 461ca: 70ff moveq #-1,%d0
461cc: 4e5e unlk %fp <== NOT EXECUTED
000468a8 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
468a8: 4e56 0000 linkw %fp,#0 468ac: 2f0a movel %a2,%sp@-
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
468ae: 4878 0003 pea 3 <DIVIDE>
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
468b2: 246e 0008 moveal %fp@(8),%a2
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
468b6: 2f12 movel %a2@,%sp@- 468b8: 4eb9 0004 c41c jsr 4c41c <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
468be: 508f addql #8,%sp 468c0: 7203 moveq #3,%d1 468c2: c081 andl %d1,%d0
468c4: 6722 beqs 468e8 <aio_read+0x40> <== NEVER TAKEN
468c6: 123c 0002 moveb #2,%d1 468ca: b280 cmpl %d0,%d1
468cc: 671a beqs 468e8 <aio_read+0x40>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
468ce: 7009 moveq #9,%d0 468d0: 72ff moveq #-1,%d1 468d2: 2540 0030 movel %d0,%a2@(48) 468d6: 2541 0034 movel %d1,%a2@(52) 468da: 4eb9 0004 f1bc jsr 4f1bc <__errno> 468e0: 2040 moveal %d0,%a0 468e2: 7009 moveq #9,%d0 468e4: 2080 movel %d0,%a0@ 468e6: 606e bras 46956 <aio_read+0xae>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
468e8: 4aaa 0014 tstl %a2@(20)
468ec: 6606 bnes 468f4 <aio_read+0x4c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
468ee: 4aaa 0004 tstl %a2@(4)
468f2: 6a1a bpls 4690e <aio_read+0x66>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
468f4: 72ff moveq #-1,%d1 468f6: 7016 moveq #22,%d0 468f8: 2541 0034 movel %d1,%a2@(52) 468fc: 2540 0030 movel %d0,%a2@(48) 46900: 4eb9 0004 f1bc jsr 4f1bc <__errno> 46906: 7216 moveq #22,%d1 46908: 2040 moveal %d0,%a0 4690a: 2081 movel %d1,%a0@ 4690c: 6048 bras 46956 <aio_read+0xae>
req = malloc (sizeof (rtems_aio_request));
4690e: 4878 0018 pea 18 <OPER2+0x4> 46912: 4eb9 0004 38dc jsr 438dc <malloc>
if (req == NULL)
46918: 588f addql #4,%sp 4691a: 4a80 tstl %d0
4691c: 661c bnes 4693a <aio_read+0x92> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
4691e: 103c 000b moveb #11,%d0 <== NOT EXECUTED 46922: 72ff moveq #-1,%d1 <== NOT EXECUTED 46924: 2540 0030 movel %d0,%a2@(48) <== NOT EXECUTED 46928: 2541 0034 movel %d1,%a2@(52) <== NOT EXECUTED 4692c: 4eb9 0004 f1bc jsr 4f1bc <__errno> <== NOT EXECUTED 46932: 2040 moveal %d0,%a0 <== NOT EXECUTED 46934: 700b moveq #11,%d0 <== NOT EXECUTED 46936: 2080 movel %d0,%a0@ <== NOT EXECUTED 46938: 601c bras 46956 <aio_read+0xae> <== NOT EXECUTED
req->aiocbp = aiocbp;
4693a: 2040 moveal %d0,%a0
req->aiocbp->aio_lio_opcode = LIO_READ;
4693c: 7201 moveq #1,%d1
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
4693e: 214a 0014 movel %a2,%a0@(20)
req->aiocbp->aio_lio_opcode = LIO_READ;
46942: 2541 002c movel %d1,%a2@(44)
return rtems_aio_enqueue (req);
}
46946: 246e fffc moveal %fp@(-4),%a2
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
4694a: 2d40 0008 movel %d0,%fp@(8)
}
4694e: 4e5e unlk %fp
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
46950: 4ef9 0004 66bc jmp 466bc <rtems_aio_enqueue>
}
46956: 246e fffc moveal %fp@(-4),%a2 4695a: 70ff moveq #-1,%d0
4695c: 4e5e unlk %fp <== NOT EXECUTED
00046970 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
46970: 4e56 0000 linkw %fp,#0 46974: 2f0a movel %a2,%sp@-
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
46976: 4878 0003 pea 3 <DIVIDE>
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
4697a: 246e 0008 moveal %fp@(8),%a2
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
4697e: 2f12 movel %a2@,%sp@- 46980: 4eb9 0004 c41c jsr 4c41c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
46986: 508f addql #8,%sp 46988: 7203 moveq #3,%d1 4698a: c081 andl %d1,%d0 4698c: 123c 0001 moveb #1,%d1 46990: 5380 subql #1,%d0 46992: b280 cmpl %d0,%d1
46994: 641a bccs 469b0 <aio_write+0x40>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
46996: 7009 moveq #9,%d0 46998: 72ff moveq #-1,%d1 4699a: 2540 0030 movel %d0,%a2@(48) 4699e: 2541 0034 movel %d1,%a2@(52) 469a2: 4eb9 0004 f1bc jsr 4f1bc <__errno> 469a8: 2040 moveal %d0,%a0 469aa: 7009 moveq #9,%d0 469ac: 2080 movel %d0,%a0@ 469ae: 606e bras 46a1e <aio_write+0xae>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
469b0: 4aaa 0014 tstl %a2@(20)
469b4: 6606 bnes 469bc <aio_write+0x4c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
469b6: 4aaa 0004 tstl %a2@(4)
469ba: 6a1a bpls 469d6 <aio_write+0x66>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
469bc: 72ff moveq #-1,%d1 469be: 7016 moveq #22,%d0 469c0: 2541 0034 movel %d1,%a2@(52) 469c4: 2540 0030 movel %d0,%a2@(48) 469c8: 4eb9 0004 f1bc jsr 4f1bc <__errno> 469ce: 7216 moveq #22,%d1 469d0: 2040 moveal %d0,%a0 469d2: 2081 movel %d1,%a0@ 469d4: 6048 bras 46a1e <aio_write+0xae>
req = malloc (sizeof (rtems_aio_request));
469d6: 4878 0018 pea 18 <OPER2+0x4> 469da: 4eb9 0004 38dc jsr 438dc <malloc>
if (req == NULL)
469e0: 588f addql #4,%sp 469e2: 4a80 tstl %d0
469e4: 661c bnes 46a02 <aio_write+0x92> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
469e6: 103c 000b moveb #11,%d0 <== NOT EXECUTED 469ea: 72ff moveq #-1,%d1 <== NOT EXECUTED 469ec: 2540 0030 movel %d0,%a2@(48) <== NOT EXECUTED 469f0: 2541 0034 movel %d1,%a2@(52) <== NOT EXECUTED 469f4: 4eb9 0004 f1bc jsr 4f1bc <__errno> <== NOT EXECUTED 469fa: 2040 moveal %d0,%a0 <== NOT EXECUTED 469fc: 700b moveq #11,%d0 <== NOT EXECUTED 469fe: 2080 movel %d0,%a0@ <== NOT EXECUTED 46a00: 601c bras 46a1e <aio_write+0xae> <== NOT EXECUTED
req->aiocbp = aiocbp;
46a02: 2040 moveal %d0,%a0
req->aiocbp->aio_lio_opcode = LIO_WRITE;
46a04: 7202 moveq #2,%d1
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
46a06: 214a 0014 movel %a2,%a0@(20)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
46a0a: 2541 002c movel %d1,%a2@(44)
return rtems_aio_enqueue (req);
}
46a0e: 246e fffc moveal %fp@(-4),%a2
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
46a12: 2d40 0008 movel %d0,%fp@(8)
}
46a16: 4e5e unlk %fp
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
46a18: 4ef9 0004 66bc jmp 466bc <rtems_aio_enqueue>
}
46a1e: 246e fffc moveal %fp@(-4),%a2 46a22: 70ff moveq #-1,%d0
46a24: 4e5e unlk %fp <== NOT EXECUTED
00045694 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
45694: 4e56 0000 linkw %fp,#0 45698: 222e 0008 movel %fp@(8),%d1 4569c: 202e 000c movel %fp@(12),%d0 456a0: 2f02 movel %d2,%sp@-
if ( !tp )
456a2: 4a80 tstl %d0
456a4: 6608 bnes 456ae <clock_gettime+0x1a>
rtems_set_errno_and_return_minus_one( EINVAL );
456a6: 4eb9 0004 da30 jsr 4da30 <__errno> 456ac: 6042 bras 456f0 <clock_gettime+0x5c>
if ( clock_id == CLOCK_REALTIME ) {
456ae: 7401 moveq #1,%d2 456b0: b481 cmpl %d1,%d2
456b2: 660a bnes 456be <clock_gettime+0x2a>
_TOD_Get(tp);
456b4: 2f00 movel %d0,%sp@- 456b6: 4eb9 0004 7350 jsr 47350 <_TOD_Get> 456bc: 6014 bras 456d2 <clock_gettime+0x3e>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
456be: 7404 moveq #4,%d2 456c0: b481 cmpl %d1,%d2
456c2: 6706 beqs 456ca <clock_gettime+0x36> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
456c4: 7402 moveq #2,%d2 456c6: b481 cmpl %d1,%d2
456c8: 660e bnes 456d8 <clock_gettime+0x44>
_TOD_Get_uptime_as_timespec( tp );
456ca: 2f00 movel %d0,%sp@- 456cc: 4eb9 0004 73b4 jsr 473b4 <_TOD_Get_uptime_as_timespec>
return 0;
456d2: 588f addql #4,%sp 456d4: 4280 clrl %d0 456d6: 6020 bras 456f8 <clock_gettime+0x64> 456d8: 41f9 0004 da30 lea 4da30 <__errno>,%a0
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
456de: 7003 moveq #3,%d0 456e0: b081 cmpl %d1,%d0
456e2: 660a bnes 456ee <clock_gettime+0x5a>
rtems_set_errno_and_return_minus_one( ENOSYS );
456e4: 4e90 jsr %a0@ 456e6: 7258 moveq #88,%d1 456e8: 2040 moveal %d0,%a0 456ea: 2081 movel %d1,%a0@ 456ec: 6008 bras 456f6 <clock_gettime+0x62>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
456ee: 4e90 jsr %a0@ 456f0: 2040 moveal %d0,%a0 456f2: 7016 moveq #22,%d0 456f4: 2080 movel %d0,%a0@ 456f6: 70ff moveq #-1,%d0
return 0;
}
456f8: 242e fffc movel %fp@(-4),%d2
456fc: 4e5e unlk %fp <== NOT EXECUTED
00045700 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
45700: 4e56 0000 linkw %fp,#0 45704: 202e 0008 movel %fp@(8),%d0 45708: 206e 000c moveal %fp@(12),%a0
if ( !tp )
4570c: 4a88 tstl %a0
4570e: 6710 beqs 45720 <clock_settime+0x20> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
45710: 7201 moveq #1,%d1 45712: b280 cmpl %d0,%d1
45714: 663a bnes 45750 <clock_settime+0x50> <== NEVER TAKEN
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
45716: 203c 21da e4ff movel #567993599,%d0 4571c: b090 cmpl %a0@,%d0
4571e: 6508 bcss 45728 <clock_settime+0x28>
rtems_set_errno_and_return_minus_one( EINVAL );
45720: 4eb9 0004 da30 jsr 4da30 <__errno> 45726: 6046 bras 4576e <clock_settime+0x6e>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45728: 2039 0006 05c8 movel 605c8 <_Thread_Dispatch_disable_level>,%d0 4572e: 5280 addql #1,%d0 45730: 23c0 0006 05c8 movel %d0,605c8 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45736: 2039 0006 05c8 movel 605c8 <_Thread_Dispatch_disable_level>,%d0
_Thread_Disable_dispatch();
_TOD_Set( tp );
4573c: 2f08 movel %a0,%sp@- 4573e: 4eb9 0004 740c jsr 4740c <_TOD_Set>
_Thread_Enable_dispatch();
45744: 4eb9 0004 894c jsr 4894c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
4574a: 588f addql #4,%sp 4574c: 4280 clrl %d0 4574e: 6026 bras 45776 <clock_settime+0x76> 45750: 41f9 0004 da30 lea 4da30 <__errno>,%a0
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
45756: 7202 moveq #2,%d1 45758: b280 cmpl %d0,%d1
4575a: 6706 beqs 45762 <clock_settime+0x62>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
4575c: 7203 moveq #3,%d1 4575e: b280 cmpl %d0,%d1
45760: 660a bnes 4576c <clock_settime+0x6c>
rtems_set_errno_and_return_minus_one( ENOSYS );
45762: 4e90 jsr %a0@ 45764: 7258 moveq #88,%d1 45766: 2040 moveal %d0,%a0 45768: 2081 movel %d1,%a0@ 4576a: 6008 bras 45774 <clock_settime+0x74>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
4576c: 4e90 jsr %a0@ 4576e: 2040 moveal %d0,%a0 45770: 7016 moveq #22,%d0 45772: 2080 movel %d0,%a0@ 45774: 70ff moveq #-1,%d0
return 0;
}
45776: 4e5e unlk %fp
...
0005ac44 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
5ac44: 4e56 ffcc linkw %fp,#-52 5ac48: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 5ac4c: 242e 000c movel %fp@(12),%d2 5ac50: 246e 0010 moveal %fp@(16),%a2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
5ac54: 4eb9 0005 a870 jsr 5a870 <getpid> 5ac5a: b0ae 0008 cmpl %fp@(8),%d0
5ac5e: 6710 beqs 5ac70 <killinfo+0x2c>
rtems_set_errno_and_return_minus_one( ESRCH );
5ac60: 4eb9 0004 cd68 jsr 4cd68 <__errno> 5ac66: 7403 moveq #3,%d2 5ac68: 2040 moveal %d0,%a0 5ac6a: 2082 movel %d2,%a0@ 5ac6c: 6000 01ae braw 5ae1c <killinfo+0x1d8>
/*
* Validate the signal passed.
*/
if ( !sig )
5ac70: 4a82 tstl %d2
5ac72: 670a beqs 5ac7e <killinfo+0x3a>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
5ac74: 2002 movel %d2,%d0 5ac76: 5380 subql #1,%d0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
5ac78: 721f moveq #31,%d1 5ac7a: b280 cmpl %d0,%d1
5ac7c: 6410 bccs 5ac8e <killinfo+0x4a>
rtems_set_errno_and_return_minus_one( EINVAL );
5ac7e: 4eb9 0004 cd68 jsr 4cd68 <__errno> 5ac84: 7216 moveq #22,%d1 5ac86: 2040 moveal %d0,%a0 5ac88: 2081 movel %d1,%a0@ 5ac8a: 6000 0190 braw 5ae1c <killinfo+0x1d8>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
5ac8e: 2202 movel %d2,%d1 5ac90: 2802 movel %d2,%d4 5ac92: e589 lsll #2,%d1 5ac94: e98c lsll #4,%d4 5ac96: 9881 subl %d1,%d4 5ac98: 2044 moveal %d4,%a0 5ac9a: d1fc 0005 f03c addal #389180,%a0 5aca0: 7201 moveq #1,%d1 5aca2: b290 cmpl %a0@,%d1 5aca4: 6700 01ae beqw 5ae54 <killinfo+0x210>
/* * 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 ) )
5aca8: 123c 0008 moveb #8,%d1 5acac: b282 cmpl %d2,%d1
5acae: 6710 beqs 5acc0 <killinfo+0x7c>
5acb0: 123c 0004 moveb #4,%d1 5acb4: b282 cmpl %d2,%d1
5acb6: 6708 beqs 5acc0 <killinfo+0x7c>
5acb8: 123c 000b moveb #11,%d1 5acbc: b282 cmpl %d2,%d1
5acbe: 6616 bnes 5acd6 <killinfo+0x92>
return pthread_kill( pthread_self(), sig );
5acc0: 4eb9 0005 b028 jsr 5b028 <pthread_self> 5acc6: 2f02 movel %d2,%sp@- 5acc8: 2f00 movel %d0,%sp@- 5acca: 4eb9 0005 af7c jsr 5af7c <pthread_kill> 5acd0: 508f addql #8,%sp 5acd2: 6000 0182 braw 5ae56 <killinfo+0x212>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
5acd6: 7601 moveq #1,%d3 5acd8: e1ab lsll %d0,%d3
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
5acda: 7001 moveq #1,%d0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
5acdc: 2d42 fff4 movel %d2,%fp@(-12)
siginfo->si_code = SI_USER;
5ace0: 2d40 fff8 movel %d0,%fp@(-8)
if ( !value ) {
5ace4: 4a8a tstl %a2
5ace6: 6606 bnes 5acee <killinfo+0xaa>
siginfo->si_value.sival_int = 0;
5ace8: 42ae fffc clrl %fp@(-4) 5acec: 6004 bras 5acf2 <killinfo+0xae>
} else {
siginfo->si_value = *value;
5acee: 2d52 fffc movel %a2@,%fp@(-4)
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
5acf2: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0 5acf8: 5280 addql #1,%d0 5acfa: 23c0 0005 eb98 movel %d0,5eb98 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
5ad00: 2039 0005 eb98 movel 5eb98 <_Thread_Dispatch_disable_level>,%d0
/*
* 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;
5ad06: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
5ad0c: 2268 0102 moveal %a0@(258),%a1 5ad10: 2029 00d0 movel %a1@(208),%d0 5ad14: 4680 notl %d0 5ad16: c083 andl %d3,%d0 5ad18: 6600 00ae bnew 5adc8 <killinfo+0x184>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
5ad1c: 2079 0005 f1c0 moveal 5f1c0 <_POSIX_signals_Wait_queue>,%a0
/* 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 );
5ad22: 601c bras 5ad40 <killinfo+0xfc>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
5ad24: 2003 movel %d3,%d0 5ad26: c0a8 0030 andl %a0@(48),%d0
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 ];
5ad2a: 2268 0102 moveal %a0@(258),%a1
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
5ad2e: 6600 0098 bnew 5adc8 <killinfo+0x184>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
5ad32: 2029 00d0 movel %a1@(208),%d0 5ad36: 4680 notl %d0 5ad38: c083 andl %d3,%d0 5ad3a: 6600 008c bnew 5adc8 <killinfo+0x184>
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 ) {
5ad3e: 2050 moveal %a0@,%a0
/* 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 );
5ad40: b1fc 0005 f1c4 cmpal #389572,%a0
5ad46: 66dc bnes 5ad24 <killinfo+0xe0> * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
5ad48: 4280 clrl %d0 5ad4a: 1039 0005 d1fa moveb 5d1fa <rtems_maximum_priority>,%d0 5ad50: 45f9 0005 eb5c lea 5eb5c <_Objects_Information_table+0x8>,%a2 5ad56: 5280 addql #1,%d0
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
5ad58: 91c8 subal %a0,%a0
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 ] )
5ad5a: 225a moveal %a2@+,%a1 5ad5c: 4a89 tstl %a1
5ad5e: 675c beqs 5adbc <killinfo+0x178> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
5ad60: 2269 0004 moveal %a1@(4),%a1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
5ad64: 4281 clrl %d1
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
5ad66: 7a01 moveq #1,%d5
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
5ad68: 3229 000e movew %a1@(14),%d1
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
5ad6c: 2669 0018 moveal %a1@(24),%a3
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
5ad70: 2841 moveal %d1,%a4
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
5ad72: 588b addql #4,%a3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
5ad74: 6042 bras 5adb8 <killinfo+0x174>
the_thread = (Thread_Control *) object_table[ index ];
5ad76: 225b moveal %a3@+,%a1
if ( !the_thread )
5ad78: 4a89 tstl %a1
5ad7a: 673a beqs 5adb6 <killinfo+0x172>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
5ad7c: 2229 0014 movel %a1@(20),%d1 5ad80: b081 cmpl %d1,%d0
5ad82: 6532 bcss 5adb6 <killinfo+0x172>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
5ad84: 2a69 0102 moveal %a1@(258),%a5 5ad88: 2c2d 00d0 movel %a5@(208),%d6 5ad8c: 4686 notl %d6 5ad8e: cc83 andl %d3,%d6
5ad90: 6724 beqs 5adb6 <killinfo+0x172>
*
* 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 ) {
5ad92: b081 cmpl %d1,%d0
5ad94: 621c bhis 5adb2 <killinfo+0x16e>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
5ad96: 4a88 tstl %a0
5ad98: 671c beqs 5adb6 <killinfo+0x172> <== NEVER TAKEN
5ad9a: 2e28 0010 movel %a0@(16),%d7
5ad9e: 6716 beqs 5adb6 <killinfo+0x172> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
5ada0: 2c29 0010 movel %a1@(16),%d6
5ada4: 670c beqs 5adb2 <killinfo+0x16e>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
5ada6: 0807 001c btst #28,%d7
5adaa: 660a bnes 5adb6 <killinfo+0x172>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
5adac: 0806 001c btst #28,%d6
5adb0: 6704 beqs 5adb6 <killinfo+0x172>
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
5adb2: 2001 movel %d1,%d0 5adb4: 2049 moveal %a1,%a0
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
5adb6: 5285 addql #1,%d5 5adb8: b9c5 cmpal %d5,%a4
5adba: 64ba bccs 5ad76 <killinfo+0x132>
* + 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++) {
5adbc: b5fc 0005 eb64 cmpal #387940,%a2
5adc2: 6696 bnes 5ad5a <killinfo+0x116>
}
}
}
}
if ( interested ) {
5adc4: 4a88 tstl %a0
5adc6: 6716 beqs 5adde <killinfo+0x19a>
/*
* 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 ) ) {
5adc8: 486e fff4 pea %fp@(-12) 5adcc: 2f02 movel %d2,%sp@- 5adce: 2f08 movel %a0,%sp@- 5add0: 4eb9 0005 ae80 jsr 5ae80 <_POSIX_signals_Unblock_thread> 5add6: 4fef 000c lea %sp@(12),%sp 5adda: 4a00 tstb %d0
5addc: 6670 bnes 5ae4e <killinfo+0x20a>
/*
* 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 );
5adde: 2f03 movel %d3,%sp@- 5ade0: 4eb9 0005 ae60 jsr 5ae60 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
5ade6: 588f addql #4,%sp 5ade8: 41f9 0005 f034 lea 5f034 <_POSIX_signals_Vectors>,%a0 5adee: 7002 moveq #2,%d0 5adf0: b0b0 4800 cmpl %a0@(00000000,%d4:l),%d0
5adf4: 6658 bnes 5ae4e <killinfo+0x20a>
psiginfo = (POSIX_signals_Siginfo_node *)
5adf6: 4879 0005 f1b4 pea 5f1b4 <_POSIX_signals_Inactive_siginfo> 5adfc: 4eb9 0004 6414 jsr 46414 <_Chain_Get>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
5ae02: 588f addql #4,%sp
*/
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
5ae04: 2440 moveal %d0,%a2
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
5ae06: 4a80 tstl %d0
5ae08: 6616 bnes 5ae20 <killinfo+0x1dc>
_Thread_Enable_dispatch();
5ae0a: 4eb9 0004 7d80 jsr 47d80 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
5ae10: 4eb9 0004 cd68 jsr 4cd68 <__errno> 5ae16: 2040 moveal %d0,%a0 5ae18: 700b moveq #11,%d0 5ae1a: 2080 movel %d0,%a0@ 5ae1c: 70ff moveq #-1,%d0 5ae1e: 6036 bras 5ae56 <killinfo+0x212>
}
psiginfo->Info = *siginfo;
5ae20: 4878 000c pea c <OPER1> 5ae24: 486e fff4 pea %fp@(-12) 5ae28: 486a 0008 pea %a2@(8) 5ae2c: 4eb9 0004 d588 jsr 4d588 <memcpy>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
5ae32: 2002 movel %d2,%d0 5ae34: e98a lsll #4,%d2 5ae36: e588 lsll #2,%d0 5ae38: 2f0a movel %a2,%sp@- 5ae3a: 9480 subl %d0,%d2 5ae3c: 0682 0005 f22c addil #389676,%d2 5ae42: 2f02 movel %d2,%sp@- 5ae44: 4eb9 0004 63b4 jsr 463b4 <_Chain_Append> 5ae4a: 4fef 0014 lea %sp@(20),%sp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
5ae4e: 4eb9 0004 7d80 jsr 47d80 <_Thread_Enable_dispatch>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
return 0;
5ae54: 4280 clrl %d0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
5ae56: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5
5ae5c: 4e5e unlk %fp <== NOT EXECUTED
0004a3e8 <pthread_attr_getstack>:
int pthread_attr_getstack(
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
4a3e8: 4e56 0000 linkw %fp,#0 4a3ec: 206e 0008 moveal %fp@(8),%a0 4a3f0: 2f0a movel %a2,%sp@- 4a3f2: 246e 000c moveal %fp@(12),%a2 4a3f6: 226e 0010 moveal %fp@(16),%a1
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
4a3fa: 4a88 tstl %a0
4a3fc: 6718 beqs 4a416 <pthread_attr_getstack+0x2e> <== NEVER TAKEN
4a3fe: 4a90 tstl %a0@
4a400: 6714 beqs 4a416 <pthread_attr_getstack+0x2e>
4a402: 4a8a tstl %a2
4a404: 6710 beqs 4a416 <pthread_attr_getstack+0x2e>
4a406: 4a89 tstl %a1
4a408: 670c beqs 4a416 <pthread_attr_getstack+0x2e>
return EINVAL;
*stackaddr = attr->stackaddr;
4a40a: 24a8 0004 movel %a0@(4),%a2@
*stacksize = attr->stacksize; return 0;
4a40e: 4280 clrl %d0
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
4a410: 22a8 0008 movel %a0@(8),%a1@
return 0;
4a414: 6002 bras 4a418 <pthread_attr_getstack+0x30>
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
4a416: 7016 moveq #22,%d0
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
return 0;
}
4a418: 245f moveal %sp@+,%a2 4a41a: 4e5e unlk %fp
...
0004a52c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
4a52c: 4e56 0000 linkw %fp,#0 4a530: 206e 0008 moveal %fp@(8),%a0 4a534: 222e 000c movel %fp@(12),%d1 4a538: 2f02 movel %d2,%sp@-
if ( !attr || !attr->is_initialized )
4a53a: 4a88 tstl %a0
4a53c: 671e beqs 4a55c <pthread_attr_setschedpolicy+0x30>
4a53e: 4a90 tstl %a0@
4a540: 671a beqs 4a55c <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
4a542: 7004 moveq #4,%d0 4a544: b081 cmpl %d1,%d0
4a546: 6518 bcss 4a560 <pthread_attr_setschedpolicy+0x34>
4a548: 103c 0001 moveb #1,%d0 4a54c: 7417 moveq #23,%d2 4a54e: e3a8 lsll %d1,%d0 4a550: c082 andl %d2,%d0
4a552: 670c beqs 4a560 <pthread_attr_setschedpolicy+0x34><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
4a554: 2141 0014 movel %d1,%a0@(20)
return 0;
4a558: 4280 clrl %d0 4a55a: 600a bras 4a566 <pthread_attr_setschedpolicy+0x3a>
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
4a55c: 7016 moveq #22,%d0 4a55e: 6006 bras 4a566 <pthread_attr_setschedpolicy+0x3a>
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
4a560: 203c 0000 0086 movel #134,%d0
} }
4a566: 241f movel %sp@+,%d2
4a568: 4e5e unlk %fp <== NOT EXECUTED
00045bac <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
45bac: 4e56 ffe0 linkw %fp,#-32 45bb0: 206e 000c moveal %fp@(12),%a0 45bb4: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 45bb8: 246e 0008 moveal %fp@(8),%a2 45bbc: 242e 0010 movel %fp@(16),%d2
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
45bc0: 4a8a tstl %a2 45bc2: 6700 0092 beqw 45c56 <pthread_barrier_init+0xaa>
return EINVAL;
if ( count == 0 )
45bc6: 4a82 tstl %d2 45bc8: 6700 008c beqw 45c56 <pthread_barrier_init+0xaa>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
45bcc: 4a88 tstl %a0
45bce: 6610 bnes 45be0 <pthread_barrier_init+0x34>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
45bd0: 260e movel %fp,%d3 45bd2: 5183 subql #8,%d3 45bd4: 2f03 movel %d3,%sp@- 45bd6: 4eb9 0004 5af4 jsr 45af4 <pthread_barrierattr_init> 45bdc: 588f addql #4,%sp
the_attr = &my_attr;
45bde: 2043 moveal %d3,%a0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
45be0: 4a90 tstl %a0@
45be2: 6772 beqs 45c56 <pthread_barrier_init+0xaa> <== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
45be4: 4aa8 0004 tstl %a0@(4)
45be8: 666c bnes 45c56 <pthread_barrier_init+0xaa> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45bea: 2039 0005 ff4c movel 5ff4c <_Thread_Dispatch_disable_level>,%d0 45bf0: 5280 addql #1,%d0 45bf2: 23c0 0005 ff4c movel %d0,5ff4c <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45bf8: 2039 0005 ff4c movel 5ff4c <_Thread_Dispatch_disable_level>,%d0
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
45bfe: 42ae fff0 clrl %fp@(-16)
the_attributes.maximum_count = count;
45c02: 2d42 fff4 movel %d2,%fp@(-12)
* 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 *)
45c06: 4879 0006 0242 pea 60242 <_POSIX_Barrier_Information> 45c0c: 4eb9 0004 7b28 jsr 47b28 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
45c12: 588f addql #4,%sp 45c14: 2640 moveal %d0,%a3 45c16: 4a80 tstl %d0
45c18: 660a bnes 45c24 <pthread_barrier_init+0x78>
_Thread_Enable_dispatch();
45c1a: 4eb9 0004 8b9c jsr 48b9c <_Thread_Enable_dispatch>
return EAGAIN;
45c20: 700b moveq #11,%d0 45c22: 6034 bras 45c58 <pthread_barrier_init+0xac>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
45c24: 486e fff0 pea %fp@(-16) 45c28: 486b 0010 pea %a3@(16) 45c2c: 4eb9 0004 7208 jsr 47208 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
45c32: 202b 0008 movel %a3@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45c36: 4281 clrl %d1 45c38: 2079 0006 025a moveal 6025a <_POSIX_Barrier_Information+0x18>,%a0 45c3e: 3200 movew %d0,%d1 45c40: 218b 1c00 movel %a3,%a0@(00000000,%d1:l:4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
45c44: 42ab 000c clrl %a3@(12)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
45c48: 2480 movel %d0,%a2@
_Thread_Enable_dispatch();
45c4a: 4eb9 0004 8b9c jsr 48b9c <_Thread_Enable_dispatch>
return 0;
45c50: 508f addql #8,%sp 45c52: 4280 clrl %d0 45c54: 6002 bras 45c58 <pthread_barrier_init+0xac>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
45c56: 7016 moveq #22,%d0
* Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; }
45c58: 4cee 0c0c ffe0 moveml %fp@(-32),%d2-%d3/%a2-%a3 45c5e: 4e5e unlk %fp
...
000455b8 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
455b8: 4e56 0000 linkw %fp,#0 455bc: 2f03 movel %d3,%sp@- 455be: 262e 000c movel %fp@(12),%d3 455c2: 2f02 movel %d2,%sp@- 455c4: 242e 0008 movel %fp@(8),%d2
/*
* The POSIX standard does not address what to do when the routine
* is NULL. It also does not address what happens when we cannot
* allocate memory or anything else bad happens.
*/
if ( !routine )
455c8: 675a beqs 45624 <pthread_cleanup_push+0x6c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
455ca: 2039 0005 f8d2 movel 5f8d2 <_Thread_Dispatch_disable_level>,%d0 455d0: 5280 addql #1,%d0 455d2: 23c0 0005 f8d2 movel %d0,5f8d2 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
455d8: 2039 0005 f8d2 movel 5f8d2 <_Thread_Dispatch_disable_level>,%d0
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
455de: 4878 0010 pea 10 <INVALID_OPERATION> 455e2: 4eb9 0004 955c jsr 4955c <_Workspace_Allocate>
if ( handler ) {
455e8: 588f addql #4,%sp 455ea: 4a80 tstl %d0
455ec: 6726 beqs 45614 <pthread_cleanup_push+0x5c> <== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
455ee: 2079 0005 fd34 moveal 5fd34 <_Per_CPU_Information+0xc>,%a0
handler_stack = &thread_support->Cancellation_Handlers;
455f4: 2228 0102 movel %a0@(258),%d1
handler->routine = routine;
455f8: 2040 moveal %d0,%a0
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
if ( handler ) {
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
455fa: 0681 0000 00e4 addil #228,%d1
handler->routine = routine;
45600: 2142 0008 movel %d2,%a0@(8)
handler->arg = arg;
45604: 2143 000c movel %d3,%a0@(12)
_Chain_Append( handler_stack, &handler->Node );
45608: 2f00 movel %d0,%sp@- 4560a: 2f01 movel %d1,%sp@- 4560c: 4eb9 0004 6cdc jsr 46cdc <_Chain_Append> 45612: 508f addql #8,%sp
} _Thread_Enable_dispatch(); }
45614: 242e fff8 movel %fp@(-8),%d2 45618: 262e fffc movel %fp@(-4),%d3 4561c: 4e5e unlk %fp
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
4561e: 4ef9 0004 8634 jmp 48634 <_Thread_Enable_dispatch>
}
45624: 242e fff8 movel %fp@(-8),%d2 45628: 262e fffc movel %fp@(-4),%d3
4562c: 4e5e unlk %fp <== NOT EXECUTED
00046188 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
46188: 4e56 0000 linkw %fp,#0 4618c: 206e 0008 moveal %fp@(8),%a0
if ( !attr || attr->is_initialized == false )
46190: 4a88 tstl %a0
46192: 670a beqs 4619e <pthread_condattr_destroy+0x16>
46194: 4a90 tstl %a0@
46196: 6706 beqs 4619e <pthread_condattr_destroy+0x16> <== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
46198: 4290 clrl %a0@
return 0;
4619a: 4280 clrl %d0 4619c: 6002 bras 461a0 <pthread_condattr_destroy+0x18>
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
4619e: 7016 moveq #22,%d0
attr->is_initialized = false;
return 0;
}
461a0: 4e5e unlk %fp <== NOT EXECUTED
0004c8d0 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
4c8d0: 4e56 0000 linkw %fp,#0
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
4c8d4: 2f2e 0008 movel %fp@(8),%sp@- 4c8d8: 2f39 0005 effa movel 5effa <_Per_CPU_Information+0xc>,%sp@- 4c8de: 4eb9 0004 c7e0 jsr 4c7e0 <_POSIX_Thread_Exit>
4c8e4: 508f addql #8,%sp <== NOT EXECUTED
}
4c8e6: 4e5e unlk %fp <== NOT EXECUTED
...
0005af7c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
5af7c: 4e56 fff0 linkw %fp,#-16 5af80: 48d7 040c moveml %d2-%d3/%a2,%sp@ 5af84: 242e 000c movel %fp@(12),%d2
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
5af88: 670a beqs 5af94 <pthread_kill+0x18>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
5af8a: 2602 movel %d2,%d3 5af8c: 5383 subql #1,%d3
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
5af8e: 701f moveq #31,%d0 5af90: b083 cmpl %d3,%d0
5af92: 640e bccs 5afa2 <pthread_kill+0x26>
rtems_set_errno_and_return_minus_one( EINVAL );
5af94: 4eb9 0004 cd68 jsr 4cd68 <__errno> 5af9a: 7216 moveq #22,%d1 5af9c: 2040 moveal %d0,%a0 5af9e: 2081 movel %d1,%a0@ 5afa0: 607a bras 5b01c <pthread_kill+0xa0>
the_thread = _Thread_Get( thread, &location );
5afa2: 486e fffc pea %fp@(-4) 5afa6: 2f2e 0008 movel %fp@(8),%sp@- 5afaa: 4eb9 0004 7da8 jsr 47da8 <_Thread_Get>
switch ( location ) {
5afb0: 508f addql #8,%sp
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 );
5afb2: 2440 moveal %d0,%a2
switch ( location ) {
5afb4: 4aae fffc tstl %fp@(-4)
5afb8: 6656 bnes 5b010 <pthread_kill+0x94> <== NEVER TAKEN
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
5afba: 2202 movel %d2,%d1 5afbc: 2002 movel %d2,%d0 5afbe: e589 lsll #2,%d1 5afc0: e988 lsll #4,%d0
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
5afc2: 206a 0102 moveal %a2@(258),%a0
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
5afc6: 9081 subl %d1,%d0 5afc8: 0680 0005 f03c addil #389180,%d0 5afce: 7201 moveq #1,%d1 5afd0: 2240 moveal %d0,%a1 5afd2: b291 cmpl %a1@,%d1
5afd4: 6730 beqs 5b006 <pthread_kill+0x8a>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
5afd6: 7001 moveq #1,%d0 5afd8: e7a8 lsll %d3,%d0
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
5afda: 81a8 00d4 orl %d0,%a0@(212)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
5afde: 42a7 clrl %sp@- 5afe0: 2f02 movel %d2,%sp@- 5afe2: 2f0a movel %a2,%sp@- 5afe4: 4eb9 0005 ae80 jsr 5ae80 <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
5afea: 4fef 000c lea %sp@(12),%sp 5afee: 4ab9 0005 eff6 tstl 5eff6 <_Per_CPU_Information+0x8>
5aff4: 6710 beqs 5b006 <pthread_kill+0x8a>
5aff6: b5f9 0005 effa cmpal 5effa <_Per_CPU_Information+0xc>,%a2
5affc: 6608 bnes 5b006 <pthread_kill+0x8a> _Thread_Dispatch_necessary = true;
5affe: 7001 moveq #1,%d0 5b000: 13c0 0005 f006 moveb %d0,5f006 <_Per_CPU_Information+0x18>
}
_Thread_Enable_dispatch();
5b006: 4eb9 0004 7d80 jsr 47d80 <_Thread_Enable_dispatch>
return 0;
5b00c: 4280 clrl %d0 5b00e: 600e bras 5b01e <pthread_kill+0xa2>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
5b010: 4eb9 0004 cd68 jsr 4cd68 <__errno> <== NOT EXECUTED 5b016: 2040 moveal %d0,%a0 <== NOT EXECUTED 5b018: 7003 moveq #3,%d0 <== NOT EXECUTED 5b01a: 2080 movel %d0,%a0@ <== NOT EXECUTED
5b01c: 70ff moveq #-1,%d0
}
5b01e: 4cee 040c fff0 moveml %fp@(-16),%d2-%d3/%a2
5b024: 4e5e unlk %fp <== NOT EXECUTED
0004753c <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
4753c: 4e56 fffc linkw %fp,#-4 47540: 2f03 movel %d3,%sp@- 47542: 2f02 movel %d2,%sp@-
* * 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 );
47544: 486e fffc pea %fp@(-4) 47548: 2f2e 000c movel %fp@(12),%sp@- 4754c: 4eb9 0004 7624 jsr 47624 <_POSIX_Absolute_timeout_to_ticks>
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
47552: 508f addql #8,%sp 47554: 2400 movel %d0,%d2 47556: 7003 moveq #3,%d0 47558: b082 cmpl %d2,%d0 4755a: 57c3 seq %d3
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
4755c: 2f2e fffc movel %fp@(-4),%sp@- 47560: 4483 negl %d3 47562: 4280 clrl %d0 47564: 1003 moveb %d3,%d0 47566: 2f00 movel %d0,%sp@- 47568: 2f2e 0008 movel %fp@(8),%sp@- 4756c: 4eb9 0004 7444 jsr 47444 <_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) ) {
47572: 4fef 000c lea %sp@(12),%sp 47576: 4a03 tstb %d3
47578: 661c bnes 47596 <pthread_mutex_timedlock+0x5a>
4757a: 7210 moveq #16,%d1 4757c: b280 cmpl %d0,%d1
4757e: 6616 bnes 47596 <pthread_mutex_timedlock+0x5a>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
47580: 4a82 tstl %d2
47582: 670c beqs 47590 <pthread_mutex_timedlock+0x54> <== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
47584: 5382 subql #1,%d2 47586: 123c 0001 moveb #1,%d1 4758a: b282 cmpl %d2,%d1
4758c: 6508 bcss 47596 <pthread_mutex_timedlock+0x5a> <== NEVER TAKEN
4758e: 6004 bras 47594 <pthread_mutex_timedlock+0x58>
* 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 )
return EINVAL;
47590: 7016 moveq #22,%d0 <== NOT EXECUTED 47592: 6002 bras 47596 <pthread_mutex_timedlock+0x5a> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
47594: 7074 moveq #116,%d0
}
return lock_status;
}
47596: 242e fff4 movel %fp@(-12),%d2 4759a: 262e fff8 movel %fp@(-8),%d3 4759e: 4e5e unlk %fp
...
00045420 <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
45420: 4e56 0000 linkw %fp,#0 45424: 206e 0008 moveal %fp@(8),%a0 45428: 226e 000c moveal %fp@(12),%a1
if ( !attr )
4542c: 4a88 tstl %a0
4542e: 6710 beqs 45440 <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !attr->is_initialized )
45430: 4a90 tstl %a0@
45432: 670c beqs 45440 <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !type )
45434: 4a89 tstl %a1
45436: 6708 beqs 45440 <pthread_mutexattr_gettype+0x20> <== NEVER TAKEN
return EINVAL;
*type = attr->type;
45438: 22a8 0010 movel %a0@(16),%a1@
return 0;
4543c: 4280 clrl %d0 4543e: 6002 bras 45442 <pthread_mutexattr_gettype+0x22>
if ( !attr->is_initialized )
return EINVAL;
if ( !type )
return EINVAL;
45440: 7016 moveq #22,%d0
*type = attr->type;
return 0;
}
45442: 4e5e unlk %fp
...
00047184 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
47184: 4e56 0000 linkw %fp,#0 47188: 206e 0008 moveal %fp@(8),%a0 4718c: 202e 000c movel %fp@(12),%d0
if ( !attr || !attr->is_initialized )
47190: 4a88 tstl %a0
47192: 6712 beqs 471a6 <pthread_mutexattr_setpshared+0x22>
47194: 4a90 tstl %a0@
47196: 670e beqs 471a6 <pthread_mutexattr_setpshared+0x22>
return EINVAL;
switch ( pshared ) {
47198: 7201 moveq #1,%d1 4719a: b280 cmpl %d0,%d1
4719c: 6508 bcss 471a6 <pthread_mutexattr_setpshared+0x22><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
4719e: 2140 0004 movel %d0,%a0@(4)
return 0;
471a2: 4280 clrl %d0 471a4: 6002 bras 471a8 <pthread_mutexattr_setpshared+0x24>
default:
return EINVAL;
471a6: 7016 moveq #22,%d0
} }
471a8: 4e5e unlk %fp <== NOT EXECUTED
00045474 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
45474: 4e56 0000 linkw %fp,#0 45478: 206e 0008 moveal %fp@(8),%a0 4547c: 202e 000c movel %fp@(12),%d0
if ( !attr || !attr->is_initialized )
45480: 4a88 tstl %a0
45482: 6712 beqs 45496 <pthread_mutexattr_settype+0x22>
45484: 4a90 tstl %a0@
45486: 670e beqs 45496 <pthread_mutexattr_settype+0x22> <== NEVER TAKEN
return EINVAL;
switch ( type ) {
45488: 7203 moveq #3,%d1 4548a: b280 cmpl %d0,%d1
4548c: 6508 bcss 45496 <pthread_mutexattr_settype+0x22>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
4548e: 2140 0010 movel %d0,%a0@(16)
return 0;
45492: 4280 clrl %d0 45494: 6002 bras 45498 <pthread_mutexattr_settype+0x24>
default:
return EINVAL;
45496: 7016 moveq #22,%d0
} }
45498: 4e5e unlk %fp <== NOT EXECUTED
00045f94 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
45f94: 4e56 fff0 linkw %fp,#-16 45f98: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 45f9c: 246e 0008 moveal %fp@(8),%a2 45fa0: 266e 000c moveal %fp@(12),%a3
if ( !once_control || !init_routine )
45fa4: 4a8a tstl %a2
45fa6: 674a beqs 45ff2 <pthread_once+0x5e>
45fa8: 4a8b tstl %a3
45faa: 6746 beqs 45ff2 <pthread_once+0x5e>
return EINVAL;
if ( !once_control->init_executed ) {
45fac: 4aaa 0004 tstl %a2@(4)
45fb0: 6644 bnes 45ff6 <pthread_once+0x62>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
45fb2: 240e movel %fp,%d2 45fb4: 5982 subql #4,%d2 45fb6: 2f02 movel %d2,%sp@- 45fb8: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> 45fbc: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> 45fc0: 4eb9 0004 6ab8 jsr 46ab8 <rtems_task_mode>
if ( !once_control->init_executed ) {
45fc6: 4fef 000c lea %sp@(12),%sp 45fca: 4aaa 0004 tstl %a2@(4)
45fce: 660c bnes 45fdc <pthread_once+0x48> <== NEVER TAKEN
once_control->is_initialized = true;
45fd0: 7001 moveq #1,%d0 45fd2: 2480 movel %d0,%a2@
once_control->init_executed = true;
45fd4: 7001 moveq #1,%d0 45fd6: 2540 0004 movel %d0,%a2@(4)
(*init_routine)();
45fda: 4e93 jsr %a3@
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
45fdc: 2f02 movel %d2,%sp@- 45fde: 4878 0100 pea 100 <DBL_MANT_DIG+0xcb> 45fe2: 2f2e fffc movel %fp@(-4),%sp@- 45fe6: 4eb9 0004 6ab8 jsr 46ab8 <rtems_task_mode> 45fec: 4fef 000c lea %sp@(12),%sp 45ff0: 6004 bras 45ff6 <pthread_once+0x62>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
45ff2: 7016 moveq #22,%d0 45ff4: 6002 bras 45ff8 <pthread_once+0x64>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
45ff6: 4280 clrl %d0
}
45ff8: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3 45ffe: 4e5e unlk %fp
...
00046670 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
46670: 4e56 ffe8 linkw %fp,#-24 46674: 206e 000c moveal %fp@(12),%a0 46678: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 4667c: 246e 0008 moveal %fp@(8),%a2
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
46680: 4a8a tstl %a2 46682: 6700 008c beqw 46710 <pthread_rwlock_init+0xa0>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
46686: 4a88 tstl %a0
46688: 6614 bnes 4669e <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
4668a: 240e movel %fp,%d2 4668c: 0682 ffff fff4 addil #-12,%d2 46692: 2f02 movel %d2,%sp@- 46694: 4eb9 0004 6fd8 jsr 46fd8 <pthread_rwlockattr_init> 4669a: 588f addql #4,%sp
the_attr = &default_attr;
4669c: 2042 moveal %d2,%a0
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
4669e: 4a90 tstl %a0@
466a0: 676e beqs 46710 <pthread_rwlock_init+0xa0> <== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
466a2: 4aa8 0004 tstl %a0@(4)
466a6: 6668 bnes 46710 <pthread_rwlock_init+0xa0> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
466a8: 2039 0006 156c movel 6156c <_Thread_Dispatch_disable_level>,%d0 466ae: 5280 addql #1,%d0 466b0: 23c0 0006 156c movel %d0,6156c <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
466b6: 2039 0006 156c movel 6156c <_Thread_Dispatch_disable_level>,%d0
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
466bc: 42ae fffc clrl %fp@(-4)
* 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 *)
466c0: 4879 0006 16cc pea 616cc <_POSIX_RWLock_Information> 466c6: 4eb9 0004 8b54 jsr 48b54 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
466cc: 588f addql #4,%sp 466ce: 2640 moveal %d0,%a3 466d0: 4a80 tstl %d0
466d2: 660a bnes 466de <pthread_rwlock_init+0x6e>
_Thread_Enable_dispatch();
466d4: 4eb9 0004 9bc8 jsr 49bc8 <_Thread_Enable_dispatch>
return EAGAIN;
466da: 700b moveq #11,%d0 466dc: 6034 bras 46712 <pthread_rwlock_init+0xa2>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
466de: 486e fffc pea %fp@(-4) 466e2: 486b 0010 pea %a3@(16) 466e6: 4eb9 0004 8340 jsr 48340 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
466ec: 202b 0008 movel %a3@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
466f0: 4281 clrl %d1 466f2: 2079 0006 16e4 moveal 616e4 <_POSIX_RWLock_Information+0x18>,%a0 466f8: 3200 movew %d0,%d1 466fa: 218b 1c00 movel %a3,%a0@(00000000,%d1:l:4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
466fe: 42ab 000c clrl %a3@(12)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
46702: 2480 movel %d0,%a2@
_Thread_Enable_dispatch();
46704: 4eb9 0004 9bc8 jsr 49bc8 <_Thread_Enable_dispatch>
return 0;
4670a: 508f addql #8,%sp 4670c: 4280 clrl %d0 4670e: 6002 bras 46712 <pthread_rwlock_init+0xa2>
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
46710: 7016 moveq #22,%d0
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
46712: 4cee 0c04 ffe8 moveml %fp@(-24),%d2/%a2-%a3
46718: 4e5e unlk %fp <== NOT EXECUTED
00046784 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
46784: 4e56 ffec linkw %fp,#-20 46788: 48d7 040c moveml %d2-%d3/%a2,%sp@ 4678c: 246e 0008 moveal %fp@(8),%a2
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
46790: 4a8a tstl %a2 46792: 6700 0086 beqw 4681a <pthread_rwlock_timedrdlock+0x96>
* * 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 );
46796: 486e fffc pea %fp@(-4) 4679a: 2f2e 000c movel %fp@(12),%sp@- 4679e: 4eb9 0004 c598 jsr 4c598 <_POSIX_Absolute_timeout_to_ticks> 467a4: 486e fff8 pea %fp@(-8) 467a8: 2400 movel %d0,%d2 467aa: 2f12 movel %a2@,%sp@- 467ac: 4879 0006 16cc pea 616cc <_POSIX_RWLock_Information> 467b2: 4eb9 0004 8fb4 jsr 48fb4 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
467b8: 4fef 0014 lea %sp@(20),%sp 467bc: 4aae fff8 tstl %fp@(-8)
467c0: 6658 bnes 4681a <pthread_rwlock_timedrdlock+0x96><== NEVER TAKEN
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,
467c2: 7203 moveq #3,%d1 467c4: b282 cmpl %d2,%d1 467c6: 57c3 seq %d3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
467c8: 42a7 clrl %sp@- 467ca: 2f2e fffc movel %fp@(-4),%sp@- 467ce: 4483 negl %d3 467d0: 4281 clrl %d1 467d2: 1203 moveb %d3,%d1 467d4: 2040 moveal %d0,%a0 467d6: 2f01 movel %d1,%sp@- 467d8: 2f12 movel %a2@,%sp@- 467da: 4868 0010 pea %a0@(16) 467de: 4eb9 0004 8374 jsr 48374 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
467e4: 4eb9 0004 9bc8 jsr 49bc8 <_Thread_Enable_dispatch> 467ea: 2079 0006 19ce moveal 619ce <_Per_CPU_Information+0xc>,%a0
if ( !do_wait ) {
467f0: 4fef 0014 lea %sp@(20),%sp 467f4: 4a03 tstb %d3
467f6: 6614 bnes 4680c <pthread_rwlock_timedrdlock+0x88><== NEVER TAKEN
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
467f8: 7002 moveq #2,%d0 467fa: b0a8 0034 cmpl %a0@(52),%d0
467fe: 660c bnes 4680c <pthread_rwlock_timedrdlock+0x88> if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
46800: 4a82 tstl %d2
46802: 6716 beqs 4681a <pthread_rwlock_timedrdlock+0x96><== NEVER TAKEN
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
46804: 5382 subql #1,%d2 46806: 7201 moveq #1,%d1 46808: b282 cmpl %d2,%d1
4680a: 6412 bccs 4681e <pthread_rwlock_timedrdlock+0x9a><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
4680c: 2f28 0034 movel %a0@(52),%sp@- 46810: 4eb9 0004 68d4 jsr 468d4 <_POSIX_RWLock_Translate_core_RWLock_return_code> 46816: 588f addql #4,%sp 46818: 6006 bras 46820 <pthread_rwlock_timedrdlock+0x9c>
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
4681a: 7016 moveq #22,%d0 4681c: 6002 bras 46820 <pthread_rwlock_timedrdlock+0x9c>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
4681e: 7074 moveq #116,%d0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
46820: 4cee 040c ffec moveml %fp@(-20),%d2-%d3/%a2 46826: 4e5e unlk %fp
...
0004682c <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
4682c: 4e56 ffec linkw %fp,#-20 46830: 48d7 040c moveml %d2-%d3/%a2,%sp@ 46834: 246e 0008 moveal %fp@(8),%a2
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
46838: 4a8a tstl %a2 4683a: 6700 0086 beqw 468c2 <pthread_rwlock_timedwrlock+0x96>
* * 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 );
4683e: 486e fffc pea %fp@(-4) 46842: 2f2e 000c movel %fp@(12),%sp@- 46846: 4eb9 0004 c598 jsr 4c598 <_POSIX_Absolute_timeout_to_ticks> 4684c: 486e fff8 pea %fp@(-8) 46850: 2400 movel %d0,%d2 46852: 2f12 movel %a2@,%sp@- 46854: 4879 0006 16cc pea 616cc <_POSIX_RWLock_Information> 4685a: 4eb9 0004 8fb4 jsr 48fb4 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
46860: 4fef 0014 lea %sp@(20),%sp 46864: 4aae fff8 tstl %fp@(-8)
46868: 6658 bnes 468c2 <pthread_rwlock_timedwrlock+0x96>
(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,
4686a: 7203 moveq #3,%d1 4686c: b282 cmpl %d2,%d1 4686e: 57c3 seq %d3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
46870: 42a7 clrl %sp@- 46872: 2f2e fffc movel %fp@(-4),%sp@- 46876: 4483 negl %d3 46878: 4281 clrl %d1 4687a: 1203 moveb %d3,%d1 4687c: 2040 moveal %d0,%a0 4687e: 2f01 movel %d1,%sp@- 46880: 2f12 movel %a2@,%sp@- 46882: 4868 0010 pea %a0@(16) 46886: 4eb9 0004 8420 jsr 48420 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
4688c: 4eb9 0004 9bc8 jsr 49bc8 <_Thread_Enable_dispatch> 46892: 2079 0006 19ce moveal 619ce <_Per_CPU_Information+0xc>,%a0
if ( !do_wait &&
46898: 4fef 0014 lea %sp@(20),%sp 4689c: 4a03 tstb %d3
4689e: 6614 bnes 468b4 <pthread_rwlock_timedwrlock+0x88>
468a0: 7002 moveq #2,%d0 468a2: b0a8 0034 cmpl %a0@(52),%d0
468a6: 660c bnes 468b4 <pthread_rwlock_timedwrlock+0x88>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
468a8: 4a82 tstl %d2
468aa: 6716 beqs 468c2 <pthread_rwlock_timedwrlock+0x96><== NEVER TAKEN
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
468ac: 5382 subql #1,%d2 468ae: 7201 moveq #1,%d1 468b0: b282 cmpl %d2,%d1
468b2: 6412 bccs 468c6 <pthread_rwlock_timedwrlock+0x9a><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
468b4: 2f28 0034 movel %a0@(52),%sp@- 468b8: 4eb9 0004 68d4 jsr 468d4 <_POSIX_RWLock_Translate_core_RWLock_return_code> 468be: 588f addql #4,%sp 468c0: 6006 bras 468c8 <pthread_rwlock_timedwrlock+0x9c>
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
468c2: 7016 moveq #22,%d0 468c4: 6002 bras 468c8 <pthread_rwlock_timedwrlock+0x9c>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
468c6: 7074 moveq #116,%d0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
468c8: 4cee 040c ffec moveml %fp@(-20),%d2-%d3/%a2 468ce: 4e5e unlk %fp
...
00046ff8 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
46ff8: 4e56 0000 linkw %fp,#0 46ffc: 206e 0008 moveal %fp@(8),%a0 47000: 202e 000c movel %fp@(12),%d0
if ( !attr )
47004: 4a88 tstl %a0
47006: 6712 beqs 4701a <pthread_rwlockattr_setpshared+0x22>
return EINVAL;
if ( !attr->is_initialized )
47008: 4a90 tstl %a0@
4700a: 670e beqs 4701a <pthread_rwlockattr_setpshared+0x22>
return EINVAL;
switch ( pshared ) {
4700c: 7201 moveq #1,%d1 4700e: b280 cmpl %d0,%d1
47010: 6508 bcss 4701a <pthread_rwlockattr_setpshared+0x22><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
47012: 2140 0004 movel %d0,%a0@(4)
return 0;
47016: 4280 clrl %d0 47018: 6002 bras 4701c <pthread_rwlockattr_setpshared+0x24>
default:
return EINVAL;
4701a: 7016 moveq #22,%d0
} }
4701c: 4e5e unlk %fp <== NOT EXECUTED
00047dc4 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
47dc4: 4e56 ffe0 linkw %fp,#-32 47dc8: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 47dcc: 242e 000c movel %fp@(12),%d2 47dd0: 282e 0010 movel %fp@(16),%d4
int rc;
/*
* Check all the parameters
*/
if ( !param )
47dd4: 6700 00d8 beqw 47eae <pthread_setschedparam+0xea>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
47dd8: 486e fff8 pea %fp@(-8) 47ddc: 486e fff4 pea %fp@(-12) 47de0: 2f04 movel %d4,%sp@- 47de2: 2f02 movel %d2,%sp@- 47de4: 4eb9 0004 d330 jsr 4d330 <_POSIX_Thread_Translate_sched_param>
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
47dea: 4fef 0010 lea %sp@(16),%sp
* Check all the parameters
*/
if ( !param )
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
47dee: 2600 movel %d0,%d3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
47df0: 6600 00c2 bnew 47eb4 <pthread_setschedparam+0xf0>
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
47df4: 486e fffc pea %fp@(-4) 47df8: 2f2e 0008 movel %fp@(8),%sp@- 47dfc: 4eb9 0004 a82c jsr 4a82c <_Thread_Get>
switch ( location ) {
47e02: 508f addql #8,%sp
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
47e04: 2640 moveal %d0,%a3
switch ( location ) {
47e06: 4aae fffc tstl %fp@(-4) 47e0a: 6600 00a6 bnew 47eb2 <pthread_setschedparam+0xee>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
47e0e: 246b 0102 moveal %a3@(258),%a2
if ( api->schedpolicy == SCHED_SPORADIC )
47e12: 7004 moveq #4,%d0 47e14: b0aa 0084 cmpl %a2@(132),%d0
47e18: 660c bnes 47e26 <pthread_setschedparam+0x62>
(void) _Watchdog_Remove( &api->Sporadic_timer );
47e1a: 486a 00a8 pea %a2@(168) 47e1e: 4eb9 0004 b6ac jsr 4b6ac <_Watchdog_Remove> 47e24: 588f addql #4,%sp
api->schedpolicy = policy;
47e26: 2542 0084 movel %d2,%a2@(132)
api->schedparam = *param;
47e2a: 4878 001c pea 1c <OPER2+0x8> 47e2e: 2f04 movel %d4,%sp@- 47e30: 486a 0088 pea %a2@(136) 47e34: 4eb9 0004 fe40 jsr 4fe40 <memcpy>
the_thread->budget_algorithm = budget_algorithm;
47e3a: 276e fff4 007a movel %fp@(-12),%a3@(122)
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
47e40: 4fef 000c lea %sp@(12),%sp
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
47e44: 276e fff8 007e movel %fp@(-8),%a3@(126)
switch ( api->schedpolicy ) {
47e4a: 4a82 tstl %d2
47e4c: 6d58 blts 47ea6 <pthread_setschedparam+0xe2> <== NEVER TAKEN
47e4e: 7002 moveq #2,%d0 47e50: b082 cmpl %d2,%d0
47e52: 6c0a bges 47e5e <pthread_setschedparam+0x9a>
47e54: 103c 0004 moveb #4,%d0 47e58: b082 cmpl %d2,%d0
47e5a: 664a bnes 47ea6 <pthread_setschedparam+0xe2> <== NEVER TAKEN
47e5c: 602a bras 47e88 <pthread_setschedparam+0xc4> 47e5e: 4280 clrl %d0 47e60: 1039 0006 1a1a moveb 61a1a <rtems_maximum_priority>,%d0
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
47e66: 41f9 0006 33d0 lea 633d0 <_Thread_Ticks_per_timeslice>,%a0 47e6c: 90aa 0088 subl %a2@(136),%d0 47e70: 2750 0076 movel %a0@,%a3@(118)
the_thread->real_priority =
47e74: 2740 0018 movel %d0,%a3@(24)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
47e78: 4878 0001 pea 1 <ADD> 47e7c: 2f00 movel %d0,%sp@- 47e7e: 2f0b movel %a3,%sp@- 47e80: 4eb9 0004 a3b4 jsr 4a3b4 <_Thread_Change_priority> 47e86: 601a bras 47ea2 <pthread_setschedparam+0xde>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
47e88: 256a 0088 00a4 movel %a2@(136),%a2@(164)
_Watchdog_Remove( &api->Sporadic_timer );
47e8e: 486a 00a8 pea %a2@(168) 47e92: 4eb9 0004 b6ac jsr 4b6ac <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
47e98: 2f0b movel %a3,%sp@- 47e9a: 42a7 clrl %sp@- 47e9c: 4eb9 0004 7c9e jsr 47c9e <_POSIX_Threads_Sporadic_budget_TSR>
break;
47ea2: 4fef 000c lea %sp@(12),%sp
}
_Thread_Enable_dispatch();
47ea6: 4eb9 0004 a804 jsr 4a804 <_Thread_Enable_dispatch>
return 0;
47eac: 6006 bras 47eb4 <pthread_setschedparam+0xf0>
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
47eae: 7616 moveq #22,%d3 47eb0: 6002 bras 47eb4 <pthread_setschedparam+0xf0>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
47eb2: 7603 moveq #3,%d3
}
47eb4: 2003 movel %d3,%d0 47eb6: 4cee 0c1c ffe0 moveml %fp@(-32),%d2-%d4/%a2-%a3
47ebc: 4e5e unlk %fp <== NOT EXECUTED
00045d30 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
45d30: 4e56 0000 linkw %fp,#0 45d34: 2f02 movel %d2,%sp@-
* 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() )
45d36: 4ab9 0005 fd30 tstl 5fd30 <_Per_CPU_Information+0x8>
45d3c: 664c bnes 45d8a <pthread_testcancel+0x5a> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45d3e: 2039 0005 f8d2 movel 5f8d2 <_Thread_Dispatch_disable_level>,%d0 45d44: 5280 addql #1,%d0
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
45d46: 2079 0005 fd34 moveal 5fd34 <_Per_CPU_Information+0xc>,%a0 45d4c: 23c0 0005 f8d2 movel %d0,5f8d2 <_Thread_Dispatch_disable_level> 45d52: 2068 0102 moveal %a0@(258),%a0
return _Thread_Dispatch_disable_level;
45d56: 2039 0005 f8d2 movel 5f8d2 <_Thread_Dispatch_disable_level>,%d0
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
45d5c: 4aa8 00d8 tstl %a0@(216)
45d60: 660a bnes 45d6c <pthread_testcancel+0x3c> <== NEVER TAKEN
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
45d62: 4aa8 00e0 tstl %a0@(224) 45d66: 56c2 sne %d2 45d68: 4482 negl %d2 45d6a: 6002 bras 45d6e <pthread_testcancel+0x3e>
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
45d6c: 4202 clrb %d2 <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
45d6e: 4eb9 0004 8634 jsr 48634 <_Thread_Enable_dispatch>
if ( cancel )
45d74: 4a02 tstb %d2
45d76: 6712 beqs 45d8a <pthread_testcancel+0x5a>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
45d78: 4878 ffff pea ffffffff <LESS> 45d7c: 2f39 0005 fd34 movel 5fd34 <_Per_CPU_Information+0xc>,%sp@- 45d82: 4eb9 0004 b240 jsr 4b240 <_POSIX_Thread_Exit>
45d88: 508f addql #8,%sp <== NOT EXECUTED
}
45d8a: 242e fffc movel %fp@(-4),%d2 45d8e: 4e5e unlk %fp
...
000466bc <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
466bc: 4e56 ffc8 linkw %fp,#-56 466c0: 48d7 3c04 moveml %d2/%a2-%a5,%sp@
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);
466c4: 4879 0006 12c8 pea 612c8 <aio_request_queue> 466ca: 4bf9 0004 6fe0 lea 46fe0 <pthread_mutex_lock>,%a5
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
466d0: 246e 0008 moveal %fp@(8),%a2
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);
466d4: 4e95 jsr %a5@
if (result != 0) {
466d6: 588f addql #4,%sp
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);
466d8: 2400 movel %d0,%d2
if (result != 0) {
466da: 670c beqs 466e8 <rtems_aio_enqueue+0x2c> <== ALWAYS TAKEN
free (req);
466dc: 2f0a movel %a2,%sp@- <== NOT EXECUTED 466de: 4eb9 0004 33b4 jsr 433b4 <free> <== NOT EXECUTED 466e4: 6000 01b2 braw 46898 <rtems_aio_enqueue+0x1dc> <== 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);
466e8: 47f9 0004 77b8 lea 477b8 <pthread_self>,%a3 466ee: 4e93 jsr %a3@ 466f0: 486e ffdc pea %fp@(-36) 466f4: 486e fffc pea %fp@(-4) 466f8: 2f00 movel %d0,%sp@- 466fa: 4eb9 0004 73dc jsr 473dc <pthread_getschedparam>
req->caller_thread = pthread_self ();
46700: 4e93 jsr %a3@
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
46702: 206a 0014 moveal %a2@(20),%a0
req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
46706: 7277 moveq #119,%d1
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
46708: 4fef 000c lea %sp@(12),%sp
/* _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 ();
4670c: 2540 0010 movel %d0,%a2@(16)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
46710: 202e ffdc movel %fp@(-36),%d0 46714: 90a8 0014 subl %a0@(20),%d0
req->policy = policy;
46718: 256e fffc 0008 movel %fp@(-4),%a2@(8)
/* _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;
4671e: 2540 000c movel %d0,%a2@(12)
req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
46722: 2141 0030 movel %d1,%a0@(48)
req->aiocbp->return_value = 0;
46726: 42a8 0034 clrl %a0@(52)
if ((aio_request_queue.idle_threads == 0) &&
4672a: 4ab9 0006 1330 tstl 61330 <aio_request_queue+0x68> 46730: 6600 009e bnew 467d0 <rtems_aio_enqueue+0x114> 46734: 7004 moveq #4,%d0 46736: b0b9 0006 132c cmpl 6132c <aio_request_queue+0x64>,%d0 4673c: 6d00 0092 bltw 467d0 <rtems_aio_enqueue+0x114>
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);
46740: 4878 0001 pea 1 <ADD> 46744: 2f10 movel %a0@,%sp@- 46746: 4879 0006 1310 pea 61310 <aio_request_queue+0x48> 4674c: 4eb9 0004 62ba jsr 462ba <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
46752: 4fef 000c lea %sp@(12),%sp 46756: 7201 moveq #1,%d1
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);
46758: 2640 moveal %d0,%a3
if (r_chain->new_fd == 1) {
4675a: b2ab 0018 cmpl %a3@(24),%d1
4675e: 6666 bnes 467c6 <rtems_aio_enqueue+0x10a>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
46760: 2f0a movel %a2,%sp@- 46762: 486b 0008 pea %a3@(8) 46766: 4eb9 0004 88b0 jsr 488b0 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0;
4676c: 42ab 0018 clrl %a3@(24)
pthread_mutex_init (&r_chain->mutex, NULL);
46770: 42a7 clrl %sp@- 46772: 486b 001c pea %a3@(28) 46776: 4eb9 0004 6ec4 jsr 46ec4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
4677c: 42a7 clrl %sp@- 4677e: 486b 0020 pea %a3@(32) 46782: 4eb9 0004 6b54 jsr 46b54 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
46788: 2f0b movel %a3,%sp@- 4678a: 487a fbf4 pea %pc@(46380 <rtems_aio_handle>) 4678e: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8> 46794: 486e fff8 pea %fp@(-8) 46798: 4eb9 0004 71d8 jsr 471d8 <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
4679e: 4fef 0028 lea %sp@(40),%sp
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
pthread_cond_init (&r_chain->cond, NULL);
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
467a2: 2440 moveal %d0,%a2
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
467a4: 4a80 tstl %d0
467a6: 6714 beqs 467bc <rtems_aio_enqueue+0x100> <== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
467a8: 4879 0006 12c8 pea 612c8 <aio_request_queue> <== NOT EXECUTED
return result;
467ae: 240a movel %a2,%d2 <== 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);
467b0: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
467b6: 588f addql #4,%sp <== NOT EXECUTED 467b8: 6000 00e0 braw 4689a <rtems_aio_enqueue+0x1de> <== NOT EXECUTED
} ++aio_request_queue.active_threads;
467bc: 52b9 0006 132c addql #1,6132c <aio_request_queue+0x64> 467c2: 6000 00c8 braw 4688c <rtems_aio_enqueue+0x1d0>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
467c6: 49eb 001c lea %a3@(28),%a4 467ca: 2f0c movel %a4,%sp@- 467cc: 4e95 jsr %a5@ 467ce: 6028 bras 467f8 <rtems_aio_enqueue+0x13c>
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,
467d0: 42a7 clrl %sp@- 467d2: 2f10 movel %a0@,%sp@- 467d4: 49f9 0004 62ba lea 462ba <rtems_aio_search_fd>,%a4 467da: 4879 0006 1310 pea 61310 <aio_request_queue+0x48> 467e0: 4e94 jsr %a4@
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
467e2: 4fef 000c lea %sp@(12),%sp
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,
467e6: 2640 moveal %d0,%a3
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
467e8: 4a80 tstl %d0
467ea: 6730 beqs 4681c <rtems_aio_enqueue+0x160>
{
pthread_mutex_lock (&r_chain->mutex);
467ec: 49eb 001c lea %a3@(28),%a4 467f0: 2f0c movel %a4,%sp@- 467f2: 4eb9 0004 6fe0 jsr 46fe0 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
467f8: 2f0a movel %a2,%sp@- 467fa: 486b 0008 pea %a3@(8) 467fe: 4eb9 0004 65ba jsr 465ba <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
46804: 486b 0020 pea %a3@(32) 46808: 4eb9 0004 6c04 jsr 46c04 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
4680e: 2f0c movel %a4,%sp@- 46810: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock> 46816: 4fef 0014 lea %sp@(20),%sp 4681a: 6070 bras 4688c <rtems_aio_enqueue+0x1d0>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
4681c: 4878 0001 pea 1 <ADD> 46820: 206a 0014 moveal %a2@(20),%a0 46824: 2f10 movel %a0@,%sp@- 46826: 4879 0006 131c pea 6131c <aio_request_queue+0x54> 4682c: 4e94 jsr %a4@
if (r_chain->new_fd == 1) {
4682e: 4fef 000c lea %sp@(12),%sp 46832: 7201 moveq #1,%d1
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
46834: 2640 moveal %d0,%a3 46836: 5080 addql #8,%d0
if (r_chain->new_fd == 1) {
46838: b2ab 0018 cmpl %a3@(24),%d1
4683c: 662c bnes 4686a <rtems_aio_enqueue+0x1ae>
4683e: 2f0a movel %a2,%sp@- 46840: 2f00 movel %d0,%sp@- 46842: 4eb9 0004 88b0 jsr 488b0 <_Chain_Insert>
/* 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;
46848: 42ab 0018 clrl %a3@(24)
pthread_mutex_init (&r_chain->mutex, NULL);
4684c: 42a7 clrl %sp@- 4684e: 486b 001c pea %a3@(28) 46852: 4eb9 0004 6ec4 jsr 46ec4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
46858: 42a7 clrl %sp@- 4685a: 486b 0020 pea %a3@(32) 4685e: 4eb9 0004 6b54 jsr 46b54 <pthread_cond_init> 46864: 4fef 0018 lea %sp@(24),%sp 46868: 600c bras 46876 <rtems_aio_enqueue+0x1ba>
} else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
4686a: 2f0a movel %a2,%sp@- 4686c: 2f00 movel %d0,%sp@- 4686e: 4eb9 0004 65ba jsr 465ba <rtems_aio_insert_prio> 46874: 508f addql #8,%sp
if (aio_request_queue.idle_threads > 0)
46876: 4ab9 0006 1330 tstl 61330 <aio_request_queue+0x68>
4687c: 6f0e bles 4688c <rtems_aio_enqueue+0x1d0> <== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
4687e: 4879 0006 12cc pea 612cc <aio_request_queue+0x4> <== NOT EXECUTED 46884: 4eb9 0004 6c04 jsr 46c04 <pthread_cond_signal> <== NOT EXECUTED 4688a: 588f addql #4,%sp <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
4688c: 4879 0006 12c8 pea 612c8 <aio_request_queue> 46892: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return 0;
46898: 588f addql #4,%sp
}
4689a: 2002 movel %d2,%d0 4689c: 4cee 3c04 ffc8 moveml %fp@(-56),%d2/%a2-%a5 468a2: 4e5e unlk %fp
...
00046380 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
46380: 4e56 ffac linkw %fp,#-84 46384: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
46388: 240e movel %fp,%d2
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);
4638a: 280e movel %fp,%d4 4638c: 2e0e movel %fp,%d7
/* 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);
4638e: 2a3c 0004 6fe0 movel #290784,%d5
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
46394: 49f9 0004 7078 lea 47078 <pthread_mutex_unlock>,%a4
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
4639a: 0682 ffff fff4 addil #-12,%d2 463a0: 4bf9 0004 6a28 lea 46a28 <clock_gettime>,%a5
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);
463a6: 0684 ffff ffd8 addil #-40,%d4 463ac: 5987 subql #4,%d7
static void *
rtems_aio_handle (void *arg)
{
rtems_aio_request_chain *r_chain = arg;
463ae: 246e 0008 moveal %fp@(8),%a2
/* 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);
463b2: 260a movel %a2,%d3 463b4: 0683 0000 001c addil #28,%d3 463ba: 2045 moveal %d5,%a0 463bc: 2f03 movel %d3,%sp@- 463be: 4e90 jsr %a0@
if (result != 0)
463c0: 588f addql #4,%sp 463c2: 4a80 tstl %d0 463c4: 6600 01e8 bnew 465ae <rtems_aio_handle+0x22e>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
463c8: 200a movel %a2,%d0 463ca: 0680 0000 000c addil #12,%d0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
463d0: 266a 0008 moveal %a2@(8),%a3
/* 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)) {
463d4: b08b cmpl %a3,%d0 463d6: 6700 00d8 beqw 464b0 <rtems_aio_handle+0x130>
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);
463da: 2c3c 0004 77b8 movel #292792,%d6 463e0: 2046 moveal %d6,%a0 463e2: 4e90 jsr %a0@ 463e4: 2f04 movel %d4,%sp@- 463e6: 2f07 movel %d7,%sp@- 463e8: 2f00 movel %d0,%sp@- 463ea: 4eb9 0004 73dc jsr 473dc <pthread_getschedparam>
param.sched_priority = req->priority;
pthread_setschedparam (pthread_self(), req->policy, ¶m);
463f0: 222b 0008 movel %a3@(8),%d1 463f4: 2046 moveal %d6,%a0
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
param.sched_priority = req->priority;
463f6: 2d6b 000c ffd8 movel %a3@(12),%fp@(-40)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
463fc: 2d41 ffd4 movel %d1,%fp@(-44) 46400: 4e90 jsr %a0@ 46402: 2f04 movel %d4,%sp@- 46404: 2f2e ffd4 movel %fp@(-44),%sp@- 46408: 2f00 movel %d0,%sp@- 4640a: 4eb9 0004 77cc jsr 477cc <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
46410: 2f0b movel %a3,%sp@- 46412: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
46418: 2f03 movel %d3,%sp@- 4641a: 4e94 jsr %a4@
switch (req->aiocbp->aio_lio_opcode) {
4641c: 206b 0014 moveal %a3@(20),%a0 46420: 4fef 0020 lea %sp@(32),%sp 46424: 7202 moveq #2,%d1 46426: 2028 002c movel %a0@(44),%d0 4642a: b280 cmpl %d0,%d1
4642c: 672a beqs 46458 <rtems_aio_handle+0xd8>
4642e: 123c 0003 moveb #3,%d1 46432: b280 cmpl %d0,%d1
46434: 6740 beqs 46476 <rtems_aio_handle+0xf6> <== NEVER TAKEN
46436: 123c 0001 moveb #1,%d1 4643a: b280 cmpl %d0,%d1
4643c: 6648 bnes 46486 <rtems_aio_handle+0x106> <== NEVER TAKEN
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
4643e: 2f28 0008 movel %a0@(8),%sp@- 46442: 2f28 0004 movel %a0@(4),%sp@- 46446: 2f28 0010 movel %a0@(16),%sp@- 4644a: 2f28 000c movel %a0@(12),%sp@- 4644e: 2f10 movel %a0@,%sp@- 46450: 4eb9 0004 fbdc jsr 4fbdc <pread> 46456: 6018 bras 46470 <rtems_aio_handle+0xf0>
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
46458: 2f28 0008 movel %a0@(8),%sp@- 4645c: 2f28 0004 movel %a0@(4),%sp@- 46460: 2f28 0010 movel %a0@(16),%sp@- 46464: 2f28 000c movel %a0@(12),%sp@- 46468: 2f10 movel %a0@,%sp@- 4646a: 4eb9 0004 fca0 jsr 4fca0 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
46470: 4fef 0014 lea %sp@(20),%sp 46474: 600a bras 46480 <rtems_aio_handle+0x100>
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
46476: 2f10 movel %a0@,%sp@- <== NOT EXECUTED 46478: 4eb9 0004 c5a8 jsr 4c5a8 <fsync> <== NOT EXECUTED
break;
4647e: 588f addql #4,%sp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
46480: 72ff moveq #-1,%d1 46482: b280 cmpl %d0,%d1
46484: 661a bnes 464a0 <rtems_aio_handle+0x120> <== ALWAYS TAKEN
req->aiocbp->return_value = -1;
46486: 266b 0014 moveal %a3@(20),%a3 <== NOT EXECUTED 4648a: 70ff moveq #-1,%d0 <== NOT EXECUTED 4648c: 2740 0034 movel %d0,%a3@(52) <== NOT EXECUTED
req->aiocbp->error_code = errno;
46490: 4eb9 0004 f1bc jsr 4f1bc <__errno> <== NOT EXECUTED 46496: 2040 moveal %d0,%a0 <== NOT EXECUTED 46498: 2750 0030 movel %a0@,%a3@(48) <== NOT EXECUTED 4649c: 6000 ff14 braw 463b2 <rtems_aio_handle+0x32> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
464a0: 206b 0014 moveal %a3@(20),%a0 464a4: 2140 0034 movel %d0,%a0@(52)
req->aiocbp->error_code = 0;
464a8: 42a8 0030 clrl %a0@(48) 464ac: 6000 ff04 braw 463b2 <rtems_aio_handle+0x32>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
464b0: 2f03 movel %d3,%sp@- 464b2: 4e94 jsr %a4@
pthread_mutex_lock (&aio_request_queue.mutex);
464b4: 4879 0006 12c8 pea 612c8 <aio_request_queue> 464ba: 2045 moveal %d5,%a0 464bc: 4e90 jsr %a0@
if (rtems_chain_is_empty (chain))
464be: 508f addql #8,%sp 464c0: b7ea 0008 cmpal %a2@(8),%a3 464c4: 6600 00da bnew 465a0 <rtems_aio_handle+0x220>
{
clock_gettime (CLOCK_REALTIME, &timeout);
464c8: 2f02 movel %d2,%sp@- 464ca: 4878 0001 pea 1 <ADD>
timeout.tv_sec += 3; timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
464ce: 2c0a movel %a2,%d6 464d0: 0686 0000 0020 addil #32,%d6 464d6: 47f9 0004 6c78 lea 46c78 <pthread_cond_timedwait>,%a3
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
464dc: 4e95 jsr %a5@
timeout.tv_sec += 3;
464de: 56ae fff4 addql #3,%fp@(-12)
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
464e2: 2f02 movel %d2,%sp@- 464e4: 4879 0006 12c8 pea 612c8 <aio_request_queue>
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
464ea: 42ae fff8 clrl %fp@(-8)
result = pthread_cond_timedwait (&r_chain->cond,
464ee: 2f06 movel %d6,%sp@- 464f0: 4e93 jsr %a3@
&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) {
464f2: 4fef 0014 lea %sp@(20),%sp 464f6: 7274 moveq #116,%d1 464f8: b280 cmpl %d0,%d1 464fa: 6600 00a4 bnew 465a0 <rtems_aio_handle+0x220> 464fe: 2f0a movel %a2,%sp@- 46500: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
46506: 2f03 movel %d3,%sp@- 46508: 4eb9 0004 6da8 jsr 46da8 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
4650e: 2f06 movel %d6,%sp@- 46510: 4eb9 0004 6a94 jsr 46a94 <pthread_cond_destroy>
free (r_chain);
46516: 2f0a movel %a2,%sp@- 46518: 4eb9 0004 33b4 jsr 433b4 <free>
/* 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)) {
4651e: 4fef 0010 lea %sp@(16),%sp 46522: 41f9 0006 1320 lea 61320 <aio_request_queue+0x58>,%a0 46528: b1f9 0006 131c cmpal 6131c <aio_request_queue+0x54>,%a0
4652e: 664c bnes 4657c <rtems_aio_handle+0x1fc>
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);
46530: 2f02 movel %d2,%sp@- 46532: 4878 0001 pea 1 <ADD>
/* 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;
46536: 52b9 0006 1330 addql #1,61330 <aio_request_queue+0x68>
--aio_request_queue.active_threads;
4653c: 53b9 0006 132c subql #1,6132c <aio_request_queue+0x64>
clock_gettime (CLOCK_REALTIME, &timeout);
46542: 4e95 jsr %a5@
timeout.tv_sec += 3;
46544: 56ae fff4 addql #3,%fp@(-12)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
46548: 2f02 movel %d2,%sp@- 4654a: 4879 0006 12c8 pea 612c8 <aio_request_queue> 46550: 4879 0006 12cc pea 612cc <aio_request_queue+0x4>
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
46556: 42ae fff8 clrl %fp@(-8)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
4655a: 4e93 jsr %a3@
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
4655c: 4fef 0014 lea %sp@(20),%sp 46560: 7274 moveq #116,%d1 46562: b280 cmpl %d0,%d1
46564: 6616 bnes 4657c <rtems_aio_handle+0x1fc> <== NEVER TAKEN
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
46566: 4879 0006 12c8 pea 612c8 <aio_request_queue>
/* 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;
4656c: 53b9 0006 1330 subql #1,61330 <aio_request_queue+0x68>
pthread_mutex_unlock (&aio_request_queue.mutex);
46572: 4eb9 0004 7078 jsr 47078 <pthread_mutex_unlock>
return NULL;
46578: 588f addql #4,%sp 4657a: 6032 bras 465ae <rtems_aio_handle+0x22e>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4657c: 2479 0006 131c moveal 6131c <aio_request_queue+0x54>,%a2
}
}
/* 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;
46582: 53b9 0006 1330 subql #1,61330 <aio_request_queue+0x68>
++aio_request_queue.active_threads;
46588: 52b9 0006 132c addql #1,6132c <aio_request_queue+0x64> 4658e: 2f0a movel %a2,%sp@- 46590: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
rtems_aio_move_to_work (r_chain);
46596: 2f0a movel %a2,%sp@- 46598: 4eb9 0004 634a jsr 4634a <rtems_aio_move_to_work> 4659e: 508f addql #8,%sp
}
}
/* 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);
465a0: 4879 0006 12c8 pea 612c8 <aio_request_queue> 465a6: 4e94 jsr %a4@ 465a8: 588f addql #4,%sp 465aa: 6000 fe06 braw 463b2 <rtems_aio_handle+0x32>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
465ae: 4280 clrl %d0 465b0: 4cee 3cfc ffac moveml %fp@(-84),%d2-%d7/%a2-%a5
465b6: 4e5e unlk %fp <== NOT EXECUTED
000461d0 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
461d0: 4e56 0000 linkw %fp,#0 461d4: 2f02 movel %d2,%sp@-
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
461d6: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8> 461dc: 4eb9 0004 7184 jsr 47184 <pthread_attr_init>
if (result != 0)
461e2: 588f addql #4,%sp
int
rtems_aio_init (void)
{
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
461e4: 2400 movel %d0,%d2
if (result != 0)
461e6: 6600 00c8 bnew 462b0 <rtems_aio_init+0xe0>
return result;
result =
461ea: 42a7 clrl %sp@- 461ec: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8> 461f2: 4eb9 0004 71b0 jsr 471b0 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
461f8: 508f addql #8,%sp 461fa: 4a80 tstl %d0
461fc: 670e beqs 4620c <rtems_aio_init+0x3c> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
461fe: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8> <== NOT EXECUTED 46204: 4eb9 0004 7168 jsr 47168 <pthread_attr_destroy> <== NOT EXECUTED 4620a: 588f addql #4,%sp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
4620c: 42a7 clrl %sp@- 4620e: 4879 0006 12c8 pea 612c8 <aio_request_queue> 46214: 4eb9 0004 6ec4 jsr 46ec4 <pthread_mutex_init>
if (result != 0)
4621a: 508f addql #8,%sp 4621c: 4a80 tstl %d0
4621e: 670e beqs 4622e <rtems_aio_init+0x5e> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
46220: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8> <== NOT EXECUTED 46226: 4eb9 0004 7168 jsr 47168 <pthread_attr_destroy> <== NOT EXECUTED 4622c: 588f addql #4,%sp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
4622e: 42a7 clrl %sp@- 46230: 4879 0006 12cc pea 612cc <aio_request_queue+0x4> 46236: 4eb9 0004 6b54 jsr 46b54 <pthread_cond_init>
if (result != 0) {
4623c: 508f addql #8,%sp
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
4623e: 2400 movel %d0,%d2
if (result != 0) {
46240: 671a beqs 4625c <rtems_aio_init+0x8c> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
46242: 4879 0006 12c8 pea 612c8 <aio_request_queue> <== NOT EXECUTED 46248: 4eb9 0004 6da8 jsr 46da8 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
4624e: 4879 0006 12d0 pea 612d0 <aio_request_queue+0x8> <== NOT EXECUTED 46254: 4eb9 0004 7168 jsr 47168 <pthread_attr_destroy> <== NOT EXECUTED 4625a: 508f addql #8,%sp <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4625c: 42b9 0006 1314 clrl 61314 <aio_request_queue+0x4c>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
46262: 203c 0006 1314 movel #398100,%d0 46268: 23c0 0006 1310 movel %d0,61310 <aio_request_queue+0x48>
head->previous = NULL; tail->previous = head;
4626e: 203c 0006 1310 movel #398096,%d0 46274: 23c0 0006 1318 movel %d0,61318 <aio_request_queue+0x50>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
4627a: 203c 0006 1320 movel #398112,%d0 46280: 23c0 0006 131c movel %d0,6131c <aio_request_queue+0x54>
head->previous = NULL; tail->previous = head;
46286: 203c 0006 131c movel #398108,%d0 4628c: 23c0 0006 1324 movel %d0,61324 <aio_request_queue+0x5c>
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
46292: 203c 0000 b00b movel #45067,%d0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
46298: 42b9 0006 1320 clrl 61320 <aio_request_queue+0x58>
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
4629e: 42b9 0006 132c clrl 6132c <aio_request_queue+0x64>
aio_request_queue.idle_threads = 0;
462a4: 42b9 0006 1330 clrl 61330 <aio_request_queue+0x68>
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
462aa: 23c0 0006 1328 movel %d0,61328 <aio_request_queue+0x60>
return result;
}
462b0: 2002 movel %d2,%d0 462b2: 242e fffc movel %fp@(-4),%d2
462b6: 4e5e unlk %fp <== NOT EXECUTED
000465ba <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
465ba: 4e56 0000 linkw %fp,#0 465be: 202e 0008 movel %fp@(8),%d0 465c2: 2240 moveal %d0,%a1 465c4: 2f0b movel %a3,%sp@- 465c6: 2059 moveal %a1@+,%a0 465c8: 2f0a movel %a2,%sp@- 465ca: 246e 000c moveal %fp@(12),%a2
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
465ce: b3c8 cmpal %a0,%a1
465d0: 672e beqs 46600 <rtems_aio_insert_prio+0x46> <== NEVER TAKEN
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;
465d2: 2668 0014 moveal %a0@(20),%a3 465d6: 202b 0014 movel %a3@(20),%d0
while (req->aiocbp->aio_reqprio > prio &&
465da: 266a 0014 moveal %a2@(20),%a3 465de: 222b 0014 movel %a3@(20),%d1 465e2: 600a bras 465ee <rtems_aio_insert_prio+0x34>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
465e4: 2050 moveal %a0@,%a0 <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
465e6: 2668 0014 moveal %a0@(20),%a3 <== NOT EXECUTED 465ea: 202b 0014 movel %a3@(20),%d0 <== 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 &&
465ee: b081 cmpl %d1,%d0
465f0: 6c04 bges 465f6 <rtems_aio_insert_prio+0x3c> <== ALWAYS TAKEN
465f2: b3c8 cmpal %a0,%a1 <== NOT EXECUTED 465f4: 66ee bnes 465e4 <rtems_aio_insert_prio+0x2a> <== 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 );
465f6: 2d4a 000c movel %a2,%fp@(12) 465fa: 2d68 0004 0008 movel %a0@(4),%fp@(8)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
46600: 245f moveal %sp@+,%a2 46602: 265f moveal %sp@+,%a3 46604: 4e5e unlk %fp 46606: 4ef9 0004 88b0 jmp 488b0 <_Chain_Insert>
0004634a <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
4634a: 4e56 0000 linkw %fp,#0 4634e: 226e 0008 moveal %fp@(8),%a1
rtems_aio_request_chain *temp;
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
46352: 2079 0006 1310 moveal 61310 <aio_request_queue+0x48>,%a0
while (temp->fildes < r_chain->fildes &&
46358: 2029 0014 movel %a1@(20),%d0 4635c: 6002 bras 46360 <rtems_aio_move_to_work+0x16>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
4635e: 2050 moveal %a0@,%a0
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 &&
46360: b0a8 0014 cmpl %a0@(20),%d0
46364: 6f08 bles 4636e <rtems_aio_move_to_work+0x24>
46366: b1fc 0006 1314 cmpal #398100,%a0
4636c: 66f0 bnes 4635e <rtems_aio_move_to_work+0x14> <== ALWAYS TAKEN
4636e: 2f09 movel %a1,%sp@- 46370: 2f28 0004 movel %a0@(4),%sp@- 46374: 4eb9 0004 88b0 jsr 488b0 <_Chain_Insert> 4637a: 508f addql #8,%sp
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
4637c: 4e5e unlk %fp <== NOT EXECUTED
00046662 <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)
{
46662: 4e56 0000 linkw %fp,#0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
46666: 206e 0008 moveal %fp@(8),%a0 4666a: 2f0a movel %a2,%sp@- 4666c: 202e 000c movel %fp@(12),%d0 46670: 2458 moveal %a0@+,%a2
if (rtems_chain_is_empty (chain))
46672: b1ca cmpal %a2,%a0
46674: 6604 bnes 4667a <rtems_aio_remove_req+0x18>
46676: 6036 bras 466ae <rtems_aio_remove_req+0x4c>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
46678: 2452 moveal %a2@,%a2 <== 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) {
4667a: b1ca cmpal %a2,%a0
4667c: 6734 beqs 466b2 <rtems_aio_remove_req+0x50> <== NEVER TAKEN
4667e: b0aa 0014 cmpl %a2@(20),%d0
46682: 66f4 bnes 46678 <rtems_aio_remove_req+0x16> <== NEVER TAKEN
46684: 2f0a movel %a2,%sp@- 46686: 4eb9 0004 8854 jsr 48854 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
4668c: 206a 0014 moveal %a2@(20),%a0 46690: 203c 0000 008c movel #140,%d0 46696: 2140 0030 movel %d0,%a0@(48)
current->aiocbp->return_value = -1;
4669a: 70ff moveq #-1,%d0 4669c: 2140 0034 movel %d0,%a0@(52)
free (current);
466a0: 2f0a movel %a2,%sp@- 466a2: 4eb9 0004 33b4 jsr 433b4 <free>
}
return AIO_CANCELED;
466a8: 508f addql #8,%sp 466aa: 4280 clrl %d0 466ac: 6006 bras 466b4 <rtems_aio_remove_req+0x52>
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
466ae: 7002 moveq #2,%d0 466b0: 6002 bras 466b4 <rtems_aio_remove_req+0x52>
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
466b2: 7001 moveq #1,%d0 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
466b4: 246e fffc moveal %fp@(-4),%a2
466b8: 4e5e unlk %fp <== NOT EXECUTED
000463cc <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
463cc: 4e56 0000 linkw %fp,#0 463d0: 2f03 movel %d3,%sp@- 463d2: 262e 0010 movel %fp@(16),%d3 463d6: 2f02 movel %d2,%sp@-
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 );
463d8: 2f2e 0014 movel %fp@(20),%sp@- 463dc: 2f2e 0008 movel %fp@(8),%sp@- 463e0: 242e 000c movel %fp@(12),%d2 463e4: 4eb9 0004 69c8 jsr 469c8 <_Chain_Get_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
463ea: 508f addql #8,%sp 463ec: 4a00 tstb %d0
463ee: 6718 beqs 46408 <rtems_chain_get_with_notification+0x3c><== NEVER TAKEN
sc = rtems_event_send( task, events );
463f0: 2d43 000c movel %d3,%fp@(12)
}
return sc;
}
463f4: 262e fffc movel %fp@(-4),%d3
{
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 );
463f8: 2d42 0008 movel %d2,%fp@(8)
}
return sc;
}
463fc: 242e fff8 movel %fp@(-8),%d2 46400: 4e5e unlk %fp
{
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 );
46402: 4ef9 0004 59f8 jmp 459f8 <rtems_event_send>
}
return sc;
}
46408: 242e fff8 movel %fp@(-8),%d2 4640c: 4280 clrl %d0 4640e: 262e fffc movel %fp@(-4),%d3 46412: 4e5e unlk %fp
...
00046418 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
46418: 4e56 ffe0 linkw %fp,#-32 4641c: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
46420: 260e movel %fp,%d3
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
46422: 47f9 0004 6a10 lea 46a10 <_Chain_Get>,%a3 46428: 5983 subql #4,%d3 4642a: 45f9 0004 5890 lea 45890 <rtems_event_receive>,%a2
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
46430: 2c2e 0008 movel %fp@(8),%d6 46434: 2a2e 000c movel %fp@(12),%d5 46438: 282e 0010 movel %fp@(16),%d4 4643c: 6012 bras 46450 <rtems_chain_get_with_wait+0x38>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
4643e: 2f03 movel %d3,%sp@- 46440: 2f04 movel %d4,%sp@- 46442: 42a7 clrl %sp@- 46444: 2f05 movel %d5,%sp@- 46446: 4e92 jsr %a2@
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
46448: 4fef 0010 lea %sp@(16),%sp 4644c: 4a80 tstl %d0
4644e: 660c bnes 4645c <rtems_chain_get_with_wait+0x44> <== ALWAYS TAKEN
46450: 2f06 movel %d6,%sp@- 46452: 4e93 jsr %a3@
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
46454: 588f addql #4,%sp 46456: 2400 movel %d0,%d2
46458: 67e4 beqs 4643e <rtems_chain_get_with_wait+0x26>
4645a: 4280 clrl %d0
timeout,
&out
);
}
*node_ptr = node;
4645c: 206e 0014 moveal %fp@(20),%a0 46460: 2082 movel %d2,%a0@
return sc;
}
46462: 4cee 0c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a3
46468: 4e5e unlk %fp <== NOT EXECUTED
00046ff0 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
46ff0: 4e56 fff4 linkw %fp,#-12 46ff4: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 46ff8: 242e 0008 movel %fp@(8),%d2 46ffc: 266e 0010 moveal %fp@(16),%a3
Extension_Control *the_extension;
if ( !id )
47000: 4a8b tstl %a3
47002: 6778 beqs 4707c <rtems_extension_create+0x8c> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
47004: 4a82 tstl %d2
47006: 6778 beqs 47080 <rtems_extension_create+0x90> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
47008: 2039 0006 0d78 movel 60d78 <_Thread_Dispatch_disable_level>,%d0 4700e: 5280 addql #1,%d0 47010: 23c0 0006 0d78 movel %d0,60d78 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
47016: 2039 0006 0d78 movel 60d78 <_Thread_Dispatch_disable_level>,%d0
#ifndef __EXTENSION_MANAGER_inl
#define __EXTENSION_MANAGER_inl
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
4701c: 4879 0006 0ed8 pea 60ed8 <_Extension_Information> 47022: 4eb9 0004 7dd4 jsr 47dd4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
47028: 588f addql #4,%sp 4702a: 2440 moveal %d0,%a2 4702c: 4a80 tstl %d0
4702e: 660a bnes 4703a <rtems_extension_create+0x4a>
_Thread_Enable_dispatch();
47030: 4eb9 0004 8f2c jsr 48f2c <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
47036: 7005 moveq #5,%d0 47038: 6048 bras 47082 <rtems_extension_create+0x92>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
4703a: 4878 0020 pea 20 <OPER2+0xc> 4703e: 2f2e 000c movel %fp@(12),%sp@- 47042: 486a 0024 pea %a2@(36) 47046: 4eb9 0004 e71c jsr 4e71c <memcpy>
_User_extensions_Add_set( extension );
4704c: 486a 0010 pea %a2@(16) 47050: 4eb9 0004 99ac jsr 499ac <_User_extensions_Add_set>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
47056: 202a 0008 movel %a2@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4705a: 4281 clrl %d1 4705c: 2079 0006 0ef0 moveal 60ef0 <_Extension_Information+0x18>,%a0 47062: 3200 movew %d0,%d1 47064: 218a 1c00 movel %a2,%a0@(00000000,%d1:l:4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
47068: 2542 000c movel %d2,%a2@(12)
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
4706c: 2680 movel %d0,%a3@
_Thread_Enable_dispatch();
4706e: 4eb9 0004 8f2c jsr 48f2c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
47074: 4fef 0010 lea %sp@(16),%sp 47078: 4280 clrl %d0 4707a: 6006 bras 47082 <rtems_extension_create+0x92>
)
{
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
4707c: 7009 moveq #9,%d0 4707e: 6002 bras 47082 <rtems_extension_create+0x92>
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
47080: 7003 moveq #3,%d0
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
47082: 4cee 0c04 fff4 moveml %fp@(-12),%d2/%a2-%a3
47088: 4e5e unlk %fp <== NOT EXECUTED
0004ca18 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4ca18: 4e56 0000 linkw %fp,#0 4ca1c: 202e 0008 movel %fp@(8),%d0 4ca20: 2f03 movel %d3,%sp@- 4ca22: 2f02 movel %d2,%sp@-
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4ca24: b0b9 0005 f412 cmpl 5f412 <_IO_Number_of_drivers>,%d0
4ca2a: 6420 bccs 4ca4c <rtems_io_close+0x34> <== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
4ca2c: 2600 movel %d0,%d3 4ca2e: 2200 movel %d0,%d1 4ca30: e78b lsll #3,%d3 4ca32: eb89 lsll #5,%d1 4ca34: 2279 0005 f416 moveal 5f416 <_IO_Driver_address_table>,%a1 4ca3a: 9283 subl %d3,%d1 4ca3c: 2271 1808 moveal %a1@(00000008,%d1:l),%a1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4ca40: 4a89 tstl %a1
4ca42: 670c beqs 4ca50 <rtems_io_close+0x38> }
4ca44: 241f movel %sp@+,%d2 4ca46: 261f movel %sp@+,%d3 4ca48: 4e5e unlk %fp
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4ca4a: 4ed1 jmp %a1@
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
4ca4c: 700a moveq #10,%d0 4ca4e: 6002 bras 4ca52 <rtems_io_close+0x3a>
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4ca50: 4280 clrl %d0
}
4ca52: 241f movel %sp@+,%d2 4ca54: 261f movel %sp@+,%d3 4ca56: 4e5e unlk %fp
...
00046e1c <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
46e1c: 4e56 0000 linkw %fp,#0 46e20: 206e 000c moveal %fp@(12),%a0 46e24: 2f0a movel %a2,%sp@- 46e26: 226e 0010 moveal %fp@(16),%a1 46e2a: 2f02 movel %d2,%sp@- 46e2c: 242e 0008 movel %fp@(8),%d2
rtems_device_major_number major_limit = _IO_Number_of_drivers;
46e30: 2039 0006 282a movel 6282a <_IO_Number_of_drivers>,%d0
if ( rtems_interrupt_is_in_progress() )
46e36: 4ab9 0006 240e tstl 6240e <_Per_CPU_Information+0x8> 46e3c: 6600 00de bnew 46f1c <rtems_io_register_driver+0x100>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
46e40: 4a89 tstl %a1 46e42: 6700 00dc beqw 46f20 <rtems_io_register_driver+0x104>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
46e46: 2280 movel %d0,%a1@
if ( driver_table == NULL )
46e48: 4a88 tstl %a0 46e4a: 6700 00d4 beqw 46f20 <rtems_io_register_driver+0x104>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46e4e: 4a90 tstl %a0@ 46e50: 6600 00e0 bnew 46f32 <rtems_io_register_driver+0x116> 46e54: 4aa8 0004 tstl %a0@(4) 46e58: 6600 00d8 bnew 46f32 <rtems_io_register_driver+0x116> 46e5c: 6000 00c2 braw 46f20 <rtems_io_register_driver+0x104>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
46e60: 2039 0006 1fb0 movel 61fb0 <_Thread_Dispatch_disable_level>,%d0 46e66: 5280 addql #1,%d0 46e68: 23c0 0006 1fb0 movel %d0,61fb0 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
46e6e: 2039 0006 1fb0 movel 61fb0 <_Thread_Dispatch_disable_level>,%d0
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
46e74: 4a82 tstl %d2
46e76: 662c bnes 46ea4 <rtems_io_register_driver+0x88>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
46e78: 2039 0006 282a movel 6282a <_IO_Number_of_drivers>,%d0 46e7e: 2479 0006 282e moveal 6282e <_IO_Driver_address_table>,%a2 46e84: 6010 bras 46e96 <rtems_io_register_driver+0x7a>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46e86: 4a92 tstl %a2@ 46e88: 6600 00b0 bnew 46f3a <rtems_io_register_driver+0x11e> 46e8c: 4aaa 0004 tstl %a2@(4) 46e90: 6600 00a8 bnew 46f3a <rtems_io_register_driver+0x11e> 46e94: 6004 bras 46e9a <rtems_io_register_driver+0x7e>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
46e96: b082 cmpl %d2,%d0
46e98: 66ec bnes 46e86 <rtems_io_register_driver+0x6a>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
46e9a: 2282 movel %d2,%a1@
if ( m != n )
46e9c: b082 cmpl %d2,%d0
46e9e: 6638 bnes 46ed8 <rtems_io_register_driver+0xbc>
46ea0: 6000 00a2 braw 46f44 <rtems_io_register_driver+0x128>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
46ea4: 2202 movel %d2,%d1 46ea6: 2002 movel %d2,%d0 46ea8: e789 lsll #3,%d1 46eaa: eb88 lsll #5,%d0 46eac: 2479 0006 282e moveal 6282e <_IO_Driver_address_table>,%a2 46eb2: 9081 subl %d1,%d0 46eb4: d5c0 addal %d0,%a2
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46eb6: 4a92 tstl %a2@
46eb8: 660c bnes 46ec6 <rtems_io_register_driver+0xaa>
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
}
rtems_status_code rtems_io_register_driver(
46eba: 4aaa 0004 tstl %a2@(4) 46ebe: 57c0 seq %d0 46ec0: 49c0 extbl %d0 46ec2: 4480 negl %d0 46ec4: 6002 bras 46ec8 <rtems_io_register_driver+0xac>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46ec6: 4280 clrl %d0
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
46ec8: 4a00 tstb %d0
46eca: 660a bnes 46ed6 <rtems_io_register_driver+0xba>
_Thread_Enable_dispatch();
46ecc: 4eb9 0004 8bc4 jsr 48bc4 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
46ed2: 700c moveq #12,%d0 46ed4: 6050 bras 46f26 <rtems_io_register_driver+0x10a>
}
*registered_major = major;
46ed6: 2282 movel %d2,%a1@
}
_IO_Driver_address_table [major] = *driver_table;
46ed8: 2202 movel %d2,%d1 46eda: 2002 movel %d2,%d0 46edc: 4878 0018 pea 18 <OPER2+0x4> 46ee0: e789 lsll #3,%d1 46ee2: eb88 lsll #5,%d0 46ee4: 2f08 movel %a0,%sp@- 46ee6: 9081 subl %d1,%d0 46ee8: d0b9 0006 282e addl 6282e <_IO_Driver_address_table>,%d0 46eee: 2f00 movel %d0,%sp@- 46ef0: 4eb9 0005 0b90 jsr 50b90 <memcpy>
_Thread_Enable_dispatch();
46ef6: 4eb9 0004 8bc4 jsr 48bc4 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
}
46efc: 246e fffc moveal %fp@(-4),%a2
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46f00: 4fef 000c lea %sp@(12),%sp 46f04: 2d42 0008 movel %d2,%fp@(8)
}
46f08: 242e fff8 movel %fp@(-8),%d2
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46f0c: 42ae 0010 clrl %fp@(16) 46f10: 42ae 000c clrl %fp@(12)
}
46f14: 4e5e unlk %fp
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46f16: 4ef9 0004 e388 jmp 4e388 <rtems_io_initialize>
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
46f1c: 7012 moveq #18,%d0 46f1e: 6006 bras 46f26 <rtems_io_register_driver+0x10a>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
46f20: 7009 moveq #9,%d0 46f22: 6002 bras 46f26 <rtems_io_register_driver+0x10a>
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
46f24: 700a moveq #10,%d0
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
46f26: 242e fff8 movel %fp@(-8),%d2 46f2a: 246e fffc moveal %fp@(-4),%a2 46f2e: 4e5e unlk %fp 46f30: 4e75 rts
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
46f32: b082 cmpl %d2,%d0
46f34: 63ee blss 46f24 <rtems_io_register_driver+0x108>
46f36: 6000 ff28 braw 46e60 <rtems_io_register_driver+0x44>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
46f3a: 5282 addql #1,%d2 46f3c: 45ea 0018 lea %a2@(24),%a2 46f40: 6000 ff54 braw 46e96 <rtems_io_register_driver+0x7a>
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
46f44: 4eb9 0004 8bc4 jsr 48bc4 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
46f4a: 7005 moveq #5,%d0
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
46f4c: 60d8 bras 46f26 <rtems_io_register_driver+0x10a>
...
00047d80 <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)
{
47d80: 4e56 fff0 linkw %fp,#-16 47d84: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 47d88: 286e 0008 moveal %fp@(8),%a4
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
47d8c: 4a8c tstl %a4
47d8e: 6738 beqs 47dc8 <rtems_iterate_over_all_threads+0x48><== NEVER TAKEN
47d90: 45f9 0006 0d38 lea 60d38 <_Objects_Information_table+0x4>,%a2
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
47d96: 205a moveal %a2@+,%a0 47d98: 2668 0004 moveal %a0@(4),%a3
if ( !information )
47d9c: 4a8b tstl %a3
47d9e: 6720 beqs 47dc0 <rtems_iterate_over_all_threads+0x40>
47da0: 7401 moveq #1,%d2 47da2: 6012 bras 47db6 <rtems_iterate_over_all_threads+0x36>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
47da4: 206b 0018 moveal %a3@(24),%a0 47da8: 2030 2c00 movel %a0@(00000000,%d2:l:4),%d0
if ( !the_thread )
47dac: 6706 beqs 47db4 <rtems_iterate_over_all_threads+0x34><== NEVER TAKEN
continue;
(*routine)(the_thread);
47dae: 2f00 movel %d0,%sp@- 47db0: 4e94 jsr %a4@ 47db2: 588f addql #4,%sp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
47db4: 5282 addql #1,%d2 47db6: 4280 clrl %d0 47db8: 302b 000e movew %a3@(14),%d0 47dbc: b082 cmpl %d2,%d0
47dbe: 64e4 bccs 47da4 <rtems_iterate_over_all_threads+0x24>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
47dc0: b5fc 0006 0d44 cmpal #396612,%a2
47dc6: 66ce bnes 47d96 <rtems_iterate_over_all_threads+0x16>
(*routine)(the_thread);
}
}
}
47dc8: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 47dce: 4e5e unlk %fp
...
0004b7bc <rtems_message_queue_delete>:
*/
rtems_status_code rtems_message_queue_delete(
rtems_id id
)
{
4b7bc: 4e56 fffc linkw %fp,#-4 4b7c0: 2f0a movel %a2,%sp@-
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
4b7c2: 486e fffc pea %fp@(-4) 4b7c6: 2f2e 0008 movel %fp@(8),%sp@- 4b7ca: 4879 0006 1688 pea 61688 <_Message_queue_Information> 4b7d0: 4eb9 0004 7a78 jsr 47a78 <_Objects_Get>
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
4b7d6: 4fef 000c lea %sp@(12),%sp 4b7da: 2440 moveal %d0,%a2 4b7dc: 4aae fffc tstl %fp@(-4)
4b7e0: 663a bnes 4b81c <rtems_message_queue_delete+0x60><== NEVER TAKEN
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
4b7e2: 2f00 movel %d0,%sp@- 4b7e4: 4879 0006 1688 pea 61688 <_Message_queue_Information> 4b7ea: 4eb9 0004 7694 jsr 47694 <_Objects_Close>
&the_message_queue->Object );
_CORE_message_queue_Close(
4b7f0: 4878 0005 pea 5 <COMPARE> 4b7f4: 42a7 clrl %sp@- 4b7f6: 486a 0014 pea %a2@(20) 4b7fa: 4eb9 0004 bd3c jsr 4bd3c <_CORE_message_queue_Close>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
4b800: 2f0a movel %a2,%sp@- 4b802: 4879 0006 1688 pea 61688 <_Message_queue_Information> 4b808: 4eb9 0004 7914 jsr 47914 <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
4b80e: 4eb9 0004 868c jsr 4868c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4b814: 4fef 001c lea %sp@(28),%sp 4b818: 4280 clrl %d0 4b81a: 6002 bras 4b81e <rtems_message_queue_delete+0x62>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4b81c: 7004 moveq #4,%d0
}
4b81e: 246e fff8 moveal %fp@(-8),%a2 4b822: 4e5e unlk %fp
...
0004f7dc <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
rtems_id id,
void **buffer
)
{
4f7dc: 4e56 fff0 linkw %fp,#-16 4f7e0: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 4f7e4: 266e 000c moveal %fp@(12),%a3
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
4f7e8: 4a8b tstl %a3
4f7ea: 6748 beqs 4f834 <rtems_partition_get_buffer+0x58><== NEVER TAKEN
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
4f7ec: 486e fffc pea %fp@(-4) 4f7f0: 2f2e 0008 movel %fp@(8),%sp@- 4f7f4: 4879 0007 69d2 pea 769d2 <_Partition_Information> 4f7fa: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
4f800: 4fef 000c lea %sp@(12),%sp 4f804: 2440 moveal %d0,%a2 4f806: 4aae fffc tstl %fp@(-4)
4f80a: 662c bnes 4f838 <rtems_partition_get_buffer+0x5c>
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
4f80c: 486a 0024 pea %a2@(36) 4f810: 4eb9 0005 24c0 jsr 524c0 <_Chain_Get>
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
4f816: 588f addql #4,%sp 4f818: 41f9 0005 4ab4 lea 54ab4 <_Thread_Enable_dispatch>,%a0 4f81e: 2400 movel %d0,%d2
4f820: 670c beqs 4f82e <rtems_partition_get_buffer+0x52>
the_partition->number_of_used_blocks += 1;
4f822: 52aa 0020 addql #1,%a2@(32)
_Thread_Enable_dispatch();
4f826: 4e90 jsr %a0@
*buffer = the_buffer;
return RTEMS_SUCCESSFUL;
4f828: 4280 clrl %d0
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
the_partition->number_of_used_blocks += 1;
_Thread_Enable_dispatch();
*buffer = the_buffer;
4f82a: 2682 movel %d2,%a3@
return RTEMS_SUCCESSFUL;
4f82c: 600c bras 4f83a <rtems_partition_get_buffer+0x5e>
}
_Thread_Enable_dispatch();
4f82e: 4e90 jsr %a0@
return RTEMS_UNSATISFIED;
4f830: 700d moveq #13,%d0 4f832: 6006 bras 4f83a <rtems_partition_get_buffer+0x5e>
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
4f834: 7009 moveq #9,%d0 4f836: 6002 bras 4f83a <rtems_partition_get_buffer+0x5e>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4f838: 7004 moveq #4,%d0
}
4f83a: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
4f840: 4e5e unlk %fp <== NOT EXECUTED
0004f870 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
4f870: 4e56 fffc linkw %fp,#-4 4f874: 2f0a movel %a2,%sp@- 4f876: 2f02 movel %d2,%sp@-
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
4f878: 486e fffc pea %fp@(-4) 4f87c: 2f2e 0008 movel %fp@(8),%sp@- 4f880: 4879 0007 69d2 pea 769d2 <_Partition_Information> 4f886: 242e 000c movel %fp@(12),%d2 4f88a: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
4f890: 4fef 000c lea %sp@(12),%sp 4f894: 2440 moveal %d0,%a2 4f896: 4aae fffc tstl %fp@(-4)
4f89a: 663e bnes 4f8da <rtems_partition_return_buffer+0x6a>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
4f89c: 202a 0010 movel %a2@(16),%d0
ending = _Addresses_Add_offset( starting, the_partition->length );
4f8a0: 222a 0014 movel %a2@(20),%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
4f8a4: b082 cmpl %d2,%d0
4f8a6: 6240 bhis 4f8e8 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
4f8a8: d280 addl %d0,%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
4f8aa: b282 cmpl %d2,%d1
4f8ac: 653a bcss 4f8e8 <rtems_partition_return_buffer+0x78><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
4f8ae: 2202 movel %d2,%d1 4f8b0: 9280 subl %d0,%d1 4f8b2: 2001 movel %d1,%d0
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
4f8b4: 4c6a 0001 0018 remul %a2@(24),%d1,%d0
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
4f8ba: 4a81 tstl %d1
4f8bc: 662a bnes 4f8e8 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
4f8be: 2f02 movel %d2,%sp@- 4f8c0: 486a 0024 pea %a2@(36) 4f8c4: 4eb9 0005 2460 jsr 52460 <_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;
4f8ca: 53aa 0020 subql #1,%a2@(32)
_Thread_Enable_dispatch();
4f8ce: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4f8d4: 508f addql #8,%sp 4f8d6: 4280 clrl %d0 4f8d8: 6002 bras 4f8dc <rtems_partition_return_buffer+0x6c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4f8da: 7004 moveq #4,%d0
}
4f8dc: 242e fff4 movel %fp@(-12),%d2 4f8e0: 246e fff8 moveal %fp@(-8),%a2 4f8e4: 4e5e unlk %fp 4f8e6: 4e75 rts
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
4f8e8: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
4f8ee: 7009 moveq #9,%d0 4f8f0: 60ea bras 4f8dc <rtems_partition_return_buffer+0x6c>
...
00046552 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
46552: 4e56 ffec linkw %fp,#-20 46556: 48d7 041c moveml %d2-%d4/%a2,%sp@
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
4655a: 486e fffc pea %fp@(-4) 4655e: 262e 0008 movel %fp@(8),%d3 46562: 2f03 movel %d3,%sp@- 46564: 4879 0006 04ac pea 604ac <_Rate_monotonic_Information> 4656a: 242e 000c movel %fp@(12),%d2 4656e: 4eb9 0004 8580 jsr 48580 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
46574: 4fef 000c lea %sp@(12),%sp 46578: 2440 moveal %d0,%a2 4657a: 4aae fffc tstl %fp@(-4) 4657e: 6600 015a bnew 466da <rtems_rate_monotonic_period+0x188>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
46582: 2039 0006 0a04 movel 60a04 <_Per_CPU_Information+0xc>,%d0 46588: b0aa 0040 cmpl %a2@(64),%d0
4658c: 670c beqs 4659a <rtems_rate_monotonic_period+0x48>
_Thread_Enable_dispatch();
4658e: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
46594: 7417 moveq #23,%d2 46596: 6000 0144 braw 466dc <rtems_rate_monotonic_period+0x18a>
}
if ( length == RTEMS_PERIOD_STATUS ) {
4659a: 4a82 tstl %d2
4659c: 6624 bnes 465c2 <rtems_rate_monotonic_period+0x70>
switch ( the_period->state ) {
4659e: 202a 0038 movel %a2@(56),%d0 465a2: 7204 moveq #4,%d1 465a4: b280 cmpl %d0,%d1
465a6: 650e bcss 465b6 <rtems_rate_monotonic_period+0x64><== NEVER TAKEN
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
465a8: 41f9 0005 db0a lea 5db0a <CSWTCH.2>,%a0 465ae: 4282 clrl %d2 465b0: 1430 0800 moveb %a0@(00000000,%d0:l),%d2 465b4: 6002 bras 465b8 <rtems_rate_monotonic_period+0x66>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
465b6: 4282 clrl %d2 <== NOT EXECUTED
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
465b8: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return( return_value );
465be: 6000 011c braw 466dc <rtems_rate_monotonic_period+0x18a>
}
_ISR_Disable( level );
465c2: 203c 0000 0700 movel #1792,%d0 465c8: 40c4 movew %sr,%d4 465ca: 8084 orl %d4,%d0 465cc: 46c0 movew %d0,%sr
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
465ce: 202a 0038 movel %a2@(56),%d0
465d2: 664a bnes 4661e <rtems_rate_monotonic_period+0xcc>
_ISR_Enable( level );
465d4: 46c4 movew %d4,%sr
the_period->next_length = length;
465d6: 2542 003c movel %d2,%a2@(60)
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
465da: 2f0a movel %a2,%sp@- 465dc: 4eb9 0004 63d6 jsr 463d6 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
465e2: 7002 moveq #2,%d0
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
465e4: 223c 0004 692c movel #289068,%d1 465ea: 2540 0038 movel %d0,%a2@(56) 465ee: 2541 002c movel %d1,%a2@(44)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
465f2: 42aa 0018 clrl %a2@(24)
the_watchdog->routine = routine; the_watchdog->id = id;
465f6: 2543 0030 movel %d3,%a2@(48)
the_watchdog->user_data = user_data;
465fa: 42aa 0034 clrl %a2@(52)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
465fe: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
46602: 486a 0010 pea %a2@(16) 46606: 4879 0006 065a pea 6065a <_Watchdog_Ticks_chain> 4660c: 4eb9 0004 9f0c jsr 49f0c <_Watchdog_Insert>
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
46612: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
46618: 4fef 000c lea %sp@(12),%sp 4661c: 606c bras 4668a <rtems_rate_monotonic_period+0x138>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
4661e: 7202 moveq #2,%d1 46620: b280 cmpl %d0,%d1
46622: 666a bnes 4668e <rtems_rate_monotonic_period+0x13c>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
46624: 2f0a movel %a2,%sp@- 46626: 4eb9 0004 6460 jsr 46460 <_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;
4662c: 7001 moveq #1,%d0
the_period->next_length = length;
4662e: 2542 003c movel %d2,%a2@(60)
/*
* 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;
46632: 2540 0038 movel %d0,%a2@(56)
the_period->next_length = length;
_ISR_Enable( level );
46636: 46c4 movew %d4,%sr
_Thread_Executing->Wait.id = the_period->Object.id;
46638: 2079 0006 0a04 moveal 60a04 <_Per_CPU_Information+0xc>,%a0 4663e: 216a 0008 0020 movel %a2@(8),%a0@(32)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
46644: 4878 4000 pea 4000 <D_MAX_EXP+0x3801> 46648: 2f08 movel %a0,%sp@- 4664a: 4eb9 0004 998c jsr 4998c <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
46650: 203c 0000 0700 movel #1792,%d0 46656: 40c1 movew %sr,%d1 46658: 8081 orl %d1,%d0 4665a: 46c0 movew %d0,%sr
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
4665c: 7402 moveq #2,%d2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
4665e: 202a 0038 movel %a2@(56),%d0
the_period->state = RATE_MONOTONIC_ACTIVE;
46662: 2542 0038 movel %d2,%a2@(56)
_ISR_Enable( level );
46666: 46c1 movew %d1,%sr
/*
* 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 )
46668: 7203 moveq #3,%d1 4666a: 4fef 000c lea %sp@(12),%sp 4666e: b280 cmpl %d0,%d1
46670: 6612 bnes 46684 <rtems_rate_monotonic_period+0x132>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
46672: 4878 4000 pea 4000 <D_MAX_EXP+0x3801> 46676: 2f39 0006 0a04 movel 60a04 <_Per_CPU_Information+0xc>,%sp@- 4667c: 4eb9 0004 8e94 jsr 48e94 <_Thread_Clear_state> 46682: 508f addql #8,%sp
_Thread_Enable_dispatch();
46684: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4668a: 4282 clrl %d2 4668c: 604e bras 466dc <rtems_rate_monotonic_period+0x18a>
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
4668e: 7204 moveq #4,%d1 46690: b280 cmpl %d0,%d1
46692: 6646 bnes 466da <rtems_rate_monotonic_period+0x188><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
46694: 2f0a movel %a2,%sp@- 46696: 4eb9 0004 6460 jsr 46460 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
4669c: 46c4 movew %d4,%sr
the_period->state = RATE_MONOTONIC_ACTIVE;
4669e: 7002 moveq #2,%d0
the_period->next_length = length;
466a0: 2542 003c movel %d2,%a2@(60)
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
466a4: 2540 0038 movel %d0,%a2@(56)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
466a8: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
466ac: 486a 0010 pea %a2@(16)
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();
return RTEMS_TIMEOUT;
466b0: 7406 moveq #6,%d2 466b2: 4879 0006 065a pea 6065a <_Watchdog_Ticks_chain> 466b8: 4eb9 0004 9f0c jsr 49f0c <_Watchdog_Insert> 466be: 2f2a 003c movel %a2@(60),%sp@- 466c2: 2f2a 0040 movel %a2@(64),%sp@- 466c6: 2079 0005 ebf2 moveal 5ebf2 <_Scheduler+0x34>,%a0 466cc: 4e90 jsr %a0@
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();
466ce: 4eb9 0004 9208 jsr 49208 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
466d4: 4fef 0014 lea %sp@(20),%sp 466d8: 6002 bras 466dc <rtems_rate_monotonic_period+0x18a>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
466da: 7404 moveq #4,%d2
}
466dc: 2002 movel %d2,%d0 466de: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
466e4: 4e5e unlk %fp <== NOT EXECUTED
0004687c <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
4687c: 4e56 0000 linkw %fp,#0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
46880: 2039 0006 05a2 movel 605a2 <_Thread_Dispatch_disable_level>,%d0 46886: 5280 addql #1,%d0 46888: 2f0a movel %a2,%sp@- 4688a: 23c0 0006 05a2 movel %d0,605a2 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
46890: 2039 0006 05a2 movel 605a2 <_Thread_Dispatch_disable_level>,%d0 46896: 2f02 movel %d2,%sp@-
/*
* 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 ;
46898: 2439 0006 04b2 movel 604b2 <_Rate_monotonic_Information+0x6>,%d2
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
4689e: 45f9 0004 68c8 lea 468c8 <rtems_rate_monotonic_reset_statistics>,%a2
/*
* 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 ;
468a4: 6008 bras 468ae <rtems_rate_monotonic_reset_all_statistics+0x32>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
468a6: 2f02 movel %d2,%sp@-
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
468a8: 5282 addql #1,%d2
(void) rtems_rate_monotonic_reset_statistics( id );
468aa: 4e92 jsr %a2@
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
468ac: 588f addql #4,%sp
/*
* 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 ;
468ae: b4b9 0006 04b6 cmpl 604b6 <_Rate_monotonic_Information+0xa>,%d2
468b4: 63f0 blss 468a6 <rtems_rate_monotonic_reset_all_statistics+0x2a>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
468b6: 242e fff8 movel %fp@(-8),%d2 468ba: 246e fffc moveal %fp@(-4),%a2 468be: 4e5e unlk %fp
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
468c0: 4ef9 0004 9208 jmp 49208 <_Thread_Enable_dispatch>
...
00050224 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
50224: 4e56 fff8 linkw %fp,#-8 50228: 2f0a movel %a2,%sp@- 5022a: 2f02 movel %d2,%sp@- 5022c: 242e 000c movel %fp@(12),%d2
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
50230: 676e beqs 502a0 <rtems_region_extend+0x7c>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
50232: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@- 50238: 4eb9 0005 23c8 jsr 523c8 <_API_Mutex_Lock>
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
5023e: 486e fffc pea %fp@(-4) 50242: 2f2e 0008 movel %fp@(8),%sp@- 50246: 4879 0007 6a46 pea 76a46 <_Region_Information> 5024c: 4eb9 0005 3df4 jsr 53df4 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
50252: 4fef 0010 lea %sp@(16),%sp 50256: 2440 moveal %d0,%a2 50258: 4aae fffc tstl %fp@(-4)
5025c: 662c bnes 5028a <rtems_region_extend+0x66>
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
5025e: 486e fff8 pea %fp@(-8) 50262: 2f2e 0010 movel %fp@(16),%sp@- 50266: 2f02 movel %d2,%sp@- 50268: 486a 0068 pea %a2@(104) 5026c: 4eb9 0005 3050 jsr 53050 <_Heap_Extend>
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
50272: 4fef 0010 lea %sp@(16),%sp 50276: 4a00 tstb %d0
50278: 6714 beqs 5028e <rtems_region_extend+0x6a> <== ALWAYS TAKEN
the_region->length += amount_extended;
5027a: 202e fff8 movel %fp@(-8),%d0 <== NOT EXECUTED 5027e: d1aa 0054 addl %d0,%a2@(84) <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
50282: 4282 clrl %d2 <== NOT EXECUTED
&amount_extended
);
if ( extend_ok ) {
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
50284: d1aa 005c addl %d0,%a2@(92) <== NOT EXECUTED 50288: 6006 bras 50290 <rtems_region_extend+0x6c> <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
5028a: 7404 moveq #4,%d2 5028c: 6002 bras 50290 <rtems_region_extend+0x6c>
if ( extend_ok ) {
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
} else {
return_status = RTEMS_INVALID_ADDRESS;
5028e: 7409 moveq #9,%d2
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
50290: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@- 50296: 4eb9 0005 2428 jsr 52428 <_API_Mutex_Unlock>
return return_status;
5029c: 588f addql #4,%sp 5029e: 6002 bras 502a2 <rtems_region_extend+0x7e>
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
502a0: 7409 moveq #9,%d2
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
502a2: 2002 movel %d2,%d0 502a4: 242e fff0 movel %fp@(-16),%d2 502a8: 246e fff4 moveal %fp@(-12),%a2
502ac: 4e5e unlk %fp <== NOT EXECUTED
000504a8 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
504a8: 4e56 fffc linkw %fp,#-4 504ac: 2f03 movel %d3,%sp@- 504ae: 262e 0010 movel %fp@(16),%d3 504b2: 2f02 movel %d2,%sp@- 504b4: 242e 000c movel %fp@(12),%d2
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
504b8: 6768 beqs 50522 <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
if ( !size )
504ba: 4a83 tstl %d3
504bc: 6764 beqs 50522 <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
504be: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@- 504c4: 4eb9 0005 23c8 jsr 523c8 <_API_Mutex_Lock> 504ca: 486e fffc pea %fp@(-4) 504ce: 2f2e 0008 movel %fp@(8),%sp@- 504d2: 4879 0007 6a46 pea 76a46 <_Region_Information> 504d8: 4eb9 0005 3df4 jsr 53df4 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
504de: 222e fffc movel %fp@(-4),%d1 504e2: 4fef 0010 lea %sp@(16),%sp
504e6: 6708 beqs 504f0 <rtems_region_get_segment_size+0x48>
504e8: 7001 moveq #1,%d0 504ea: b081 cmpl %d1,%d0
504ec: 661a bnes 50508 <rtems_region_get_segment_size+0x60><== NEVER TAKEN
504ee: 601c bras 5050c <rtems_region_get_segment_size+0x64>
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
504f0: 2f03 movel %d3,%sp@- 504f2: 2040 moveal %d0,%a0 504f4: 2f02 movel %d2,%sp@- 504f6: 4868 0068 pea %a0@(104) 504fa: 4eb9 0005 3860 jsr 53860 <_Heap_Size_of_alloc_area> 50500: 4fef 000c lea %sp@(12),%sp 50504: 4a00 tstb %d0
50506: 6708 beqs 50510 <rtems_region_get_segment_size+0x68><== NEVER TAKEN
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
50508: 4282 clrl %d2 5050a: 6006 bras 50512 <rtems_region_get_segment_size+0x6a>
case OBJECTS_REMOTE: /* this error cannot be returned */
break;
#endif
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
5050c: 7404 moveq #4,%d2 5050e: 6002 bras 50512 <rtems_region_get_segment_size+0x6a>
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
return_status = RTEMS_INVALID_ADDRESS;
50510: 7409 moveq #9,%d2 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
50512: 2f39 0007 6bdc movel 76bdc <_RTEMS_Allocator_Mutex>,%sp@- 50518: 4eb9 0005 2428 jsr 52428 <_API_Mutex_Unlock>
return return_status;
5051e: 588f addql #4,%sp 50520: 6002 bras 50524 <rtems_region_get_segment_size+0x7c>
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
50522: 7409 moveq #9,%d2
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
50524: 2002 movel %d2,%d0 50526: 242e fff4 movel %fp@(-12),%d2 5052a: 262e fff8 movel %fp@(-8),%d3 5052e: 4e5e unlk %fp
...
00046030 <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
46030: 7003 moveq #3,%d0
*/
void rtems_shutdown_executive(
uint32_t result
)
{
46032: 4e56 0000 linkw %fp,#0
if ( _System_state_Is_up( _System_state_Get() ) ) {
46036: b0b9 0005 ecdc cmpl 5ecdc <_System_state_Current>,%d0
4603c: 6624 bnes 46062 <rtems_shutdown_executive+0x32>
#if defined(RTEMS_SMP)
_SMP_Request_other_cores_to_shutdown();
#endif
_Per_CPU_Information[0].idle->Wait.return_code = result;
4603e: 2079 0005 f002 moveal 5f002 <_Per_CPU_Information+0x14>,%a0 46044: 103c 0004 moveb #4,%d0 46048: 216e 0008 0034 movel %fp@(8),%a0@(52)
* if we were running within the same context, it would work. * * And we will not return to this thread, so there is no point of * saving the context. */ _Context_Restart_self( &_Thread_BSP_context );
4604e: 4879 0005 eb64 pea 5eb64 <_Thread_BSP_context> 46054: 23c0 0005 ecdc movel %d0,5ecdc <_System_state_Current> 4605a: 4eb9 0004 8c92 jsr 48c92 <_CPU_Context_Restart_self>
46060: 588f addql #4,%sp <== NOT EXECUTED
****** AND THEN TO BOOT_CARD() ******
*******************************************************************
*******************************************************************
*******************************************************************/
}
_Internal_error_Occurred(
46062: 4878 0014 pea 14 <OPER2> 46066: 4878 0001 pea 1 <ADD> 4606a: 42a7 clrl %sp@- 4606c: 4eb9 0004 6bdc jsr 46bdc <_Internal_error_Occurred>
...
00050b0c <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
50b0c: 4e56 fffc linkw %fp,#-4 50b10: 2f03 movel %d3,%sp@- 50b12: 2f02 movel %d2,%sp@- 50b14: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
50b18: 6776 beqs 50b90 <rtems_signal_send+0x84>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
50b1a: 486e fffc pea %fp@(-4) 50b1e: 2f2e 0008 movel %fp@(8),%sp@- 50b22: 4eb9 0005 4adc jsr 54adc <_Thread_Get>
switch ( location ) {
50b28: 508f addql #8,%sp 50b2a: 4aae fffc tstl %fp@(-4)
50b2e: 6664 bnes 50b94 <rtems_signal_send+0x88>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
50b30: 2240 moveal %d0,%a1 50b32: 2069 00fe moveal %a1@(254),%a0
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
50b36: 4aa8 000a tstl %a0@(10)
50b3a: 674a beqs 50b86 <rtems_signal_send+0x7a>
50b3c: 223c 0000 0700 movel #1792,%d1
if ( asr->is_enabled ) {
50b42: 4a28 0008 tstb %a0@(8)
50b46: 6726 beqs 50b6e <rtems_signal_send+0x62>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
50b48: 40c3 movew %sr,%d3 50b4a: 8283 orl %d3,%d1 50b4c: 46c1 movew %d1,%sr
*signal_set |= signals;
50b4e: 85a8 0012 orl %d2,%a0@(18)
_ISR_Enable( _level );
50b52: 46c3 movew %d3,%sr
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
50b54: 4ab9 0007 6fa2 tstl 76fa2 <_Per_CPU_Information+0x8>
50b5a: 6720 beqs 50b7c <rtems_signal_send+0x70>
50b5c: b0b9 0007 6fa6 cmpl 76fa6 <_Per_CPU_Information+0xc>,%d0
50b62: 6618 bnes 50b7c <rtems_signal_send+0x70> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
50b64: 7001 moveq #1,%d0 50b66: 13c0 0007 6fb2 moveb %d0,76fb2 <_Per_CPU_Information+0x18> 50b6c: 600e bras 50b7c <rtems_signal_send+0x70>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
50b6e: 2001 movel %d1,%d0 50b70: 40c1 movew %sr,%d1 50b72: 8081 orl %d1,%d0 50b74: 46c0 movew %d0,%sr
*signal_set |= signals;
50b76: 85a8 0016 orl %d2,%a0@(22)
_ISR_Enable( _level );
50b7a: 46c1 movew %d1,%sr
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
50b7c: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
50b82: 4280 clrl %d0 50b84: 6010 bras 50b96 <rtems_signal_send+0x8a>
}
_Thread_Enable_dispatch();
50b86: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
50b8c: 700b moveq #11,%d0 50b8e: 6006 bras 50b96 <rtems_signal_send+0x8a>
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
50b90: 700a moveq #10,%d0 50b92: 6002 bras 50b96 <rtems_signal_send+0x8a>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
50b94: 7004 moveq #4,%d0
}
50b96: 242e fff4 movel %fp@(-12),%d2 50b9a: 262e fff8 movel %fp@(-8),%d3 50b9e: 4e5e unlk %fp
...
0004c8ec <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
4c8ec: 4e56 ffe4 linkw %fp,#-28 4c8f0: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@ 4c8f4: 262e 0008 movel %fp@(8),%d3 4c8f8: 282e 000c movel %fp@(12),%d4 4c8fc: 286e 0010 moveal %fp@(16),%a4
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
4c900: 4a8c tstl %a4 4c902: 6700 0104 beqw 4ca08 <rtems_task_mode+0x11c>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
4c906: 2679 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a3
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4c90c: 4a2b 0074 tstb %a3@(116) 4c910: 57c2 seq %d2
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4c912: 246b 00fe moveal %a3@(254),%a2
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4c916: 49c2 extbl %d2 4c918: 0282 0000 0100 andil #256,%d2
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4c91e: 4aab 007a tstl %a3@(122)
4c922: 6704 beqs 4c928 <rtems_task_mode+0x3c>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
4c924: 08c2 0009 bset #9,%d2
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4c928: 4a2a 0008 tstb %a2@(8) 4c92c: 57c5 seq %d5
old_mode |= _ISR_Get_level();
4c92e: 4eb9 0004 8d38 jsr 48d38 <_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;
4c934: 49c5 extbl %d5 4c936: 0285 0000 0400 andil #1024,%d5 4c93c: 8085 orl %d5,%d0
old_mode |= _ISR_Get_level();
4c93e: 8082 orl %d2,%d0 4c940: 2880 movel %d0,%a4@
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
4c942: 0804 0008 btst #8,%d4
4c946: 670c beqs 4c954 <rtems_task_mode+0x68>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
4c948: 0803 0008 btst #8,%d3 4c94c: 57c0 seq %d0 4c94e: 4480 negl %d0 4c950: 1740 0074 moveb %d0,%a3@(116)
if ( mask & RTEMS_TIMESLICE_MASK ) {
4c954: 0804 0009 btst #9,%d4
4c958: 671c beqs 4c976 <rtems_task_mode+0x8a>
if ( _Modes_Is_timeslice(mode_set) ) {
4c95a: 0803 0009 btst #9,%d3
4c95e: 6712 beqs 4c972 <rtems_task_mode+0x86>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4c960: 41f9 0005 eb50 lea 5eb50 <_Thread_Ticks_per_timeslice>,%a0
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;
4c966: 7001 moveq #1,%d0
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4c968: 2750 0076 movel %a0@,%a3@(118)
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;
4c96c: 2740 007a movel %d0,%a3@(122) 4c970: 6004 bras 4c976 <rtems_task_mode+0x8a>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4c972: 42ab 007a clrl %a3@(122)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
4c976: 7007 moveq #7,%d0 4c978: c084 andl %d4,%d0
4c97a: 6712 beqs 4c98e <rtems_task_mode+0xa2>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
4c97c: 40c0 movew %sr,%d0
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
4c97e: 7207 moveq #7,%d1 4c980: c283 andl %d3,%d1
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
4c982: 0280 0000 f8ff andil #63743,%d0 4c988: e189 lsll #8,%d1 4c98a: 8081 orl %d1,%d0 4c98c: 46c0 movew %d0,%sr
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
4c98e: 0804 000a btst #10,%d4
4c992: 6740 beqs 4c9d4 <rtems_task_mode+0xe8>
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
4c994: 4281 clrl %d1 4c996: 122a 0008 moveb %a2@(8),%d1 4c99a: 4282 clrl %d2
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
4c99c: 0803 000a btst #10,%d3 4c9a0: 57c0 seq %d0 4c9a2: 4480 negl %d0
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 ) {
4c9a4: 1400 moveb %d0,%d2 4c9a6: b282 cmpl %d2,%d1
4c9a8: 672a beqs 4c9d4 <rtems_task_mode+0xe8>
asr->is_enabled = is_asr_enabled;
4c9aa: 1540 0008 moveb %d0,%a2@(8)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
4c9ae: 203c 0000 0700 movel #1792,%d0 4c9b4: 40c1 movew %sr,%d1 4c9b6: 8081 orl %d1,%d0 4c9b8: 46c0 movew %d0,%sr
_signals = information->signals_pending;
4c9ba: 202a 0016 movel %a2@(22),%d0
information->signals_pending = information->signals_posted;
4c9be: 256a 0012 0016 movel %a2@(18),%a2@(22)
information->signals_posted = _signals;
4c9c4: 2540 0012 movel %d0,%a2@(18)
_ISR_Enable( _level );
4c9c8: 46c1 movew %d1,%sr
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
4c9ca: 4aaa 0012 tstl %a2@(18) 4c9ce: 56c0 sne %d0 4c9d0: 4480 negl %d0 4c9d2: 6002 bras 4c9d6 <rtems_task_mode+0xea> 4c9d4: 4200 clrb %d0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
4c9d6: 7203 moveq #3,%d1 4c9d8: b2b9 0005 ecdc cmpl 5ecdc <_System_state_Current>,%d1
4c9de: 662c bnes 4ca0c <rtems_task_mode+0x120>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
4c9e0: 2079 0005 effa moveal 5effa <_Per_CPU_Information+0xc>,%a0
if ( are_signals_pending ||
4c9e6: 4a00 tstb %d0
4c9e8: 660e bnes 4c9f8 <rtems_task_mode+0x10c>
4c9ea: b1f9 0005 effe cmpal 5effe <_Per_CPU_Information+0x10>,%a0
4c9f0: 671a beqs 4ca0c <rtems_task_mode+0x120>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
4c9f2: 4a28 0074 tstb %a0@(116)
4c9f6: 6714 beqs 4ca0c <rtems_task_mode+0x120> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
4c9f8: 7001 moveq #1,%d0 4c9fa: 13c0 0005 f006 moveb %d0,5f006 <_Per_CPU_Information+0x18>
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
4ca00: 4eb9 0004 7c28 jsr 47c28 <_Thread_Dispatch> 4ca06: 6004 bras 4ca0c <rtems_task_mode+0x120>
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
4ca08: 7009 moveq #9,%d0 4ca0a: 6002 bras 4ca0e <rtems_task_mode+0x122>
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
4ca0c: 4280 clrl %d0
}
4ca0e: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
4ca14: 4e5e unlk %fp <== NOT EXECUTED
00049500 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
49500: 4e56 fffc linkw %fp,#-4 49504: 2f0a movel %a2,%sp@- 49506: 246e 0010 moveal %fp@(16),%a2 4950a: 2f02 movel %d2,%sp@- 4950c: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
49510: 670c beqs 4951e <rtems_task_set_priority+0x1e>
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 ) );
49512: 4280 clrl %d0 49514: 1039 0006 085a moveb 6085a <rtems_maximum_priority>,%d0 4951a: b082 cmpl %d2,%d0
4951c: 654e bcss 4956c <rtems_task_set_priority+0x6c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
4951e: 4a8a tstl %a2
49520: 674e beqs 49570 <rtems_task_set_priority+0x70>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
49522: 486e fffc pea %fp@(-4) 49526: 2f2e 0008 movel %fp@(8),%sp@- 4952a: 4eb9 0004 b68c jsr 4b68c <_Thread_Get>
switch ( location ) {
49530: 508f addql #8,%sp
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
49532: 2040 moveal %d0,%a0
switch ( location ) {
49534: 4aae fffc tstl %fp@(-4)
49538: 663a bnes 49574 <rtems_task_set_priority+0x74>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
4953a: 24a8 0014 movel %a0@(20),%a2@
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4953e: 4a82 tstl %d2
49540: 6720 beqs 49562 <rtems_task_set_priority+0x62>
the_thread->real_priority = new_priority;
49542: 2142 0018 movel %d2,%a0@(24)
if ( the_thread->resource_count == 0 ||
49546: 4aa8 001c tstl %a0@(28)
4954a: 6706 beqs 49552 <rtems_task_set_priority+0x52>
4954c: b4a8 0014 cmpl %a0@(20),%d2
49550: 6410 bccs 49562 <rtems_task_set_priority+0x62> <== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
49552: 42a7 clrl %sp@- 49554: 2f02 movel %d2,%sp@- 49556: 2f08 movel %a0,%sp@- 49558: 4eb9 0004 b214 jsr 4b214 <_Thread_Change_priority> 4955e: 4fef 000c lea %sp@(12),%sp
}
_Thread_Enable_dispatch();
49562: 4eb9 0004 b664 jsr 4b664 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
49568: 4280 clrl %d0 4956a: 600a bras 49576 <rtems_task_set_priority+0x76>
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
4956c: 7013 moveq #19,%d0 4956e: 6006 bras 49576 <rtems_task_set_priority+0x76>
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
49570: 7009 moveq #9,%d0 49572: 6002 bras 49576 <rtems_task_set_priority+0x76>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
49574: 7004 moveq #4,%d0
}
49576: 242e fff4 movel %fp@(-12),%d2 4957a: 246e fff8 moveal %fp@(-8),%a2 4957e: 4e5e unlk %fp
...
00051390 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
51390: 4e56 fffc linkw %fp,#-4
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
51394: 486e fffc pea %fp@(-4) 51398: 2f2e 0008 movel %fp@(8),%sp@- 5139c: 4879 0007 73be pea 773be <_Timer_Information> 513a2: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
513a8: 4fef 000c lea %sp@(12),%sp 513ac: 4aae fffc tstl %fp@(-4)
513b0: 6620 bnes 513d2 <rtems_timer_cancel+0x42>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
513b2: 7204 moveq #4,%d1 513b4: 2040 moveal %d0,%a0 513b6: b2a8 0038 cmpl %a0@(56),%d1
513ba: 670c beqs 513c8 <rtems_timer_cancel+0x38> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
513bc: 4868 0010 pea %a0@(16) 513c0: 4eb9 0005 5a1c jsr 55a1c <_Watchdog_Remove> 513c6: 588f addql #4,%sp
_Thread_Enable_dispatch();
513c8: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
513ce: 4280 clrl %d0 513d0: 6002 bras 513d4 <rtems_timer_cancel+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
513d2: 7004 moveq #4,%d0
}
513d4: 4e5e unlk %fp <== NOT EXECUTED
00045ee4 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
45ee4: 4e56 0000 linkw %fp,#0 45ee8: 2f0a movel %a2,%sp@- 45eea: 246e 000c moveal %fp@(12),%a2 45eee: 2f02 movel %d2,%sp@- 45ef0: 242e 0008 movel %fp@(8),%d2
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
45ef4: 676e beqs 45f64 <rtems_timer_create+0x80> <== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
45ef6: 4a8a tstl %a2
45ef8: 676e beqs 45f68 <rtems_timer_create+0x84> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45efa: 2039 0005 ec1a movel 5ec1a <_Thread_Dispatch_disable_level>,%d0 45f00: 5280 addql #1,%d0 45f02: 23c0 0005 ec1a movel %d0,5ec1a <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45f08: 2039 0005 ec1a movel 5ec1a <_Thread_Dispatch_disable_level>,%d0
* 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 );
45f0e: 4879 0005 f45c pea 5f45c <_Timer_Information> 45f14: 4eb9 0004 6d84 jsr 46d84 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
45f1a: 588f addql #4,%sp 45f1c: 2040 moveal %d0,%a0 45f1e: 4a80 tstl %d0
45f20: 660a bnes 45f2c <rtems_timer_create+0x48>
_Thread_Enable_dispatch();
45f22: 4eb9 0004 7df8 jsr 47df8 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
45f28: 7005 moveq #5,%d0 45f2a: 603e bras 45f6a <rtems_timer_create+0x86>
}
the_timer->the_class = TIMER_DORMANT;
45f2c: 7004 moveq #4,%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45f2e: 4281 clrl %d1 45f30: 2140 0038 movel %d0,%a0@(56)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
45f34: 2028 0008 movel %a0@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
45f38: 2279 0005 f474 moveal 5f474 <_Timer_Information+0x18>,%a1 45f3e: 3200 movew %d0,%d1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
45f40: 42a8 0018 clrl %a0@(24)
the_watchdog->routine = routine;
45f44: 42a8 002c clrl %a0@(44)
the_watchdog->id = id;
45f48: 42a8 0030 clrl %a0@(48)
the_watchdog->user_data = user_data;
45f4c: 42a8 0034 clrl %a0@(52) 45f50: 2388 1c00 movel %a0,%a1@(00000000,%d1:l:4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
45f54: 2142 000c movel %d2,%a0@(12)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
45f58: 2480 movel %d0,%a2@
_Thread_Enable_dispatch();
45f5a: 4eb9 0004 7df8 jsr 47df8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
45f60: 4280 clrl %d0 45f62: 6006 bras 45f6a <rtems_timer_create+0x86>
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
45f64: 7003 moveq #3,%d0 45f66: 6002 bras 45f6a <rtems_timer_create+0x86>
if ( !id )
return RTEMS_INVALID_ADDRESS;
45f68: 7009 moveq #9,%d0
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
45f6a: 242e fff8 movel %fp@(-8),%d2 45f6e: 246e fffc moveal %fp@(-4),%a2 45f72: 4e5e unlk %fp
...
0005176c <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
5176c: 4e56 ffe8 linkw %fp,#-24 51770: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 51774: 262e 0008 movel %fp@(8),%d3 51778: 242e 000c movel %fp@(12),%d2 5177c: 282e 0010 movel %fp@(16),%d4
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
51780: 2679 0007 73f8 moveal 773f8 <_Timer_server>,%a3
if ( !timer_server )
51786: 4a8b tstl %a3 51788: 6700 0088 beqw 51812 <rtems_timer_server_fire_after+0xa6>
return RTEMS_INCORRECT_STATE;
if ( !routine )
5178c: 4a84 tstl %d4 5178e: 6700 0086 beqw 51816 <rtems_timer_server_fire_after+0xaa>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
51792: 4a82 tstl %d2 51794: 6700 0084 beqw 5181a <rtems_timer_server_fire_after+0xae> 51798: 486e fffc pea %fp@(-4) 5179c: 2f03 movel %d3,%sp@- 5179e: 4879 0007 73be pea 773be <_Timer_Information> 517a4: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
517aa: 4fef 000c lea %sp@(12),%sp 517ae: 2440 moveal %d0,%a2 517b0: 4aae fffc tstl %fp@(-4)
517b4: 6668 bnes 5181e <rtems_timer_server_fire_after+0xb2><== NEVER TAKEN
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
517b6: 486a 0010 pea %a2@(16) 517ba: 4eb9 0005 5a1c jsr 55a1c <_Watchdog_Remove>
_ISR_Disable( level );
517c0: 203c 0000 0700 movel #1792,%d0 517c6: 40c1 movew %sr,%d1 517c8: 8081 orl %d1,%d0 517ca: 46c0 movew %d0,%sr
/*
* 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 ) {
517cc: 588f addql #4,%sp 517ce: 4aaa 0018 tstl %a2@(24)
517d2: 670a beqs 517de <rtems_timer_server_fire_after+0x72>
_ISR_Enable( level );
517d4: 46c1 movew %d1,%sr
_Thread_Enable_dispatch();
517d6: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch> 517dc: 6030 bras 5180e <rtems_timer_server_fire_after+0xa2>
/*
* 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;
517de: 7001 moveq #1,%d0
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
517e0: 256e 0014 0034 movel %fp@(20),%a2@(52) 517e6: 2540 0038 movel %d0,%a2@(56)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
517ea: 42aa 0018 clrl %a2@(24)
the_watchdog->routine = routine;
517ee: 2544 002c movel %d4,%a2@(44)
the_watchdog->id = id;
517f2: 2543 0030 movel %d3,%a2@(48)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
517f6: 2542 001c movel %d2,%a2@(28)
_ISR_Enable( level );
517fa: 46c1 movew %d1,%sr
(*timer_server->schedule_operation)( timer_server, the_timer );
517fc: 2f0a movel %a2,%sp@- 517fe: 2f0b movel %a3,%sp@- 51800: 206b 0004 moveal %a3@(4),%a0 51804: 4e90 jsr %a0@
_Thread_Enable_dispatch();
51806: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
5180c: 508f addql #8,%sp 5180e: 4280 clrl %d0 51810: 600e bras 51820 <rtems_timer_server_fire_after+0xb4>
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
51812: 700e moveq #14,%d0 51814: 600a bras 51820 <rtems_timer_server_fire_after+0xb4>
if ( !routine )
return RTEMS_INVALID_ADDRESS;
51816: 7009 moveq #9,%d0 51818: 6006 bras 51820 <rtems_timer_server_fire_after+0xb4>
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
5181a: 700a moveq #10,%d0 5181c: 6002 bras 51820 <rtems_timer_server_fire_after+0xb4>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
5181e: 7004 moveq #4,%d0
}
51820: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3 51826: 4e5e unlk %fp
...
0005182c <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
5182c: 4e56 ffe8 linkw %fp,#-24 51830: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 51834: 262e 0008 movel %fp@(8),%d3 51838: 242e 000c movel %fp@(12),%d2 5183c: 282e 0010 movel %fp@(16),%d4
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
51840: 2679 0007 73f8 moveal 773f8 <_Timer_server>,%a3
if ( !timer_server )
51846: 4a8b tstl %a3 51848: 6700 0098 beqw 518e2 <rtems_timer_server_fire_when+0xb6>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
5184c: 4a39 0007 6b4c tstb 76b4c <_TOD_Is_set> 51852: 6700 0092 beqw 518e6 <rtems_timer_server_fire_when+0xba>
return RTEMS_NOT_DEFINED;
if ( !routine )
51856: 4a84 tstl %d4 51858: 6700 0090 beqw 518ea <rtems_timer_server_fire_when+0xbe>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
5185c: 2f02 movel %d2,%sp@- 5185e: 4eb9 0004 ec6c jsr 4ec6c <_TOD_Validate> 51864: 588f addql #4,%sp 51866: 4a00 tstb %d0 51868: 6700 0084 beqw 518ee <rtems_timer_server_fire_when+0xc2>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
5186c: 2f02 movel %d2,%sp@- 5186e: 4eb9 0004 ebd4 jsr 4ebd4 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
51874: 588f addql #4,%sp
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
51876: 2400 movel %d0,%d2
if ( seconds <= _TOD_Seconds_since_epoch() )
51878: b0b9 0007 6bc6 cmpl 76bc6 <_TOD_Now>,%d0
5187e: 636e blss 518ee <rtems_timer_server_fire_when+0xc2>
51880: 486e fffc pea %fp@(-4) 51884: 2f03 movel %d3,%sp@- 51886: 4879 0007 73be pea 773be <_Timer_Information> 5188c: 4eb9 0005 3e2c jsr 53e2c <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
51892: 4fef 000c lea %sp@(12),%sp 51896: 2440 moveal %d0,%a2 51898: 4aae fffc tstl %fp@(-4)
5189c: 6654 bnes 518f2 <rtems_timer_server_fire_when+0xc6>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
5189e: 486a 0010 pea %a2@(16) 518a2: 4eb9 0005 5a1c jsr 55a1c <_Watchdog_Remove>
the_watchdog->user_data = user_data;
518a8: 256e 0014 0034 movel %fp@(20),%a2@(52)
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();
518ae: 94b9 0007 6bc6 subl 76bc6 <_TOD_Now>,%d2
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
518b4: 7003 moveq #3,%d0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
518b6: 42aa 0018 clrl %a2@(24) 518ba: 2540 0038 movel %d0,%a2@(56)
the_watchdog->routine = routine;
518be: 2544 002c movel %d4,%a2@(44)
the_watchdog->id = id;
518c2: 2543 0030 movel %d3,%a2@(48)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
518c6: 2542 001c movel %d2,%a2@(28)
(*timer_server->schedule_operation)( timer_server, the_timer );
518ca: 2f0a movel %a2,%sp@- 518cc: 2f0b movel %a3,%sp@- 518ce: 206b 0004 moveal %a3@(4),%a0 518d2: 4e90 jsr %a0@
_Thread_Enable_dispatch();
518d4: 4eb9 0005 4ab4 jsr 54ab4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
518da: 4fef 000c lea %sp@(12),%sp 518de: 4280 clrl %d0 518e0: 6012 bras 518f4 <rtems_timer_server_fire_when+0xc8>
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
518e2: 700e moveq #14,%d0 518e4: 600e bras 518f4 <rtems_timer_server_fire_when+0xc8>
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
518e6: 700b moveq #11,%d0 <== NOT EXECUTED 518e8: 600a bras 518f4 <rtems_timer_server_fire_when+0xc8><== NOT EXECUTED
if ( !routine )
return RTEMS_INVALID_ADDRESS;
518ea: 7009 moveq #9,%d0 518ec: 6006 bras 518f4 <rtems_timer_server_fire_when+0xc8>
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
518ee: 7014 moveq #20,%d0 518f0: 6002 bras 518f4 <rtems_timer_server_fire_when+0xc8>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
518f2: 7004 moveq #4,%d0
}
518f4: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3 518fa: 4e5e unlk %fp
...
00046018 <sched_get_priority_max>:
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
46018: 7004 moveq #4,%d0
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
4601a: 4e56 0000 linkw %fp,#0 4601e: 222e 0008 movel %fp@(8),%d1
switch ( policy ) {
46022: b081 cmpl %d1,%d0
46024: 650c bcss 46032 <sched_get_priority_max+0x1a>
46026: 103c 0001 moveb #1,%d0 4602a: e3a8 lsll %d1,%d0 4602c: 7217 moveq #23,%d1 4602e: c081 andl %d1,%d0
46030: 6610 bnes 46042 <sched_get_priority_max+0x2a> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
46032: 4eb9 0004 d750 jsr 4d750 <__errno> 46038: 2040 moveal %d0,%a0 4603a: 7016 moveq #22,%d0 4603c: 2080 movel %d0,%a0@ 4603e: 70ff moveq #-1,%d0 46040: 600a bras 4604c <sched_get_priority_max+0x34>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
46042: 4280 clrl %d0 46044: 1039 0005 dfea moveb 5dfea <rtems_maximum_priority>,%d0 4604a: 5380 subql #1,%d0
}
4604c: 4e5e unlk %fp <== NOT EXECUTED
00046050 <sched_get_priority_min>:
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
46050: 7004 moveq #4,%d0
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
46052: 4e56 0000 linkw %fp,#0 46056: 222e 0008 movel %fp@(8),%d1
switch ( policy ) {
4605a: b081 cmpl %d1,%d0
4605c: 650c bcss 4606a <sched_get_priority_min+0x1a>
4605e: 103c 0001 moveb #1,%d0 46062: e3a8 lsll %d1,%d0 46064: 7217 moveq #23,%d1 46066: c081 andl %d1,%d0
46068: 6610 bnes 4607a <sched_get_priority_min+0x2a> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
4606a: 4eb9 0004 d750 jsr 4d750 <__errno> 46070: 2040 moveal %d0,%a0 46072: 7016 moveq #22,%d0 46074: 2080 movel %d0,%a0@ 46076: 70ff moveq #-1,%d0 46078: 6002 bras 4607c <sched_get_priority_min+0x2c>
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
4607a: 7001 moveq #1,%d0
}
4607c: 4e5e unlk %fp <== NOT EXECUTED
00046080 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
46080: 4e56 0000 linkw %fp,#0 46084: 2f03 movel %d3,%sp@- 46086: 262e 0008 movel %fp@(8),%d3 4608a: 2f02 movel %d2,%sp@- 4608c: 242e 000c movel %fp@(12),%d2
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
46090: 4a83 tstl %d3
46092: 6718 beqs 460ac <sched_rr_get_interval+0x2c> <== NEVER TAKEN
46094: 4eb9 0004 30a4 jsr 430a4 <getpid> 4609a: b083 cmpl %d3,%d0
4609c: 670e beqs 460ac <sched_rr_get_interval+0x2c>
rtems_set_errno_and_return_minus_one( ESRCH );
4609e: 4eb9 0004 d750 jsr 4d750 <__errno> 460a4: 7203 moveq #3,%d1 460a6: 2040 moveal %d0,%a0 460a8: 2081 movel %d1,%a0@ 460aa: 6010 bras 460bc <sched_rr_get_interval+0x3c>
if ( !interval )
460ac: 4a82 tstl %d2
460ae: 6610 bnes 460c0 <sched_rr_get_interval+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
460b0: 4eb9 0004 d750 jsr 4d750 <__errno> 460b6: 2040 moveal %d0,%a0 460b8: 7016 moveq #22,%d0 460ba: 2080 movel %d0,%a0@ 460bc: 70ff moveq #-1,%d0 460be: 6012 bras 460d2 <sched_rr_get_interval+0x52>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
460c0: 2f02 movel %d2,%sp@- 460c2: 2f39 0005 f940 movel 5f940 <_Thread_Ticks_per_timeslice>,%sp@- 460c8: 4eb9 0004 9434 jsr 49434 <_Timespec_From_ticks>
return 0;
460ce: 508f addql #8,%sp 460d0: 4280 clrl %d0
}
460d2: 242e fff8 movel %fp@(-8),%d2 460d6: 262e fffc movel %fp@(-4),%d3 460da: 4e5e unlk %fp
...
000485f4 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
485f4: 4e56 ffdc linkw %fp,#-36
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
485f8: 2039 0006 38b4 movel 638b4 <_Thread_Dispatch_disable_level>,%d0 485fe: 5280 addql #1,%d0 48600: 48d7 047c moveml %d2-%d6/%a2,%sp@ 48604: 23c0 0006 38b4 movel %d0,638b4 <_Thread_Dispatch_disable_level> 4860a: 262e 0008 movel %fp@(8),%d3 4860e: 2a2e 000c movel %fp@(12),%d5
return _Thread_Dispatch_disable_level;
48612: 2039 0006 38b4 movel 638b4 <_Thread_Dispatch_disable_level>,%d0
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
48618: 2c05 movel %d5,%d6 4861a: 0286 0000 0200 andil #512,%d6
48620: 6706 beqs 48628 <sem_open+0x34>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
48622: 282e 0014 movel %fp@(20),%d4 48626: 6002 bras 4862a <sem_open+0x36>
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
48628: 4284 clrl %d4
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
4862a: 45ee fff4 lea %fp@(-12),%a2 4862e: 2f0a movel %a2,%sp@- 48630: 2f03 movel %d3,%sp@- 48632: 4eb9 0004 e208 jsr 4e208 <_POSIX_Semaphore_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 ) {
48638: 508f addql #8,%sp
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
4863a: 2400 movel %d0,%d2
* 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 ) {
4863c: 671c beqs 4865a <sem_open+0x66>
/*
* 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) ) ) {
4863e: 7002 moveq #2,%d0 48640: b082 cmpl %d2,%d0
48642: 6604 bnes 48648 <sem_open+0x54> <== NEVER TAKEN
48644: 4a86 tstl %d6
48646: 6660 bnes 486a8 <sem_open+0xb4>
_Thread_Enable_dispatch();
48648: 4eb9 0004 b1bc jsr 4b1bc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
4864e: 4eb9 0005 09d0 jsr 509d0 <__errno> 48654: 2040 moveal %d0,%a0 48656: 2082 movel %d2,%a0@ 48658: 6078 bras 486d2 <sem_open+0xde>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
4865a: 0285 0000 0a00 andil #2560,%d5 48660: 0c85 0000 0a00 cmpil #2560,%d5
48666: 6614 bnes 4867c <sem_open+0x88>
_Thread_Enable_dispatch();
48668: 4eb9 0004 b1bc jsr 4b1bc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
4866e: 4eb9 0005 09d0 jsr 509d0 <__errno> 48674: 2040 moveal %d0,%a0 48676: 7011 moveq #17,%d0 48678: 2080 movel %d0,%a0@ 4867a: 6056 bras 486d2 <sem_open+0xde> 4867c: 486e fffc pea %fp@(-4) 48680: 2f12 movel %a2@,%sp@-
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
_Thread_Enable_dispatch();
48682: 45f9 0004 b1bc lea 4b1bc <_Thread_Enable_dispatch>,%a2 48688: 4879 0006 3ac2 pea 63ac2 <_POSIX_Semaphore_Information> 4868e: 4eb9 0004 a528 jsr 4a528 <_Objects_Get>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
48694: 2040 moveal %d0,%a0 48696: 52a8 0016 addql #1,%a0@(22)
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( &the_semaphore_id, &location );
4869a: 2d40 fff8 movel %d0,%fp@(-8)
the_semaphore->open_count += 1;
_Thread_Enable_dispatch();
4869e: 4e92 jsr %a2@
_Thread_Enable_dispatch();
486a0: 4e92 jsr %a2@
goto return_id;
486a2: 4fef 000c lea %sp@(12),%sp 486a6: 6022 bras 486ca <sem_open+0xd6>
/*
* 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(
486a8: 486e fff8 pea %fp@(-8) 486ac: 2f04 movel %d4,%sp@- 486ae: 42a7 clrl %sp@- 486b0: 2f03 movel %d3,%sp@- 486b2: 4eb9 0004 e0bc jsr 4e0bc <_POSIX_Semaphore_Create_support> 486b8: 2400 movel %d0,%d2
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
486ba: 4eb9 0004 b1bc jsr 4b1bc <_Thread_Enable_dispatch>
if ( status == -1 )
486c0: 4fef 0010 lea %sp@(16),%sp 486c4: 70ff moveq #-1,%d0 486c6: b082 cmpl %d2,%d0
486c8: 6708 beqs 486d2 <sem_open+0xde>
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
486ca: 202e fff8 movel %fp@(-8),%d0 486ce: 5080 addql #8,%d0 486d0: 6002 bras 486d4 <sem_open+0xe0>
*/
_Thread_Enable_dispatch();
if ( status == -1 )
return SEM_FAILED;
486d2: 70ff moveq #-1,%d0
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
486d4: 4cee 047c ffdc moveml %fp@(-36),%d2-%d6/%a2 486da: 4e5e unlk %fp
...
00045eac <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
45eac: 4e56 fff0 linkw %fp,#-16 45eb0: 222e 0010 movel %fp@(16),%d1 45eb4: 48d7 041c moveml %d2-%d4/%a2,%sp@ 45eb8: 242e 0008 movel %fp@(8),%d2 45ebc: 246e 000c moveal %fp@(12),%a2
ISR_Level level;
if ( oact )
45ec0: 4a81 tstl %d1
45ec2: 6722 beqs 45ee6 <sigaction+0x3a>
*oact = _POSIX_signals_Vectors[ sig ];
45ec4: 2602 movel %d2,%d3 45ec6: 2002 movel %d2,%d0 45ec8: 4878 000c pea c <OPER1> 45ecc: e58b lsll #2,%d3 45ece: e988 lsll #4,%d0 45ed0: 9083 subl %d3,%d0 45ed2: 0680 0006 0a64 addil #395876,%d0 45ed8: 2f00 movel %d0,%sp@- 45eda: 2f01 movel %d1,%sp@- 45edc: 4eb9 0004 e268 jsr 4e268 <memcpy> 45ee2: 4fef 000c lea %sp@(12),%sp
if ( !sig )
45ee6: 4a82 tstl %d2
45ee8: 6710 beqs 45efa <sigaction+0x4e>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
45eea: 2002 movel %d2,%d0 45eec: 5380 subql #1,%d0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
45eee: 721f moveq #31,%d1 45ef0: b280 cmpl %d0,%d1
45ef2: 6506 bcss 45efa <sigaction+0x4e>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
45ef4: 7009 moveq #9,%d0 45ef6: b082 cmpl %d2,%d0
45ef8: 6610 bnes 45f0a <sigaction+0x5e>
rtems_set_errno_and_return_minus_one( EINVAL );
45efa: 4eb9 0004 da30 jsr 4da30 <__errno> 45f00: 2040 moveal %d0,%a0 45f02: 7016 moveq #22,%d0 45f04: 2080 movel %d0,%a0@ 45f06: 70ff moveq #-1,%d0 45f08: 6062 bras 45f6c <sigaction+0xc0>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
45f0a: 4a8a tstl %a2
45f0c: 675c beqs 45f6a <sigaction+0xbe> <== NEVER TAKEN
/*
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
45f0e: 203c 0000 0700 movel #1792,%d0 45f14: 40c3 movew %sr,%d3 45f16: 8083 orl %d3,%d0 45f18: 46c0 movew %d0,%sr 45f1a: 780c moveq #12,%d4 45f1c: 4c02 4800 mulsl %d2,%d4
if ( act->sa_handler == SIG_DFL ) {
45f20: 4aaa 0008 tstl %a2@(8)
45f24: 6622 bnes 45f48 <sigaction+0x9c>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
45f26: 4878 000c pea c <OPER1> 45f2a: 2004 movel %d4,%d0 45f2c: 0680 0005 dfaa addil #384938,%d0 45f32: 2f00 movel %d0,%sp@- 45f34: 0684 0006 0a64 addil #395876,%d4 45f3a: 2f04 movel %d4,%sp@- 45f3c: 4eb9 0004 e268 jsr 4e268 <memcpy> 45f42: 4fef 000c lea %sp@(12),%sp 45f46: 6020 bras 45f68 <sigaction+0xbc>
} else {
_POSIX_signals_Clear_process_signals( sig );
45f48: 2f02 movel %d2,%sp@-
_POSIX_signals_Vectors[ sig ] = *act;
45f4a: 0684 0006 0a64 addil #395876,%d4
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
45f50: 4eb9 0004 b2a0 jsr 4b2a0 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
45f56: 4878 000c pea c <OPER1> 45f5a: 2f0a movel %a2,%sp@- 45f5c: 2f04 movel %d4,%sp@- 45f5e: 4eb9 0004 e268 jsr 4e268 <memcpy> 45f64: 4fef 0010 lea %sp@(16),%sp
}
_ISR_Enable( level );
45f68: 46c3 movew %d3,%sr
* 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;
45f6a: 4280 clrl %d0
}
45f6c: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 45f72: 4e5e unlk %fp
...
00047bc8 <sigismember>:
int sigismember(
const sigset_t *set,
int signo
)
{
47bc8: 4e56 0000 linkw %fp,#0 47bcc: 206e 0008 moveal %fp@(8),%a0 47bd0: 222e 000c movel %fp@(12),%d1
if ( !set )
47bd4: 4a88 tstl %a0
47bd6: 670c beqs 47be4 <sigismember+0x1c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
47bd8: 4a81 tstl %d1
47bda: 6726 beqs 47c02 <sigismember+0x3a> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
47bdc: 5381 subql #1,%d1
return 0;
if ( !is_valid_signo(signo) )
47bde: 701f moveq #31,%d0 47be0: b081 cmpl %d1,%d0
47be2: 6410 bccs 47bf4 <sigismember+0x2c>
rtems_set_errno_and_return_minus_one( EINVAL );
47be4: 4eb9 0004 f778 jsr 4f778 <__errno> 47bea: 2040 moveal %d0,%a0 47bec: 7016 moveq #22,%d0 47bee: 2080 movel %d0,%a0@ 47bf0: 70ff moveq #-1,%d0 47bf2: 6010 bras 47c04 <sigismember+0x3c>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
47bf4: 7001 moveq #1,%d0 47bf6: e3a8 lsll %d1,%d0
if ( *set & signo_to_mask(signo) )
47bf8: c090 andl %a0@,%d0
const sigset_t *set,
int signo
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
47bfa: 56c0 sne %d0 47bfc: 49c0 extbl %d0 47bfe: 4480 negl %d0 47c00: 6002 bras 47c04 <sigismember+0x3c>
if ( !signo )
return 0;
47c02: 4280 clrl %d0
if ( *set & signo_to_mask(signo) )
return 1;
return 0;
}
47c04: 4e5e unlk %fp <== NOT EXECUTED
00046328 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
46328: 4e56 ffdc linkw %fp,#-36 4632c: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@ 46330: 266e 0008 moveal %fp@(8),%a3 46334: 246e 000c moveal %fp@(12),%a2 46338: 242e 0010 movel %fp@(16),%d2
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
4633c: 4a8b tstl %a3
4633e: 6730 beqs 46370 <sigtimedwait+0x48>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
46340: 4a82 tstl %d2
46342: 673c beqs 46380 <sigtimedwait+0x58>
if ( !_Timespec_Is_valid( timeout ) )
46344: 2f02 movel %d2,%sp@- 46346: 4eb9 0004 974c jsr 4974c <_Timespec_Is_valid> 4634c: 588f addql #4,%sp 4634e: 4a00 tstb %d0
46350: 6610 bnes 46362 <sigtimedwait+0x3a>
rtems_set_errno_and_return_minus_one( EINVAL );
46352: 4eb9 0004 dfc8 jsr 4dfc8 <__errno> 46358: 7616 moveq #22,%d3 4635a: 2240 moveal %d0,%a1 4635c: 2283 movel %d3,%a1@ 4635e: 6000 014c braw 464ac <sigtimedwait+0x184>
interval = _Timespec_To_ticks( timeout );
46362: 2f02 movel %d2,%sp@- 46364: 4eb9 0004 97bc jsr 497bc <_Timespec_To_ticks>
if ( !interval )
4636a: 588f addql #4,%sp 4636c: 4a80 tstl %d0
4636e: 6612 bnes 46382 <sigtimedwait+0x5a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
46370: 4eb9 0004 dfc8 jsr 4dfc8 <__errno> 46376: 7416 moveq #22,%d2 46378: 2040 moveal %d0,%a0 4637a: 2082 movel %d2,%a0@ 4637c: 6000 012e braw 464ac <sigtimedwait+0x184>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
46380: 4280 clrl %d0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
46382: 4a8a tstl %a2
46384: 6604 bnes 4638a <sigtimedwait+0x62>
46386: 45ee fff4 lea %fp@(-12),%a2
the_thread = _Thread_Executing;
4638a: 2079 0006 0dfa moveal 60dfa <_Per_CPU_Information+0xc>,%a0
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
46390: 223c 0000 0700 movel #1792,%d1
the_info = ( info ) ? info : &signal_information;
the_thread = _Thread_Executing;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
46396: 2868 0102 moveal %a0@(258),%a4
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
4639a: 40c3 movew %sr,%d3 4639c: 8283 orl %d3,%d1 4639e: 46c1 movew %d1,%sr
if ( *set & api->signals_pending ) {
463a0: 2413 movel %a3@,%d2 463a2: 2802 movel %d2,%d4 463a4: 222c 00d4 movel %a4@(212),%d1 463a8: c881 andl %d1,%d4
463aa: 672a beqs 463d6 <sigtimedwait+0xae>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
463ac: 2f01 movel %d1,%sp@- 463ae: 4eb9 0004 62dc jsr 462dc <_POSIX_signals_Get_lowest> 463b4: 2480 movel %d0,%a2@
_POSIX_signals_Clear_signals(
463b6: 4297 clrl %sp@ 463b8: 42a7 clrl %sp@- 463ba: 2f0a movel %a2,%sp@- 463bc: 2f00 movel %d0,%sp@- 463be: 2f0c movel %a4,%sp@- 463c0: 4eb9 0004 b97c jsr 4b97c <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
463c6: 46c3 movew %d3,%sr
the_info->si_code = SI_USER;
463c8: 7001 moveq #1,%d0
the_info->si_value.sival_int = 0;
463ca: 42aa 0008 clrl %a2@(8)
return the_info->si_signo;
463ce: 2412 movel %a2@,%d2
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
463d0: 2540 0004 movel %d0,%a2@(4) 463d4: 6034 bras 4640a <sigtimedwait+0xe2>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
463d6: 2239 0006 1028 movel 61028 <_POSIX_signals_Pending>,%d1 463dc: c481 andl %d1,%d2
463de: 6732 beqs 46412 <sigtimedwait+0xea>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
463e0: 2f01 movel %d1,%sp@- 463e2: 4eb9 0004 62dc jsr 462dc <_POSIX_signals_Get_lowest> 463e8: 2400 movel %d0,%d2
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
463ea: 4297 clrl %sp@ 463ec: 4878 0001 pea 1 <ADD> 463f0: 2f0a movel %a2,%sp@- 463f2: 2f00 movel %d0,%sp@- 463f4: 2f0c movel %a4,%sp@- 463f6: 4eb9 0004 b97c jsr 4b97c <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
463fc: 46c3 movew %d3,%sr
the_info->si_signo = signo;
the_info->si_code = SI_USER;
463fe: 7201 moveq #1,%d1
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;
46400: 2482 movel %d2,%a2@
the_info->si_code = SI_USER;
46402: 2541 0004 movel %d1,%a2@(4)
the_info->si_value.sival_int = 0;
46406: 42aa 0008 clrl %a2@(8)
return signo;
4640a: 4fef 0014 lea %sp@(20),%sp 4640e: 6000 009e braw 464ae <sigtimedwait+0x186>
}
the_info->si_signo = -1;
46412: 72ff moveq #-1,%d1 46414: 2481 movel %d1,%a2@
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
46416: 2239 0006 0998 movel 60998 <_Thread_Dispatch_disable_level>,%d1 4641c: 5281 addql #1,%d1 4641e: 23c1 0006 0998 movel %d1,60998 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
46424: 2239 0006 0998 movel 60998 <_Thread_Dispatch_disable_level>,%d1
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
4642a: 7204 moveq #4,%d1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
4642c: 43f9 0006 0fc0 lea 60fc0 <_POSIX_signals_Wait_queue>,%a1
the_thread->Wait.return_code = EINTR;
46432: 2141 0034 movel %d1,%a0@(52)
the_thread->Wait.option = *set;
46436: 2153 0030 movel %a3@,%a0@(48)
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;
4643a: 123c 0001 moveb #1,%d1
the_thread->Wait.return_argument = the_info;
4643e: 214a 0028 movel %a2,%a0@(40)
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
46442: 2149 0044 movel %a1,%a0@(68) 46446: 23c1 0006 0ff0 movel %d1,60ff0 <_POSIX_signals_Wait_queue+0x30>
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 );
4644c: 46c3 movew %d3,%sr
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
4644e: 4879 0004 9520 pea 49520 <_Thread_queue_Timeout> 46454: 2f00 movel %d0,%sp@- 46456: 4879 0006 0fc0 pea 60fc0 <_POSIX_signals_Wait_queue> 4645c: 4eb9 0004 9228 jsr 49228 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
46462: 4eb9 0004 8df0 jsr 48df0 <_Thread_Enable_dispatch>
/*
* 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 );
46468: 42a7 clrl %sp@- 4646a: 42a7 clrl %sp@- 4646c: 2f0a movel %a2,%sp@- 4646e: 2f12 movel %a2@,%sp@- 46470: 2f0c movel %a4,%sp@- 46472: 4eb9 0004 b97c jsr 4b97c <_POSIX_signals_Clear_signals>
/* 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)
46478: 2079 0006 0dfa moveal 60dfa <_Per_CPU_Information+0xc>,%a0 4647e: 4fef 0020 lea %sp@(32),%sp 46482: 7004 moveq #4,%d0 46484: b0a8 0034 cmpl %a0@(52),%d0
46488: 6610 bnes 4649a <sigtimedwait+0x172>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
4648a: 2412 movel %a2@,%d2 4648c: 2202 movel %d2,%d1 4648e: 5381 subql #1,%d1 46490: 103c 0001 moveb #1,%d0 46494: e3a8 lsll %d1,%d0 46496: c093 andl %a3@,%d0
46498: 6614 bnes 464ae <sigtimedwait+0x186>
errno = _Thread_Executing->Wait.return_code;
4649a: 4eb9 0004 dfc8 jsr 4dfc8 <__errno> 464a0: 2079 0006 0dfa moveal 60dfa <_Per_CPU_Information+0xc>,%a0 464a6: 2240 moveal %d0,%a1 464a8: 22a8 0034 movel %a0@(52),%a1@
return -1;
464ac: 74ff moveq #-1,%d2
}
return the_info->si_signo;
}
464ae: 2002 movel %d2,%d0 464b0: 4cee 1c1c ffdc moveml %fp@(-36),%d2-%d4/%a2-%a4 464b6: 4e5e unlk %fp
...
00047eb8 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
47eb8: 4e56 0000 linkw %fp,#0 47ebc: 2f0a movel %a2,%sp@- 47ebe: 246e 000c moveal %fp@(12),%a2
int status;
status = sigtimedwait( set, NULL, NULL );
47ec2: 42a7 clrl %sp@- 47ec4: 42a7 clrl %sp@- 47ec6: 2f2e 0008 movel %fp@(8),%sp@- 47eca: 4eb9 0004 7d0c jsr 47d0c <sigtimedwait>
if ( status != -1 ) {
47ed0: 4fef 000c lea %sp@(12),%sp 47ed4: 72ff moveq #-1,%d1 47ed6: b280 cmpl %d0,%d1
47ed8: 6708 beqs 47ee2 <sigwait+0x2a>
if ( sig )
47eda: 4a8a tstl %a2
47edc: 6710 beqs 47eee <sigwait+0x36> <== NEVER TAKEN
*sig = status;
47ede: 2480 movel %d0,%a2@ 47ee0: 600c bras 47eee <sigwait+0x36>
return 0;
}
return errno;
47ee2: 4eb9 0004 f778 jsr 4f778 <__errno> 47ee8: 2040 moveal %d0,%a0 47eea: 2010 movel %a0@,%d0 47eec: 6002 bras 47ef0 <sigwait+0x38>
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
47eee: 4280 clrl %d0
}
return errno;
}
47ef0: 246e fffc moveal %fp@(-4),%a2
47ef4: 4e5e unlk %fp <== NOT EXECUTED
000454bc <timer_create>:
timer_t *timerid
)
{
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
454bc: 7001 moveq #1,%d0
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
454be: 4e56 0000 linkw %fp,#0 454c2: 2f0b movel %a3,%sp@- 454c4: 266e 0010 moveal %fp@(16),%a3 454c8: 2f0a movel %a2,%sp@- 454ca: 246e 000c moveal %fp@(12),%a2
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
454ce: b0ae 0008 cmpl %fp@(8),%d0
454d2: 6620 bnes 454f4 <timer_create+0x38>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
454d4: 4a8b tstl %a3
454d6: 671c beqs 454f4 <timer_create+0x38>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
454d8: 4a8a tstl %a2
454da: 6726 beqs 45502 <timer_create+0x46>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
454dc: 2012 movel %a2@,%d0 454de: 7201 moveq #1,%d1 454e0: 5380 subql #1,%d0 454e2: b280 cmpl %d0,%d1
454e4: 650e bcss 454f4 <timer_create+0x38> <== NEVER TAKEN
( 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 )
454e6: 202a 0004 movel %a2@(4),%d0
454ea: 6708 beqs 454f4 <timer_create+0x38> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
454ec: 5380 subql #1,%d0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
454ee: 721f moveq #31,%d1 454f0: b280 cmpl %d0,%d1
454f2: 640e bccs 45502 <timer_create+0x46> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
454f4: 4eb9 0004 d4b0 jsr 4d4b0 <__errno> 454fa: 7216 moveq #22,%d1 454fc: 2040 moveal %d0,%a0 454fe: 2081 movel %d1,%a0@ 45500: 603a bras 4553c <timer_create+0x80>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
45502: 2039 0005 f538 movel 5f538 <_Thread_Dispatch_disable_level>,%d0 45508: 5280 addql #1,%d0 4550a: 23c0 0005 f538 movel %d0,5f538 <_Thread_Dispatch_disable_level>
return _Thread_Dispatch_disable_level;
45510: 2039 0005 f538 movel 5f538 <_Thread_Dispatch_disable_level>,%d0
* 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 );
45516: 4879 0005 f780 pea 5f780 <_POSIX_Timer_Information> 4551c: 4eb9 0004 71e8 jsr 471e8 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
45522: 588f addql #4,%sp 45524: 2040 moveal %d0,%a0 45526: 4a80 tstl %d0
45528: 6616 bnes 45540 <timer_create+0x84>
_Thread_Enable_dispatch();
4552a: 4eb9 0004 825c jsr 4825c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
45530: 4eb9 0004 d4b0 jsr 4d4b0 <__errno> 45536: 2040 moveal %d0,%a0 45538: 700b moveq #11,%d0 4553a: 2080 movel %d0,%a0@ 4553c: 70ff moveq #-1,%d0 4553e: 606a bras 455aa <timer_create+0xee>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
45540: 7002 moveq #2,%d0 45542: 1140 003c moveb %d0,%a0@(60)
ptimer->thread_id = _Thread_Executing->Object.id;
45546: 2279 0005 f99a moveal 5f99a <_Per_CPU_Information+0xc>,%a1 4554c: 2169 0008 0038 movel %a1@(8),%a0@(56)
if ( evp != NULL ) {
45552: 4a8a tstl %a2
45554: 6710 beqs 45566 <timer_create+0xaa>
ptimer->inf.sigev_notify = evp->sigev_notify;
45556: 2152 003e movel %a2@,%a0@(62)
ptimer->inf.sigev_signo = evp->sigev_signo;
4555a: 216a 0004 0042 movel %a2@(4),%a0@(66)
ptimer->inf.sigev_value = evp->sigev_value;
45560: 216a 0008 0046 movel %a2@(8),%a0@(70)
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
45566: 2028 0008 movel %a0@(8),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4556a: 4281 clrl %d1 4556c: 2279 0005 f798 moveal 5f798 <_POSIX_Timer_Information+0x18>,%a1 45572: 3200 movew %d0,%d1
}
ptimer->overrun = 0;
45574: 42a8 0066 clrl %a0@(102)
ptimer->timer_data.it_value.tv_sec = 0;
45578: 42a8 005a clrl %a0@(90)
ptimer->timer_data.it_value.tv_nsec = 0;
4557c: 42a8 005e clrl %a0@(94)
ptimer->timer_data.it_interval.tv_sec = 0;
45580: 42a8 0052 clrl %a0@(82)
ptimer->timer_data.it_interval.tv_nsec = 0;
45584: 42a8 0056 clrl %a0@(86)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
45588: 42a8 0018 clrl %a0@(24)
the_watchdog->routine = routine;
4558c: 42a8 002c clrl %a0@(44)
the_watchdog->id = id;
45590: 42a8 0030 clrl %a0@(48)
the_watchdog->user_data = user_data;
45594: 42a8 0034 clrl %a0@(52) 45598: 2388 1c00 movel %a0,%a1@(00000000,%d1:l:4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
4559c: 42a8 000c clrl %a0@(12)
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
455a0: 2680 movel %d0,%a3@
_Thread_Enable_dispatch();
455a2: 4eb9 0004 825c jsr 4825c <_Thread_Enable_dispatch>
return 0;
455a8: 4280 clrl %d0
}
455aa: 246e fff8 moveal %fp@(-8),%a2 455ae: 266e fffc moveal %fp@(-4),%a3 455b2: 4e5e unlk %fp
...
000456b2 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
456b2: 4e56 ffe8 linkw %fp,#-24 456b6: 48d7 041c moveml %d2-%d4/%a2,%sp@ 456ba: 262e 0008 movel %fp@(8),%d3
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
456be: 4ab9 0006 0968 tstl 60968 <_POSIX_signals_Ualarm_timer+0x1c>
456c4: 6620 bnes 456e6 <ualarm+0x34>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
456c6: 42b9 0006 0954 clrl 60954 <_POSIX_signals_Ualarm_timer+0x8>
the_watchdog->routine = routine;
456cc: 203c 0004 5670 movel #284272,%d0
the_watchdog->id = id;
456d2: 42b9 0006 096c clrl 6096c <_POSIX_signals_Ualarm_timer+0x20>
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
456d8: 23c0 0006 0968 movel %d0,60968 <_POSIX_signals_Ualarm_timer+0x1c>
the_watchdog->id = id; the_watchdog->user_data = user_data;
456de: 42b9 0006 0970 clrl 60970 <_POSIX_signals_Ualarm_timer+0x24> 456e4: 6056 bras 4573c <ualarm+0x8a>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
456e6: 4879 0006 094c pea 6094c <_POSIX_signals_Ualarm_timer> 456ec: 4eb9 0004 8ef0 jsr 48ef0 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
456f2: 588f addql #4,%sp 456f4: 7201 moveq #1,%d1 456f6: 5580 subql #2,%d0 456f8: b280 cmpl %d0,%d1
456fa: 6540 bcss 4573c <ualarm+0x8a> <== NEVER TAKEN
* 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);
456fc: 2039 0006 0960 movel 60960 <_POSIX_signals_Ualarm_timer+0x14>,%d0 45702: d0b9 0006 0958 addl 60958 <_POSIX_signals_Ualarm_timer+0xc>,%d0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
45708: 486e fff8 pea %fp@(-8) 4570c: 90b9 0006 0964 subl 60964 <_POSIX_signals_Ualarm_timer+0x18>,%d0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
45712: 283c 000f 4240 movel #1000000,%d4
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
45718: 2f00 movel %d0,%sp@- 4571a: 4eb9 0004 8a04 jsr 48a04 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
45720: 202e fff8 movel %fp@(-8),%d0 45724: 4c04 0800 mulsl %d4,%d0
remaining += tp.tv_nsec / 1000;
45728: 283c 0000 03e8 movel #1000,%d4 4572e: 508f addql #8,%sp 45730: 242e fffc movel %fp@(-4),%d2 45734: 4c44 2802 remsl %d4,%d2,%d2 45738: d480 addl %d0,%d2 4573a: 6002 bras 4573e <ualarm+0x8c>
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
4573c: 4282 clrl %d2
/*
* 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 ) {
4573e: 4a83 tstl %d3
45740: 674e beqs 45790 <ualarm+0xde>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
45742: 283c 0000 03e8 movel #1000,%d4
ticks = _Timespec_To_ticks( &tp );
45748: 45f9 0004 8a88 lea 48a88 <_Timespec_To_ticks>,%a2
* 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;
4574e: 223c 000f 4240 movel #1000000,%d1 45754: 4c41 3000 remul %d1,%d0,%d3 45758: 4c41 3003 remul %d1,%d3,%d3 4575c: 2d43 fff8 movel %d3,%fp@(-8)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
45760: 4c00 4800 mulsl %d0,%d4
ticks = _Timespec_To_ticks( &tp );
45764: 260e movel %fp,%d3 45766: 5183 subql #8,%d3
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
45768: 2d44 fffc movel %d4,%fp@(-4)
ticks = _Timespec_To_ticks( &tp );
4576c: 2f03 movel %d3,%sp@- 4576e: 4e92 jsr %a2@
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
45770: 2f03 movel %d3,%sp@- 45772: 4e92 jsr %a2@
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
45774: 4879 0006 094c pea 6094c <_POSIX_signals_Ualarm_timer> 4577a: 4879 0006 01f0 pea 601f0 <_Watchdog_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
45780: 23c0 0006 0958 movel %d0,60958 <_POSIX_signals_Ualarm_timer+0xc>
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
45786: 4eb9 0004 8dcc jsr 48dcc <_Watchdog_Insert> 4578c: 4fef 0010 lea %sp@(16),%sp
}
return remaining;
}
45790: 2002 movel %d2,%d0 45792: 4cee 041c ffe8 moveml %fp@(-24),%d2-%d4/%a2
45798: 4e5e unlk %fp <== NOT EXECUTED