Annotated Report
00045840 <_API_Mutex_Unlock>:
#include <rtems/score/apimutex.h>
void _API_Mutex_Unlock(
API_Mutex_Control *the_mutex
)
{
45840: 4e56 0000 linkw %fp,#0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
45844: 2039 0005 ba78 movel 5ba78 <_Thread_Dispatch_disable_level>,%d0
4584a: 5280 addql #1,%d0
4584c: 206e 0008 moveal %fp@(8),%a0
45850: 23c0 0005 ba78 movel %d0,5ba78 <_Thread_Dispatch_disable_level>
_Thread_Disable_dispatch();
_CORE_mutex_Surrender(
45856: 42a7 clrl %sp@-
45858: 2f28 0008 movel %a0@(8),%sp@-
4585c: 4868 0010 pea %a0@(16)
45860: 4eb9 0004 5a6c jsr 45a6c <_CORE_mutex_Surrender>
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
45866: 4fef 000c lea %sp@(12),%sp
}
4586a: 4e5e unlk %fp
_CORE_mutex_Surrender(
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
4586c: 4ef9 0004 6c62 jmp 46c62 <_Thread_Enable_dispatch>
...
0004b428 <_CORE_barrier_Wait>:
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4b428: 203c 0000 0700 movel #1792,%d0
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4b42e: 4e56 fff4 linkw %fp,#-12
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
4b432: 2279 0005 bb32 moveal 5bb32 <_Thread_Executing>,%a1
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4b438: 48d7 001c moveml %d2-%d4,%sp@
4b43c: 242e 000c movel %fp@(12),%d2
4b440: 262e 0014 movel %fp@(20),%d3
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
4b444: 42a9 0034 clrl %a1@(52)
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4b448: 206e 0008 moveal %fp@(8),%a0
4b44c: 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 );
4b450: 40c1 movew %sr,%d1
4b452: 8081 orl %d1,%d0
4b454: 46c0 movew %d0,%sr
the_barrier->number_of_waiting_threads++;
4b456: 2028 0048 movel %a0@(72),%d0
4b45a: 5280 addql #1,%d0
4b45c: 2140 0048 movel %d0,%a0@(72)
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
4b460: 4aa8 0040 tstl %a0@(64)
4b464: 6626 bnes 4b48c <_CORE_barrier_Wait+0x64>
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
4b466: b0a8 0044 cmpl %a0@(68),%d0
4b46a: 6620 bnes 4b48c <_CORE_barrier_Wait+0x64>
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
4b46c: 7001 moveq #1,%d0
4b46e: 2340 0034 movel %d0,%a1@(52)
_ISR_Enable( level );
4b472: 46c1 movew %d1,%sr
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
4b474: 2d44 0010 movel %d4,%fp@(16)
4b478: 2d42 000c movel %d2,%fp@(12)
4b47c: 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 );
}
4b480: 4cd7 001c moveml %sp@,%d2-%d4
4b484: 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 );
4b486: 4ef9 0004 b3f4 jmp 4b3f4 <_CORE_barrier_Release>
4b48c: 7001 moveq #1,%d0
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
4b48e: 2342 0020 movel %d2,%a1@(32)
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
4b492: 2348 0044 movel %a0,%a1@(68)
4b496: 2140 0030 movel %d0,%a0@(48)
executing->Wait.id = id;
_ISR_Enable( level );
4b49a: 46c1 movew %d1,%sr
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
4b49c: 2d43 000c movel %d3,%fp@(12)
4b4a0: 203c 0004 73c0 movel #291776,%d0
4b4a6: 2d48 0008 movel %a0,%fp@(8)
4b4aa: 2d40 0010 movel %d0,%fp@(16)
}
4b4ae: 4cd7 001c moveml %sp@,%d2-%d4
4b4b2: 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 );
4b4b4: 4ef9 0004 70d4 jmp 470d4 <_Thread_queue_Enqueue_with_handler>
...
0005202c <_CORE_message_queue_Broadcast>:
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
5202c: 4e56 ffe0 linkw %fp,#-32
52030: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
52034: 246e 0008 moveal %fp@(8),%a2
52038: 2a2e 000c movel %fp@(12),%d5
5203c: 262e 0010 movel %fp@(16),%d3
52040: 286e 001c moveal %fp@(28),%a4
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
52044: b6aa 004c cmpl %a2@(76),%d3
52048: 6304 blss 5204e <_CORE_message_queue_Broadcast+0x22>
5204a: 7001 moveq #1,%d0 <== NOT EXECUTED
5204c: 6042 bras 52090 <_CORE_message_queue_Broadcast+0x64><== NOT EXECUTED
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
5204e: 4aaa 0048 tstl %a2@(72)
52052: 6610 bnes 52064 <_CORE_message_queue_Broadcast+0x38>
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
52054: 4282 clrl %d2
52056: 283c 0005 4228 movel #344616,%d4
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
5205c: 4bf9 0005 9240 lea 59240 <memcpy>,%a5
52062: 601a bras 5207e <_CORE_message_queue_Broadcast+0x52>
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
*count = 0;
52064: 4294 clrl %a4@
52066: 6026 bras 5208e <_CORE_message_queue_Broadcast+0x62>
52068: 2f03 movel %d3,%sp@-
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
5206a: 5282 addql #1,%d2
5206c: 2f05 movel %d5,%sp@-
5206e: 2f2b 002c movel %a3@(44),%sp@-
52072: 4e95 jsr %a5@
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
52074: 206b 0028 moveal %a3@(40),%a0
52078: 4fef 000c lea %sp@(12),%sp
5207c: 2083 movel %d3,%a0@
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
5207e: 2f0a movel %a2,%sp@-
52080: 2044 moveal %d4,%a0
52082: 4e90 jsr %a0@
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
52084: 588f addql #4,%sp
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
52086: 2640 moveal %d0,%a3
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
52088: 4a80 tstl %d0
5208a: 66dc bnes 52068 <_CORE_message_queue_Broadcast+0x3c>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
5208c: 2882 movel %d2,%a4@
5208e: 4280 clrl %d0
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
52090: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5
52096: 4e5e unlk %fp
...
0004dca4 <_CORE_message_queue_Seize>:
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4dca4: 223c 0000 0700 movel #1792,%d1
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
4dcaa: 4e56 ffe0 linkw %fp,#-32
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
4dcae: 2079 0006 4fd6 moveal 64fd6 <_Thread_Executing>,%a0
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
4dcb4: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@
4dcb8: 282e 000c movel %fp@(12),%d4
4dcbc: 262e 001c movel %fp@(28),%d3
4dcc0: 246e 0008 moveal %fp@(8),%a2
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
4dcc4: 42a8 0034 clrl %a0@(52)
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
4dcc8: 242e 0010 movel %fp@(16),%d2
4dccc: 226e 0014 moveal %fp@(20),%a1
4dcd0: 1a2e 001b moveb %fp@(27),%d5
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4dcd4: 40c0 movew %sr,%d0
4dcd6: 8280 orl %d0,%d1
4dcd8: 46c1 movew %d1,%sr
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
4dcda: 220a movel %a2,%d1
4dcdc: 0681 0000 0054 addil #84,%d1
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
4dce2: 266a 0050 moveal %a2@(80),%a3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
4dce6: b28b cmpl %a3,%d1
4dce8: 6752 beqs 4dd3c <_CORE_message_queue_Seize+0x98>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
4dcea: 2853 moveal %a3@,%a4
the_chain->first = new_first;
new_first->previous = _Chain_Head(the_chain);
4dcec: 4bea 0050 lea %a2@(80),%a5
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
the_chain->first = new_first;
4dcf0: 254c 0050 movel %a4,%a2@(80)
new_first->previous = _Chain_Head(the_chain);
4dcf4: 294d 0004 movel %a5,%a4@(4)
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
4dcf8: 4a8b tstl %a3
4dcfa: 6740 beqs 4dd3c <_CORE_message_queue_Seize+0x98>
the_message_queue->number_of_pending_messages -= 1;
4dcfc: 53aa 0048 subql #1,%a2@(72)
_ISR_Enable( level );
4dd00: 46c0 movew %d0,%sr
*size_p = the_message->Contents.size;
4dd02: 22ab 0008 movel %a3@(8),%a1@
_Thread_Executing->Wait.count =
4dd06: 2079 0006 4fd6 moveal 64fd6 <_Thread_Executing>,%a0
4dd0c: 42a8 0024 clrl %a0@(36)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4dd10: 2f11 movel %a1@,%sp@-
4dd12: 486b 000c pea %a3@(12)
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
4dd16: 45ea 0060 lea %a2@(96),%a2
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4dd1a: 2f02 movel %d2,%sp@-
4dd1c: 4eb9 0005 4424 jsr 54424 <memcpy>
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
4dd22: 4fef 000c lea %sp@(12),%sp
4dd26: 2d4a 0008 movel %a2,%fp@(8)
4dd2a: 2d4b 000c movel %a3,%fp@(12)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
4dd2e: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5
4dd34: 4e5e unlk %fp
4dd36: 4ef9 0004 db2c jmp 4db2c <_Chain_Append>
return;
}
#endif
}
if ( !wait ) {
4dd3c: 4a05 tstb %d5
4dd3e: 6612 bnes 4dd52 <_CORE_message_queue_Seize+0xae>
_ISR_Enable( level );
4dd40: 46c0 movew %d0,%sr
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
4dd42: 7004 moveq #4,%d0
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
4dd44: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5
#endif
}
if ( !wait ) {
_ISR_Enable( level );
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
4dd4a: 2140 0034 movel %d0,%a0@(52)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
4dd4e: 4e5e unlk %fp
4dd50: 4e75 rts
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;
4dd52: 7201 moveq #1,%d1
4dd54: 2541 0030 movel %d1,%a2@(48)
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
executing->Wait.id = id;
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
4dd58: 2149 0028 movel %a1,%a0@(40)
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
executing->Wait.id = id;
executing->Wait.return_argument_second.mutable_object = buffer;
4dd5c: 2142 002c movel %d2,%a0@(44)
return;
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
executing->Wait.id = id;
4dd60: 2144 0020 movel %d4,%a0@(32)
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
return;
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
4dd64: 214a 0044 movel %a2,%a0@(68)
executing->Wait.id = id;
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
4dd68: 46c0 movew %d0,%sr
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
4dd6a: 4bf9 0004 fa70 lea 4fa70 <_Thread_queue_Timeout>,%a5
4dd70: 2d43 000c movel %d3,%fp@(12)
4dd74: 2d4d 0010 movel %a5,%fp@(16)
4dd78: 2d4a 0008 movel %a2,%fp@(8)
}
4dd7c: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5
4dd82: 4e5e unlk %fp
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
4dd84: 4ef9 0004 f784 jmp 4f784 <_Thread_queue_Enqueue_with_handler>
...
00049948 <_CORE_mutex_Seize_interrupt_trylock>:
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
49948: 4e56 0000 linkw %fp,#0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
4994c: 2279 0005 bb32 moveal 5bb32 <_Thread_Executing>,%a1
49952: 2f0b movel %a3,%sp@-
49954: 206e 0008 moveal %fp@(8),%a0
49958: 2f0a movel %a2,%sp@-
4995a: 246e 000c moveal %fp@(12),%a2
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
4995e: 42a9 0034 clrl %a1@(52)
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
49962: 4aa8 004e tstl %a0@(78)
49966: 6700 0098 beqw 49a00 <_CORE_mutex_Seize_interrupt_trylock+0xb8>
the_mutex->lock = CORE_MUTEX_LOCKED;
4996a: 42a8 004e clrl %a0@(78)
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
4996e: 7201 moveq #1,%d1
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
49970: 2169 0008 005e movel %a1@(8),%a0@(94)
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
49976: 2028 0046 movel %a0@(70),%d0
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
4997a: 2141 0052 movel %d1,%a0@(82)
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
4997e: 123c 0002 moveb #2,%d1
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
49982: 2149 005a movel %a1,%a0@(90)
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
49986: b280 cmpl %d0,%d1
49988: 6708 beqs 49992 <_CORE_mutex_Seize_interrupt_trylock+0x4a>
4998a: 123c 0003 moveb #3,%d1
4998e: b280 cmpl %d0,%d1
49990: 660a bnes 4999c <_CORE_mutex_Seize_interrupt_trylock+0x54>
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
49992: 52a9 001c addql #1,%a1@(28)
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
49996: 7203 moveq #3,%d1
49998: b280 cmpl %d0,%d1
4999a: 6706 beqs 499a2 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
_ISR_Enable( *level_p );
4999c: 2012 movel %a2@,%d0
4999e: 46c0 movew %d0,%sr
499a0: 607c bras 49a1e <_CORE_mutex_Seize_interrupt_trylock+0xd6>
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
499a2: 2028 004a movel %a0@(74),%d0
current = executing->current_priority;
499a6: 2229 0014 movel %a1@(20),%d1
if ( current == ceiling ) {
499aa: b081 cmpl %d1,%d0
499ac: 6606 bnes 499b4 <_CORE_mutex_Seize_interrupt_trylock+0x6c>
_ISR_Enable( *level_p );
499ae: 2012 movel %a2@,%d0
499b0: 46c0 movew %d0,%sr
499b2: 606a bras 49a1e <_CORE_mutex_Seize_interrupt_trylock+0xd6>
return 0;
}
if ( current > ceiling ) {
499b4: b081 cmpl %d1,%d0
499b6: 642e bccs 499e6 <_CORE_mutex_Seize_interrupt_trylock+0x9e>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
499b8: 2039 0005 ba78 movel 5ba78 <_Thread_Dispatch_disable_level>,%d0
499be: 5280 addql #1,%d0
499c0: 23c0 0005 ba78 movel %d0,5ba78 <_Thread_Dispatch_disable_level>
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
499c6: 2012 movel %a2@,%d0
499c8: 46c0 movew %d0,%sr
_Thread_Change_priority(
499ca: 42a7 clrl %sp@-
499cc: 2f28 004a movel %a0@(74),%sp@-
499d0: 2f28 005a movel %a0@(90),%sp@-
499d4: 4eb9 0004 6768 jsr 46768 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
499da: 4eb9 0004 6c62 jsr 46c62 <_Thread_Enable_dispatch>
499e0: 4fef 000c lea %sp@(12),%sp
499e4: 6038 bras 49a1e <_CORE_mutex_Seize_interrupt_trylock+0xd6>
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
499e6: 7006 moveq #6,%d0
the_mutex->lock = CORE_MUTEX_UNLOCKED;
499e8: 7201 moveq #1,%d1
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
499ea: 2340 0034 movel %d0,%a1@(52)
the_mutex->lock = CORE_MUTEX_UNLOCKED;
the_mutex->nest_count = 0; /* undo locking above */
499ee: 42a8 0052 clrl %a0@(82)
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
the_mutex->lock = CORE_MUTEX_UNLOCKED;
499f2: 2141 004e movel %d1,%a0@(78)
the_mutex->nest_count = 0; /* undo locking above */
executing->resource_count--; /* undo locking above */
499f6: 53a9 001c subql #1,%a1@(28)
_ISR_Enable( *level_p );
499fa: 2012 movel %a2@,%d0
499fc: 46c0 movew %d0,%sr
499fe: 601e bras 49a1e <_CORE_mutex_Seize_interrupt_trylock+0xd6>
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
49a00: 2668 005a moveal %a0@(90),%a3
49a04: b3cb cmpal %a3,%a1
49a06: 6626 bnes 49a2e <_CORE_mutex_Seize_interrupt_trylock+0xe6>
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
49a08: 2028 0040 movel %a0@(64),%d0
49a0c: 6708 beqs 49a16 <_CORE_mutex_Seize_interrupt_trylock+0xce>
49a0e: 7201 moveq #1,%d1
49a10: b280 cmpl %d0,%d1
49a12: 661a bnes 49a2e <_CORE_mutex_Seize_interrupt_trylock+0xe6>
49a14: 600c bras 49a22 <_CORE_mutex_Seize_interrupt_trylock+0xda><== NOT EXECUTED
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
49a16: 52a8 0052 addql #1,%a0@(82)
_ISR_Enable( *level_p );
49a1a: 2012 movel %a2@,%d0
49a1c: 46c0 movew %d0,%sr
49a1e: 4280 clrl %d0
49a20: 600e bras 49a30 <_CORE_mutex_Seize_interrupt_trylock+0xe8>
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
49a22: 7002 moveq #2,%d0 <== NOT EXECUTED
49a24: 2740 0034 movel %d0,%a3@(52) <== NOT EXECUTED
_ISR_Enable( *level_p );
49a28: 2012 movel %a2@,%d0 <== NOT EXECUTED
49a2a: 46c0 movew %d0,%sr <== NOT EXECUTED
49a2c: 60f0 bras 49a1e <_CORE_mutex_Seize_interrupt_trylock+0xd6><== NOT EXECUTED
49a2e: 7001 moveq #1,%d0
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
49a30: 246e fff8 moveal %fp@(-8),%a2
49a34: 266e fffc moveal %fp@(-4),%a3
49a38: 4e5e unlk %fp <== NOT EXECUTED
00045bb8 <_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
)
{
45bb8: 4e56 0000 linkw %fp,#0
45bbc: 2f0a movel %a2,%sp@-
45bbe: 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)) ) {
45bc2: 2f0a movel %a2,%sp@-
45bc4: 4eb9 0004 6f94 jsr 46f94 <_Thread_queue_Dequeue>
45bca: 588f addql #4,%sp
45bcc: 4a80 tstl %d0
45bce: 6704 beqs 45bd4 <_CORE_semaphore_Surrender+0x1c>
45bd0: 4280 clrl %d0
45bd2: 6024 bras 45bf8 <_CORE_semaphore_Surrender+0x40>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
45bd4: 203c 0000 0700 movel #1792,%d0
45bda: 40c1 movew %sr,%d1
45bdc: 8081 orl %d1,%d0
45bde: 46c0 movew %d0,%sr
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
45be0: 202a 0048 movel %a2@(72),%d0
45be4: b0aa 0040 cmpl %a2@(64),%d0
45be8: 6504 bcss 45bee <_CORE_semaphore_Surrender+0x36>
45bea: 7004 moveq #4,%d0 <== NOT EXECUTED
45bec: 6008 bras 45bf6 <_CORE_semaphore_Surrender+0x3e> <== NOT EXECUTED
the_semaphore->count += 1;
45bee: 5280 addql #1,%d0
45bf0: 2540 0048 movel %d0,%a2@(72)
45bf4: 4280 clrl %d0
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
45bf6: 46c1 movew %d1,%sr
}
return status;
}
45bf8: 246e fffc moveal %fp@(-4),%a2
45bfc: 4e5e unlk %fp <== NOT EXECUTED
00045f7c <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
45f7c: 4e56 0000 linkw %fp,#0
45f80: 222e 000c movel %fp@(12),%d1
45f84: 2f03 movel %d3,%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;
_User_extensions_Fatal( the_source, is_internal, the_error );
45f86: 4283 clrl %d3
45f88: 1601 moveb %d1,%d3
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
45f8a: 2f02 movel %d2,%sp@-
45f8c: 242e 0010 movel %fp@(16),%d2
_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 );
45f90: 2f02 movel %d2,%sp@-
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
45f92: 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 );
45f96: 2f03 movel %d3,%sp@-
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
45f98: 263c 0000 0700 movel #1792,%d3
_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 );
45f9e: 2f00 movel %d0,%sp@-
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
45fa0: 13c1 0005 bb22 moveb %d1,5bb22 <_Internal_errors_What_happened+0x4>
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
45fa6: 23c0 0005 bb1e movel %d0,5bb1e <_Internal_errors_What_happened>
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
45fac: 23c2 0005 bb24 movel %d2,5bb24 <_Internal_errors_What_happened+0x6>
_User_extensions_Fatal( the_source, is_internal, the_error );
45fb2: 4eb9 0004 7a2e jsr 47a2e <_User_extensions_Fatal>
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
45fb8: 40c0 movew %sr,%d0
45fba: 8083 orl %d3,%d0
45fbc: 46c0 movew %d0,%sr
45fbe: 2002 movel %d2,%d0 <== NOT EXECUTED
45fc0: 223c dead beef movel #-559038737,%d1 <== NOT EXECUTED
45fc6: 4ac8 halt <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
45fc8: 7005 moveq #5,%d0
45fca: 4fef 000c lea %sp@(12),%sp
45fce: 23c0 0005 bbfa movel %d0,5bbfa <_System_state_Current>
45fd4: 60fe bras 45fd4 <_Internal_error_Occurred+0x58>
...
00046040 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
46040: 4e56 fff0 linkw %fp,#-16
46044: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
46048: 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 )
4604c: 4aaa 0014 tstl %a2@(20)
46050: 6604 bnes 46056 <_Objects_Allocate+0x16>
46052: 4280 clrl %d0 <== NOT EXECUTED
46054: 605e bras 460b4 <_Objects_Allocate+0x74> <== NOT EXECUTED
/*
* 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 );
46056: 240a movel %a2,%d2
46058: 0682 0000 001c addil #28,%d2
4605e: 47f9 0004 98d4 lea 498d4 <_Chain_Get>,%a3
46064: 2f02 movel %d2,%sp@-
46066: 4e93 jsr %a3@
if ( information->auto_extend ) {
46068: 588f addql #4,%sp
4606a: 4a2a 0010 tstb %a2@(16)
4606e: 6744 beqs 460b4 <_Objects_Allocate+0x74>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
46070: 4a80 tstl %d0
46072: 6612 bnes 46086 <_Objects_Allocate+0x46>
_Objects_Extend_information( information );
46074: 2f0a movel %a2,%sp@-
46076: 4eb9 0004 60ec jsr 460ec <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
4607c: 2f02 movel %d2,%sp@-
4607e: 4e93 jsr %a3@
}
if ( the_object ) {
46080: 508f addql #8,%sp
46082: 4a80 tstl %d0
46084: 672e beqs 460b4 <_Objects_Allocate+0x74>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46086: 2040 moveal %d0,%a0
46088: 4281 clrl %d1
4608a: 4283 clrl %d3
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
4608c: 4282 clrl %d2
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
4608e: 362a 0008 movew %a2@(8),%d3
46092: 3228 000a movew %a0@(10),%d1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
46096: 342a 0012 movew %a2@(18),%d2
information->inactive--;
4609a: 306a 0028 moveaw %a2@(40),%a0
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
4609e: 9283 subl %d3,%d1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
460a0: 4c42 1001 remul %d2,%d1,%d1
information->inactive--;
460a4: 5388 subql #1,%a0
block = (uint32_t) _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
460a6: e589 lsll #2,%d1
information->inactive--;
460a8: 3548 0028 movew %a0,%a2@(40)
block = (uint32_t) _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
460ac: 206a 002a moveal %a2@(42),%a0
460b0: d1c1 addal %d1,%a0
460b2: 5390 subql #1,%a0@
information->inactive--;
}
}
return the_object;
}
460b4: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
460ba: 4e5e unlk %fp
...
000460c0 <_Objects_Close>:
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
460c0: 4280 clrl %d0
void _Objects_Close(
Objects_Information *information,
Objects_Control *the_object
)
{
460c2: 4e56 0000 linkw %fp,#0
460c6: 226e 000c moveal %fp@(12),%a1
460ca: 206e 0008 moveal %fp@(8),%a0
460ce: 2f0a movel %a2,%sp@-
460d0: 2468 0018 moveal %a0@(24),%a2
460d4: 3029 000a movew %a1@(10),%d0
460d8: 42b2 0c00 clrl %a2@(00000000,%d0:l:4)
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
460dc: 2d49 000c movel %a1,%fp@(12)
}
460e0: 245f moveal %sp@+,%a2
460e2: 4e5e unlk %fp
Objects_Control *the_object
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
460e4: 4ef9 0004 65e0 jmp 465e0 <_Objects_Namespace_remove>
...
00049e24 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
49e24: 4e56 fffc linkw %fp,#-4
49e28: 222e 0008 movel %fp@(8),%d1
49e2c: 2f02 movel %d2,%sp@-
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
49e2e: 4a81 tstl %d1
49e30: 660a bnes 49e3c <_Objects_Id_to_name+0x18>
49e32: 2079 0006 709a moveal 6709a <_Thread_Executing>,%a0
49e38: 2228 0008 movel %a0@(8),%d1
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
49e3c: 7418 moveq #24,%d2
49e3e: 2001 movel %d1,%d0
49e40: e4a8 lsrl %d2,%d0
49e42: 143c 0007 moveb #7,%d2
49e46: c082 andl %d2,%d0
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
49e48: 143c 0003 moveb #3,%d2
49e4c: 2040 moveal %d0,%a0
49e4e: 5388 subql #1,%a0
49e50: b488 cmpl %a0,%d2
49e52: 6538 bcss 49e8c <_Objects_Id_to_name+0x68>
49e54: 6040 bras 49e96 <_Objects_Id_to_name+0x72>
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
49e56: 2001 movel %d1,%d0
49e58: 741b moveq #27,%d2
49e5a: e4a8 lsrl %d2,%d0
49e5c: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
if ( !information )
49e60: 672a beqs 49e8c <_Objects_Id_to_name+0x68>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
49e62: 486e fffc pea %fp@(-4)
49e66: 2f01 movel %d1,%sp@-
49e68: 2f00 movel %d0,%sp@-
49e6a: 4eb9 0004 9dc4 jsr 49dc4 <_Objects_Get>
if ( !the_object )
49e70: 4fef 000c lea %sp@(12),%sp
49e74: 4a80 tstl %d0
49e76: 6714 beqs 49e8c <_Objects_Id_to_name+0x68>
return OBJECTS_INVALID_ID;
*name = the_object->name;
49e78: 206e 000c moveal %fp@(12),%a0
49e7c: 2240 moveal %d0,%a1
49e7e: 20a9 000c movel %a1@(12),%a0@
_Thread_Enable_dispatch();
49e82: 4eb9 0004 a696 jsr 4a696 <_Thread_Enable_dispatch>
49e88: 4280 clrl %d0
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
49e8a: 6002 bras 49e8e <_Objects_Id_to_name+0x6a>
49e8c: 7003 moveq #3,%d0
}
49e8e: 242e fff8 movel %fp@(-8),%d2
49e92: 4e5e unlk %fp
49e94: 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 ] )
49e96: 41f9 0006 6f98 lea 66f98 <_Objects_Information_table>,%a0
49e9c: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0
49ea0: 4a88 tstl %a0
49ea2: 66b2 bnes 49e56 <_Objects_Id_to_name+0x32>
49ea4: 60e6 bras 49e8c <_Objects_Id_to_name+0x68>
...
000464ec <_Objects_Initialize_information>:
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
464ec: 41f9 0005 ba30 lea 5ba30 <_Objects_Information_table>,%a0
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
464f2: 4e56 fff0 linkw %fp,#-16
464f6: 202e 000c movel %fp@(12),%d0
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
464fa: 2270 0c00 moveal %a0@(00000000,%d0:l:4),%a1
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
464fe: 48d7 003c moveml %d2-%d5,%sp@
46502: 222e 0014 movel %fp@(20),%d1
46506: 4285 clrl %d5
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
46508: 2601 movel %d1,%d3
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
4650a: 206e 0008 moveal %fp@(8),%a0
information->the_class = the_class;
information->size = size;
information->local_table = 0;
information->inactive_per_block = 0;
information->object_blocks = 0;
information->inactive = 0;
4650e: 4242 clrw %d2
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
46510: 3a2e 001a movew %fp@(26),%d5
46514: 282e 0010 movel %fp@(16),%d4
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
46518: d683 addl %d3,%d3
4651a: 9783 subxl %d3,%d3
4651c: 4483 negl %d3
information->the_class = the_class;
information->size = size;
information->local_table = 0;
information->inactive_per_block = 0;
information->object_blocks = 0;
information->inactive = 0;
4651e: 3142 0028 movew %d2,%a0@(40)
/*
* Set the maximum value to 0. It will be updated when objects are
* added to the inactive set from _Objects_Extend_information()
*/
information->maximum = 0;
46522: 3142 000e movew %d2,%a0@(14)
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
46526: 242e 0020 movel %fp@(32),%d2
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
information->the_class = the_class;
4652a: 3144 0004 movew %d4,%a0@(4)
_Objects_Information_table[ the_api ][ the_class ] = information;
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
4652e: 1143 0010 moveb %d3,%a0@(16)
uint32_t index;
#endif
information->the_api = the_api;
information->the_class = the_class;
information->size = size;
46532: 2145 0014 movel %d5,%a0@(20)
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
46536: 2388 4c00 movel %a0,%a1@(00000000,%d4:l:4)
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
4653a: 0881 001f bclr #31,%d1
uint32_t maximum_per_allocation;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
4653e: 2080 movel %d0,%a0@
information->the_class = the_class;
information->size = size;
information->local_table = 0;
46540: 42a8 0018 clrl %a0@(24)
information->inactive_per_block = 0;
46544: 42a8 002a clrl %a0@(42)
information->object_blocks = 0;
46548: 42a8 002e clrl %a0@(46)
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
4654c: 4a03 tstb %d3
4654e: 6714 beqs 46564 <_Objects_Initialize_information+0x78>
46550: 4a81 tstl %d1
46552: 6610 bnes 46564 <_Objects_Initialize_information+0x78>
_Internal_error_Occurred(
46554: 4878 0014 pea 14 <OPER2>
46558: 4878 0001 pea 1 <ADD>
4655c: 42a7 clrl %sp@-
4655e: 4eb9 0004 5f7c jsr 45f7c <_Internal_error_Occurred>
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
information->minimum_id =
46564: 7a18 moveq #24,%d5
46566: 4a81 tstl %d1
46568: 56c3 sne %d3
4656a: eba8 lsll %d5,%d0
4656c: 1a3c 001b moveb #27,%d5
46570: 49c3 extbl %d3
46572: 4483 negl %d3
information->allocation_size = maximum_per_allocation;
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
46574: 43f9 0005 b21c lea 5b21c <null_local_table.3444>,%a1
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
information->minimum_id =
4657a: ebac lsll %d5,%d4
4657c: 08c0 0010 bset #16,%d0
/*
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
46580: 1a3c 0003 moveb #3,%d5
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
information->minimum_id =
46584: 8084 orl %d4,%d0
/*
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
46586: ca82 andl %d2,%d5
}
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum_per_allocation;
46588: 3141 0012 movew %d1,%a0@(18)
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
information->minimum_id =
4658c: 8083 orl %d3,%d0
information->allocation_size = maximum_per_allocation;
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
4658e: 2149 0018 movel %a1,%a0@(24)
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
information->minimum_id =
46592: 2140 0006 movel %d0,%a0@(6)
/*
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
46596: 4a85 tstl %d5
46598: 6604 bnes 4659e <_Objects_Initialize_information+0xb2>
4659a: 2002 movel %d2,%d0
4659c: 6008 bras 465a6 <_Objects_Initialize_information+0xba>
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
4659e: 2002 movel %d2,%d0 <== NOT EXECUTED
465a0: 5880 addql #4,%d0 <== NOT EXECUTED
465a2: 74fc moveq #-4,%d2 <== NOT EXECUTED
465a4: c082 andl %d2,%d0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
465a6: 43e8 0020 lea %a0@(32),%a1
465aa: 2149 001c movel %a1,%a0@(28)
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
465ae: 43e8 001c lea %a0@(28),%a1
~(OBJECTS_NAME_ALIGNMENT-1);
information->name_length = name_length;
465b2: 3140 0032 movew %d0,%a0@(50)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
465b6: 42a8 0020 clrl %a0@(32)
the_chain->last = _Chain_Head(the_chain);
465ba: 2149 0024 movel %a1,%a0@(36)
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
465be: 4a81 tstl %d1
465c0: 6712 beqs 465d4 <_Objects_Initialize_information+0xe8>
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
465c2: 2d48 0008 movel %a0,%fp@(8)
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
465c6: 4cee 003c fff0 moveml %fp@(-16),%d2-%d5
465cc: 4e5e unlk %fp
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
465ce: 4ef9 0004 60ec jmp 460ec <_Objects_Extend_information>
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
465d4: 4cee 003c fff0 moveml %fp@(-16),%d2-%d5
465da: 4e5e unlk %fp
...
00048190 <_Objects_Set_name>:
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
48190: 4280 clrl %d0
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
48192: 4e56 fff0 linkw %fp,#-16
48196: 206e 0008 moveal %fp@(8),%a0
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
4819a: 3028 0032 movew %a0@(50),%d0
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
4819e: 48d7 041c moveml %d2-%d4/%a2,%sp@
481a2: 246e 0010 moveal %fp@(16),%a2
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
481a6: 2f00 movel %d0,%sp@-
481a8: 2f0a movel %a2,%sp@-
481aa: 4eb9 0004 e964 jsr 4e964 <strnlen>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
481b0: 508f addql #8,%sp
481b2: 7201 moveq #1,%d1
481b4: 1812 moveb %a2@,%d4
481b6: b280 cmpl %d0,%d1
481b8: 644a bccs 48204 <_Objects_Set_name+0x74>
481ba: 7602 moveq #2,%d3
481bc: 142a 0001 moveb %a2@(1),%d2
481c0: 49c2 extbl %d2
481c2: 4842 swap %d2
481c4: 4242 clrw %d2
481c6: b680 cmpl %d0,%d3
481c8: 643e bccs 48208 <_Objects_Set_name+0x78>
481ca: 163c 0003 moveb #3,%d3
481ce: 122a 0002 moveb %a2@(2),%d1
481d2: 49c1 extbl %d1
481d4: e189 lsll #8,%d1
481d6: b680 cmpl %d0,%d3
481d8: 6506 bcss 481e0 <_Objects_Set_name+0x50>
481da: 163c 0020 moveb #32,%d3
481de: 6006 bras 481e6 <_Objects_Set_name+0x56>
481e0: 162a 0003 moveb %a2@(3),%d3
481e4: 49c3 extbl %d3
481e6: 7018 moveq #24,%d0
481e8: e1ac lsll %d0,%d4
481ea: 206e 000c moveal %fp@(12),%a0
481ee: 8484 orl %d4,%d2
);
}
return true;
}
481f0: 7001 moveq #1,%d0
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
481f2: 8481 orl %d1,%d2
481f4: 8483 orl %d3,%d2
481f6: 2142 000c movel %d2,%a0@(12)
);
}
return true;
}
481fa: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
48200: 4e5e unlk %fp
48202: 4e75 rts
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
48204: 7420 moveq #32,%d2
48206: 4842 swap %d2
48208: 223c 0000 2000 movel #8192,%d1
4820e: 7620 moveq #32,%d3
48210: 60d4 bras 481e6 <_Objects_Set_name+0x56>
...
00056af8 <_Region_Process_queue>:
*/
void _Region_Process_queue(
Region_Control *the_region
)
{
56af8: 4e56 ffe4 linkw %fp,#-28
56afc: 2039 0007 4084 movel 74084 <_Thread_Dispatch_disable_level>,%d0
56b02: 5280 addql #1,%d0
56b04: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@
56b08: 266e 0008 moveal %fp@(8),%a3
56b0c: 23c0 0007 4084 movel %d0,74084 <_Thread_Dispatch_disable_level>
* 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();
56b12: 2f39 0007 4136 movel 74136 <_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 );
56b18: 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 );
56b1a: 280b movel %a3,%d4
56b1c: 0682 0000 0010 addil #16,%d2
56b22: 0684 0000 0068 addil #104,%d4
56b28: 4bf9 0005 28f4 lea 528f4 <_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 );
56b2e: 49f9 0005 718c lea 5718c <_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();
56b34: 4eb9 0005 1f4c jsr 51f4c <_API_Mutex_Unlock>
56b3a: 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 );
56b3c: 263c 0005 7290 movel #357008,%d3
56b42: 2f02 movel %d2,%sp@-
56b44: 2043 moveal %d3,%a0
56b46: 4e90 jsr %a0@
if ( the_thread == NULL )
56b48: 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 );
56b4a: 2440 moveal %d0,%a2
if ( the_thread == NULL )
56b4c: 4a80 tstl %d0
56b4e: 672c beqs 56b7c <_Region_Process_queue+0x84>
56b50: 42a7 clrl %sp@-
56b52: 42a7 clrl %sp@-
56b54: 2f2a 0024 movel %a2@(36),%sp@-
56b58: 2f04 movel %d4,%sp@-
56b5a: 4e95 jsr %a5@
the_segment = (void **) _Region_Allocate_segment(
the_region,
the_thread->Wait.count
);
if ( the_segment == NULL )
56b5c: 4fef 0010 lea %sp@(16),%sp
56b60: 4a80 tstl %d0
56b62: 6718 beqs 56b7c <_Region_Process_queue+0x84>
break;
*(void **)the_thread->Wait.return_argument = the_segment;
56b64: 206a 0028 moveal %a2@(40),%a0
the_region->number_of_used_blocks += 1;
56b68: 52ab 0064 addql #1,%a3@(100)
);
if ( the_segment == NULL )
break;
*(void **)the_thread->Wait.return_argument = the_segment;
56b6c: 2080 movel %d0,%a0@
the_region->number_of_used_blocks += 1;
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
56b6e: 2f0a movel %a2,%sp@-
56b70: 2f02 movel %d2,%sp@-
56b72: 4e94 jsr %a4@
the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
}
56b74: 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;
56b76: 42aa 0034 clrl %a2@(52)
}
56b7a: 60c6 bras 56b42 <_Region_Process_queue+0x4a>
_Thread_Enable_dispatch();
}
56b7c: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5
56b82: 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();
56b84: 4ef9 0005 3ec6 jmp 53ec6 <_Thread_Enable_dispatch>
...
00046d14 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
46d14: 4e56 ffec linkw %fp,#-20
46d18: 48d7 043c moveml %d2-%d5/%a2,%sp@
46d1c: 242e 0014 movel %fp@(20),%d2
46d20: 246e 000c moveal %fp@(12),%a2
/*
* Allocate and Initialize the stack for this thread.
*/
#if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
46d24: 2f02 movel %d2,%sp@-
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
46d26: 262e 0018 movel %fp@(24),%d3
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
46d2a: 42aa 0108 clrl %a2@(264)
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
46d2e: 282e 001c movel %fp@(28),%d4
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
46d32: 42aa 010c clrl %a2@(268)
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
46d36: 1a2e 0023 moveb %fp@(35),%d5
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
46d3a: 42aa 0110 clrl %a2@(272)
extensions_area = NULL;
the_thread->libc_reent = NULL;
46d3e: 42aa 0104 clrl %a2@(260)
/*
* Allocate and Initialize the stack for this thread.
*/
#if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
46d42: 2f0a movel %a2,%sp@-
46d44: 4eb9 0004 75cc jsr 475cc <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
46d4a: 508f addql #8,%sp
46d4c: 4a80 tstl %d0
46d4e: 6700 015a beqw 46eaa <_Thread_Initialize+0x196>
46d52: b480 cmpl %d0,%d2
46d54: 6200 0154 bhiw 46eaa <_Thread_Initialize+0x196>
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
the_stack->size = size;
46d58: 2540 00bc movel %d0,%a2@(188)
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
46d5c: 256a 00c8 00c0 movel %a2@(200),%a2@(192)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
46d62: 4a03 tstb %d3
46d64: 6604 bnes 46d6a <_Thread_Initialize+0x56>
46d66: 4283 clrl %d3
46d68: 6016 bras 46d80 <_Thread_Initialize+0x6c>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
46d6a: 4878 001c pea 1c <OPER2+0x8>
46d6e: 4eb9 0004 7dbc jsr 47dbc <_Workspace_Allocate>
if ( !fp_area )
46d74: 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 );
46d76: 2600 movel %d0,%d3
if ( !fp_area )
46d78: 6606 bnes 46d80 <_Thread_Initialize+0x6c>
46d7a: 4282 clrl %d2
46d7c: 6000 00c6 braw 46e44 <_Thread_Initialize+0x130>
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
46d80: 2039 0005 bb16 movel 5bb16 <_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;
46d86: 2543 0100 movel %d3,%a2@(256)
the_thread->Start.fp_context = fp_area;
46d8a: 2543 00c4 movel %d3,%a2@(196)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
46d8e: 42aa 0050 clrl %a2@(80)
the_watchdog->routine = routine;
46d92: 42aa 0064 clrl %a2@(100)
the_watchdog->id = id;
46d96: 42aa 0068 clrl %a2@(104)
the_watchdog->user_data = user_data;
46d9a: 42aa 006c clrl %a2@(108)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
46d9e: 4a80 tstl %d0
46da0: 6604 bnes 46da6 <_Thread_Initialize+0x92>
46da2: 4282 clrl %d2
46da4: 6016 bras 46dbc <_Thread_Initialize+0xa8>
extensions_area = _Workspace_Allocate(
46da6: e588 lsll #2,%d0
46da8: 2040 moveal %d0,%a0
46daa: 4868 0004 pea %a0@(4)
46dae: 4eb9 0004 7dbc jsr 47dbc <_Workspace_Allocate>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
46db4: 588f addql #4,%sp
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
46db6: 2400 movel %d0,%d2
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
46db8: 6700 008a beqw 46e44 <_Thread_Initialize+0x130>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
46dbc: 2542 0114 movel %d2,%a2@(276)
* 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 ) {
46dc0: 6718 beqs 46dda <_Thread_Initialize+0xc6>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
46dc2: 2239 0005 bb16 movel 5bb16 <_Thread_Maximum_extensions>,%d1
46dc8: 4280 clrl %d0
46dca: 600a bras 46dd6 <_Thread_Initialize+0xc2>
the_thread->extensions[i] = NULL;
46dcc: 206a 0114 moveal %a2@(276),%a0
46dd0: 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++ )
46dd4: 5280 addql #1,%d0
46dd6: b280 cmpl %d0,%d1
46dd8: 64f2 bccs 46dcc <_Thread_Initialize+0xb8>
#if defined(RTEMS_ITRON_API)
the_thread->suspend_count = 0;
#endif
the_thread->real_priority = priority;
the_thread->Start.initial_priority = priority;
_Thread_Set_priority( the_thread, priority );
46dda: 2f04 movel %d4,%sp@-
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
46ddc: 256e 002c 00b4 movel %fp@(44),%a2@(180)
the_thread->current_state = STATES_DORMANT;
46de2: 7001 moveq #1,%d0
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
46de4: 256e 0024 00ac movel %fp@(36),%a2@(172)
the_thread->Start.budget_callout = budget_callout;
46dea: 256e 0028 00b0 movel %fp@(40),%a2@(176)
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
46df0: 1545 00aa moveb %d5,%a2@(170)
#if defined(RTEMS_ITRON_API)
the_thread->suspend_count = 0;
#endif
the_thread->real_priority = priority;
the_thread->Start.initial_priority = priority;
_Thread_Set_priority( the_thread, priority );
46df4: 2f0a movel %a2,%sp@-
#endif
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
46df6: 2540 0010 movel %d0,%a2@(16)
the_thread->Wait.queue = NULL;
46dfa: 42aa 0044 clrl %a2@(68)
the_thread->resource_count = 0;
46dfe: 42aa 001c clrl %a2@(28)
#if defined(RTEMS_ITRON_API)
the_thread->suspend_count = 0;
#endif
the_thread->real_priority = priority;
46e02: 2544 0018 movel %d4,%a2@(24)
the_thread->Start.initial_priority = priority;
46e06: 2544 00b8 movel %d4,%a2@(184)
_Thread_Set_priority( the_thread, priority );
46e0a: 4eb9 0004 73f8 jsr 473f8 <_Thread_Set_priority>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
46e10: 206e 0008 moveal %fp@(8),%a0
46e14: 4280 clrl %d0
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
46e16: 256e 0030 000c movel %fp@(48),%a2@(12)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
46e1c: 2068 0018 moveal %a0@(24),%a0
46e20: 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 );
46e24: 42aa 0082 clrl %a2@(130)
46e28: 218a 0c00 movel %a2,%a0@(00000000,%d0:l:4)
46e2c: 42aa 0086 clrl %a2@(134)
* 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 );
46e30: 2f0a movel %a2,%sp@-
46e32: 4eb9 0004 7a78 jsr 47a78 <_User_extensions_Thread_create>
if ( extension_status )
46e38: 4fef 000c lea %sp@(12),%sp
46e3c: 4a00 tstb %d0
46e3e: 6704 beqs 46e44 <_Thread_Initialize+0x130>
46e40: 7001 moveq #1,%d0
46e42: 6068 bras 46eac <_Thread_Initialize+0x198>
return true;
failed:
if ( the_thread->libc_reent )
46e44: 202a 0104 movel %a2@(260),%d0
46e48: 670a beqs 46e54 <_Thread_Initialize+0x140>
_Workspace_Free( the_thread->libc_reent );
46e4a: 2f00 movel %d0,%sp@-
46e4c: 4eb9 0004 7dd8 jsr 47dd8 <_Workspace_Free>
46e52: 588f addql #4,%sp
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
46e54: 202a 0108 movel %a2@(264),%d0
46e58: 670a beqs 46e64 <_Thread_Initialize+0x150>
_Workspace_Free( the_thread->API_Extensions[i] );
46e5a: 2f00 movel %d0,%sp@-
46e5c: 4eb9 0004 7dd8 jsr 47dd8 <_Workspace_Free>
46e62: 588f addql #4,%sp
failed:
if ( the_thread->libc_reent )
_Workspace_Free( the_thread->libc_reent );
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
46e64: 202a 010c movel %a2@(268),%d0
46e68: 670a beqs 46e74 <_Thread_Initialize+0x160>
_Workspace_Free( the_thread->API_Extensions[i] );
46e6a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
46e6c: 4eb9 0004 7dd8 jsr 47dd8 <_Workspace_Free> <== NOT EXECUTED
46e72: 588f addql #4,%sp <== NOT EXECUTED
failed:
if ( the_thread->libc_reent )
_Workspace_Free( the_thread->libc_reent );
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
46e74: 202a 0110 movel %a2@(272),%d0
46e78: 670a beqs 46e84 <_Thread_Initialize+0x170>
_Workspace_Free( the_thread->API_Extensions[i] );
46e7a: 2f00 movel %d0,%sp@- <== NOT EXECUTED
46e7c: 4eb9 0004 7dd8 jsr 47dd8 <_Workspace_Free> <== NOT EXECUTED
46e82: 588f addql #4,%sp <== NOT EXECUTED
if ( extensions_area )
46e84: 4a82 tstl %d2
46e86: 670a beqs 46e92 <_Thread_Initialize+0x17e>
(void) _Workspace_Free( extensions_area );
46e88: 2f02 movel %d2,%sp@-
46e8a: 4eb9 0004 7dd8 jsr 47dd8 <_Workspace_Free>
46e90: 588f addql #4,%sp
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
46e92: 4a83 tstl %d3
46e94: 670a beqs 46ea0 <_Thread_Initialize+0x18c>
(void) _Workspace_Free( fp_area );
46e96: 2f03 movel %d3,%sp@-
46e98: 4eb9 0004 7dd8 jsr 47dd8 <_Workspace_Free>
46e9e: 588f addql #4,%sp
#endif
_Thread_Stack_Free( the_thread );
46ea0: 2f0a movel %a2,%sp@-
46ea2: 4eb9 0004 7618 jsr 47618 <_Thread_Stack_Free>
return false;
46ea8: 588f addql #4,%sp
46eaa: 4200 clrb %d0
}
46eac: 4cee 043c ffec moveml %fp@(-20),%d2-%d5/%a2
46eb2: 4e5e unlk %fp
...
00047b6c <_Thread_Restart>:
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
if ( !_States_Is_dormant( the_thread->current_state ) ) {
47b6c: 7001 moveq #1,%d0
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
47b6e: 4e56 0000 linkw %fp,#0
47b72: 2f0a movel %a2,%sp@-
47b74: 246e 0008 moveal %fp@(8),%a2
if ( !_States_Is_dormant( the_thread->current_state ) ) {
47b78: c0aa 0010 andl %a2@(16),%d0
47b7c: 4a00 tstb %d0
47b7e: 6704 beqs 47b84 <_Thread_Restart+0x18>
47b80: 4200 clrb %d0
47b82: 6064 bras 47be8 <_Thread_Restart+0x7c>
_Thread_Set_transient( the_thread );
47b84: 2f0a movel %a2,%sp@-
47b86: 4eb9 0004 7d48 jsr 47d48 <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
47b8c: 2f2e 0010 movel %fp@(16),%sp@-
47b90: 2f2e 000c movel %fp@(12),%sp@-
47b94: 2f0a movel %a2,%sp@-
47b96: 4eb9 0004 aa10 jsr 4aa10 <_Thread_Reset>
_Thread_Load_environment( the_thread );
47b9c: 2f0a movel %a2,%sp@-
47b9e: 4eb9 0004 a6ac jsr 4a6ac <_Thread_Load_environment>
_Thread_Ready( the_thread );
47ba4: 2f0a movel %a2,%sp@-
47ba6: 4eb9 0004 a950 jsr 4a950 <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
47bac: 2f0a movel %a2,%sp@-
47bae: 4eb9 0004 82f4 jsr 482f4 <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
47bb4: 4fef 001c lea %sp@(28),%sp
47bb8: b5f9 0005 c61a cmpal 5c61a <_Thread_Executing>,%a2
47bbe: 6626 bnes 47be6 <_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 )
47bc0: 4aaa 0100 tstl %a2@(256)
47bc4: 670c beqs 47bd2 <_Thread_Restart+0x66>
_Context_Restore_fp( &_Thread_Executing->fp_context );
47bc6: 486a 0100 pea %a2@(256)
47bca: 4eb9 0004 87e4 jsr 487e4 <_CPU_Context_restore_fp>
47bd0: 588f addql #4,%sp
#endif
_CPU_Context_Restart_self( &_Thread_Executing->Registers );
47bd2: 2079 0005 c61a moveal 5c61a <_Thread_Executing>,%a0
47bd8: 41e8 00cc lea %a0@(204),%a0
47bdc: 2f08 movel %a0,%sp@-
47bde: 4eb9 0004 86a2 jsr 486a2 <_CPU_Context_Restart_self>
47be4: 588f addql #4,%sp <== NOT EXECUTED
47be6: 7001 moveq #1,%d0
return true;
}
return false;
}
47be8: 246e fffc moveal %fp@(-4),%a2
47bec: 4e5e unlk %fp <== NOT EXECUTED
00047618 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
47618: 4e56 0000 linkw %fp,#0
4761c: 206e 0008 moveal %fp@(8),%a0
* 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 )
47620: 2279 0005 a368 moveal 5a368 <Configuration+0x24>,%a1
47626: 4a89 tstl %a1
47628: 670a beqs 47634 <_Thread_Stack_Free+0x1c>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
4762a: 2d68 00c0 0008 movel %a0@(192),%fp@(8)
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
47630: 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 );
47632: 4ed1 jmp %a1@
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
47634: 2d68 00c0 0008 movel %a0@(192),%fp@(8)
}
4763a: 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 );
4763c: 4ef9 0004 7dd8 jmp 47dd8 <_Workspace_Free>
...
00046718 <_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 ) ) {
46718: 7202 moveq #2,%d1
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
4671a: 4e56 0000 linkw %fp,#0
4671e: 202e 0010 movel %fp@(16),%d0
46722: 2f0a movel %a2,%sp@-
46724: 246e 000c moveal %fp@(12),%a2
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
46728: 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 ) ) {
4672c: b2aa 0050 cmpl %a2@(80),%d1
46730: 6618 bnes 4674a <_Thread_blocking_operation_Cancel+0x32>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
46732: 123c 0003 moveb #3,%d1
46736: 2541 0050 movel %d1,%a2@(80)
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4673a: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
4673c: 486a 0048 pea %a2@(72)
46740: 4eb9 0004 7c90 jsr 47c90 <_Watchdog_Remove>
46746: 588f addql #4,%sp
46748: 6002 bras 4674c <_Thread_blocking_operation_Cancel+0x34>
} else
_ISR_Enable( level );
4674a: 46c0 movew %d0,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4674c: 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
}
46750: 246e fffc moveal %fp@(-4),%a2
46754: 203c 1003 fff8 movel #268697592,%d0
4675a: 2d40 000c movel %d0,%fp@(12)
4675e: 4e5e unlk %fp
46760: 4ef9 0004 68a8 jmp 468a8 <_Thread_Clear_state>
...
0004716c <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
4716c: 4e56 ffe4 linkw %fp,#-28
47170: 206e 000c moveal %fp@(12),%a0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
47174: 43e8 003c lea %a0@(60),%a1
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
47178: 2028 0014 movel %a0@(20),%d0
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
4717c: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
47180: 2400 movel %d0,%d2
47182: ec8a lsrl #6,%d2
47184: 2202 movel %d2,%d1
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
47186: 283c 0000 0700 movel #1792,%d4
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
4718c: e989 lsll #4,%d1
4718e: e58a lsll #2,%d2
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
47190: 246e 0008 moveal %fp@(8),%a2
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
47194: 9282 subl %d2,%d1
47196: 47f2 1800 lea %a2@(00000000,%d1:l),%a3
4719a: 2149 0038 movel %a1,%a0@(56)
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
4719e: 43e8 0038 lea %a0@(56),%a1
block_state = the_thread_queue->state;
471a2: 2a2a 0038 movel %a2@(56),%d5
471a6: 2149 0040 movel %a1,%a0@(64)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
471aa: 42a8 003c clrl %a0@(60)
if ( _Thread_queue_Is_reverse_search( priority ) )
471ae: 0800 0005 btst #5,%d0
471b2: 6660 bnes 47214 <_Thread_queue_Enqueue_priority+0xa8>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
471b4: 2c0b movel %a3,%d6
471b6: 5886 addql #4,%d6
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
471b8: 2404 movel %d4,%d2
471ba: 40c1 movew %sr,%d1
471bc: 8481 orl %d1,%d2
471be: 46c2 movew %d2,%sr
search_thread = (Thread_Control *) header->first;
471c0: 2253 moveal %a3@,%a1
471c2: 76ff moveq #-1,%d3
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
471c4: 601e bras 471e4 <_Thread_queue_Enqueue_priority+0x78>
search_priority = search_thread->current_priority;
471c6: 2629 0014 movel %a1@(20),%d3
if ( priority <= search_priority )
471ca: b680 cmpl %d0,%d3
471cc: 641a bccs 471e8 <_Thread_queue_Enqueue_priority+0x7c>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
471ce: 2404 movel %d4,%d2
471d0: 46c1 movew %d1,%sr
471d2: 8481 orl %d1,%d2
471d4: 46c2 movew %d2,%sr
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
471d6: 2405 movel %d5,%d2
471d8: c4a9 0010 andl %a1@(16),%d2
471dc: 6604 bnes 471e2 <_Thread_queue_Enqueue_priority+0x76>
_ISR_Enable( level );
471de: 46c1 movew %d1,%sr <== NOT EXECUTED
goto restart_forward_search;
471e0: 60d6 bras 471b8 <_Thread_queue_Enqueue_priority+0x4c><== NOT EXECUTED
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
471e2: 2251 moveal %a1@,%a1
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
471e4: bc89 cmpl %a1,%d6
471e6: 66de bnes 471c6 <_Thread_queue_Enqueue_priority+0x5a>
471e8: 2401 movel %d1,%d2
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
471ea: 7801 moveq #1,%d4
471ec: b8aa 0030 cmpl %a2@(48),%d4
471f0: 6600 00a4 bnew 47296 <_Thread_queue_Enqueue_priority+0x12a>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
471f4: 42aa 0030 clrl %a2@(48)
if ( priority == search_priority )
471f8: b680 cmpl %d0,%d3
471fa: 677e beqs 4727a <_Thread_queue_Enqueue_priority+0x10e>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
471fc: 2669 0004 moveal %a1@(4),%a3
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
47200: 2089 movel %a1,%a0@
the_node->previous = previous_node;
47202: 214b 0004 movel %a3,%a0@(4)
previous_node->next = the_node;
search_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
47206: 214a 0044 movel %a2,%a0@(68)
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
4720a: 2688 movel %a0,%a3@
search_node->previous = the_node;
4720c: 2348 0004 movel %a0,%a1@(4)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
47210: 46c1 movew %d1,%sr
47212: 6062 bras 47276 <_Thread_queue_Enqueue_priority+0x10a>
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
47214: 4283 clrl %d3
47216: 1639 0005 a342 moveb 5a342 <rtems_maximum_priority>,%d3
_ISR_Disable( level );
4721c: 2404 movel %d4,%d2
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
4721e: 5283 addql #1,%d3
_ISR_Disable( level );
47220: 40c1 movew %sr,%d1
47222: 8481 orl %d1,%d2
47224: 46c2 movew %d2,%sr
search_thread = (Thread_Control *) header->last;
47226: 226b 0008 moveal %a3@(8),%a1
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
4722a: 6020 bras 4724c <_Thread_queue_Enqueue_priority+0xe0>
search_priority = search_thread->current_priority;
4722c: 2629 0014 movel %a1@(20),%d3
if ( priority >= search_priority )
47230: b680 cmpl %d0,%d3
47232: 631c blss 47250 <_Thread_queue_Enqueue_priority+0xe4>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
47234: 2404 movel %d4,%d2
47236: 46c1 movew %d1,%sr
47238: 8481 orl %d1,%d2
4723a: 46c2 movew %d2,%sr
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
4723c: 2405 movel %d5,%d2
4723e: c4a9 0010 andl %a1@(16),%d2
47242: 6604 bnes 47248 <_Thread_queue_Enqueue_priority+0xdc>
_ISR_Enable( level );
47244: 46c1 movew %d1,%sr
goto restart_reverse_search;
47246: 60cc bras 47214 <_Thread_queue_Enqueue_priority+0xa8>
}
search_thread = (Thread_Control *)
47248: 2269 0004 moveal %a1@(4),%a1
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
4724c: b7c9 cmpal %a1,%a3
4724e: 66dc bnes 4722c <_Thread_queue_Enqueue_priority+0xc0>
47250: 2401 movel %d1,%d2
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
47252: 7801 moveq #1,%d4
47254: b8aa 0030 cmpl %a2@(48),%d4
47258: 663c bnes 47296 <_Thread_queue_Enqueue_priority+0x12a>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
4725a: 42aa 0030 clrl %a2@(48)
if ( priority == search_priority )
4725e: b680 cmpl %d0,%d3
47260: 6718 beqs 4727a <_Thread_queue_Enqueue_priority+0x10e>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
47262: 2651 moveal %a1@,%a3
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
47264: 2149 0004 movel %a1,%a0@(4)
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
47268: 208b movel %a3,%a0@
the_node->previous = search_node;
search_node->next = the_node;
next_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
4726a: 214a 0044 movel %a2,%a0@(68)
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
4726e: 2288 movel %a0,%a1@
next_node->previous = the_node;
47270: 2748 0004 movel %a0,%a3@(4)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
47274: 46c1 movew %d1,%sr
47276: 7001 moveq #1,%d0
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
47278: 6026 bras 472a0 <_Thread_queue_Enqueue_priority+0x134>
4727a: 43e9 003c lea %a1@(60),%a1
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
4727e: 2669 0004 moveal %a1@(4),%a3
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
47282: 2089 movel %a1,%a0@
the_node->previous = previous_node;
47284: 214b 0004 movel %a3,%a0@(4)
previous_node->next = the_node;
search_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
47288: 214a 0044 movel %a2,%a0@(68)
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
4728c: 2688 movel %a0,%a3@
search_node->previous = the_node;
4728e: 2348 0004 movel %a0,%a1@(4)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
47292: 46c2 movew %d2,%sr
47294: 60e0 bras 47276 <_Thread_queue_Enqueue_priority+0x10a>
* For example, the blocking thread could have been given
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
47296: 206e 0010 moveal %fp@(16),%a0
return the_thread_queue->sync_state;
4729a: 202a 0030 movel %a2@(48),%d0
* For example, the blocking thread could have been given
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
4729e: 2082 movel %d2,%a0@
return the_thread_queue->sync_state;
}
472a0: 4cd7 0c7c moveml %sp@,%d2-%d6/%a2-%a3
472a4: 4e5e unlk %fp <== NOT EXECUTED
0004b588 <_Thread_queue_Extract_fifo>:
Thread_Control *the_thread
)
{
ISR_Level level;
_ISR_Disable( level );
4b588: 223c 0000 0700 movel #1792,%d1
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
4b58e: 4e56 0000 linkw %fp,#0
4b592: 2f0a movel %a2,%sp@-
4b594: 246e 000c moveal %fp@(12),%a2
ISR_Level level;
_ISR_Disable( level );
4b598: 40c0 movew %sr,%d0
4b59a: 8280 orl %d0,%d1
4b59c: 46c1 movew %d1,%sr
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4b59e: 222a 0010 movel %a2@(16),%d1
4b5a2: 0281 0003 bee0 andil #245472,%d1
4b5a8: 660a bnes 4b5b4 <_Thread_queue_Extract_fifo+0x2c>
_ISR_Enable( level );
4b5aa: 46c0 movew %d0,%sr
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
4b5ac: 246e fffc moveal %fp@(-4),%a2
4b5b0: 4e5e unlk %fp
4b5b2: 4e75 rts
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4b5b4: 2052 moveal %a2@,%a0
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4b5b6: 7202 moveq #2,%d1
previous = the_node->previous;
4b5b8: 226a 0004 moveal %a2@(4),%a1
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
4b5bc: 42aa 0044 clrl %a2@(68)
next->previous = previous;
previous->next = next;
4b5c0: 2288 movel %a0,%a1@
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
4b5c2: 2149 0004 movel %a1,%a0@(4)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4b5c6: b2aa 0050 cmpl %a2@(80),%d1
4b5ca: 6704 beqs 4b5d0 <_Thread_queue_Extract_fifo+0x48>
_ISR_Enable( level );
4b5cc: 46c0 movew %d0,%sr
4b5ce: 6014 bras 4b5e4 <_Thread_queue_Extract_fifo+0x5c>
4b5d0: 7203 moveq #3,%d1
4b5d2: 2541 0050 movel %d1,%a2@(80)
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4b5d6: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
4b5d8: 486a 0048 pea %a2@(72)
4b5dc: 4eb9 0004 7c90 jsr 47c90 <_Watchdog_Remove>
4b5e2: 588f addql #4,%sp
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4b5e4: 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
}
4b5e8: 246e fffc moveal %fp@(-4),%a2
4b5ec: 203c 1003 fff8 movel #268697592,%d0
4b5f2: 2d40 000c movel %d0,%fp@(12)
4b5f6: 4e5e unlk %fp
4b5f8: 4ef9 0004 68a8 jmp 468a8 <_Thread_Clear_state>
...
00051644 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
51644: 4e56 ffb4 linkw %fp,#-76
51648: 200e movel %fp,%d0
5164a: 0680 ffff fff4 addil #-12,%d0
51650: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
51654: 246e 0008 moveal %fp@(8),%a2
51658: 240e movel %fp,%d2
5165a: 2a0e movel %fp,%d5
5165c: 260e movel %fp,%d3
5165e: 0682 ffff ffe8 addil #-24,%d2
51664: 5185 subql #8,%d5
51666: 0683 ffff ffec addil #-20,%d3
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
5166c: 41ea 0008 lea %a2@(8),%a0
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
51670: 4bea 0040 lea %a2@(64),%a5
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51674: 2e0a movel %a2,%d7
/*
* 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 );
51676: 280a movel %a2,%d4
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51678: 0687 0000 0030 addil #48,%d7
/*
* 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 );
5167e: 0684 0000 0068 addil #104,%d4
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
51684: 49f9 0005 5054 lea 55054 <_Watchdog_Adjust_to_chain>,%a4
)
{
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 );
5168a: 47f9 0005 50e4 lea 550e4 <_Watchdog_Insert>,%a3
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
51690: 2d48 ffe4 movel %a0,%fp@(-28)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
51694: 2d45 fff4 movel %d5,%fp@(-12)
the_chain->permanent_null = NULL;
51698: 42ae fff8 clrl %fp@(-8)
the_chain->last = _Chain_Head(the_chain);
5169c: 2d40 fffc movel %d0,%fp@(-4)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
516a0: 2d43 ffe8 movel %d3,%fp@(-24)
the_chain->permanent_null = NULL;
516a4: 42ae ffec clrl %fp@(-20)
the_chain->last = _Chain_Head(the_chain);
516a8: 2d42 fff0 movel %d2,%fp@(-16)
516ac: 2d4d ffe0 movel %a5,%fp@(-32)
{
/*
* 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;
516b0: 41ee fff4 lea %fp@(-12),%a0
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
516b4: 3a7c 0700 moveaw #1792,%a5
{
/*
* 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;
516b8: 2548 0078 movel %a0,%a2@(120)
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
516bc: 2039 0007 41c4 movel 741c4 <_Watchdog_Ticks_since_boot>,%d0
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
516c2: 222a 003c movel %a2@(60),%d1
watchdogs->last_snapshot = snapshot;
516c6: 2540 003c movel %d0,%a2@(60)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
516ca: 486e ffe8 pea %fp@(-24)
516ce: 9081 subl %d1,%d0
516d0: 2f00 movel %d0,%sp@-
516d2: 2f07 movel %d7,%sp@-
516d4: 4e94 jsr %a4@
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
516d6: 2039 0007 4116 movel 74116 <_TOD_Now>,%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 ) {
516dc: 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;
516e0: 222a 0074 movel %a2@(116),%d1
/*
* 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 ) {
516e4: b280 cmpl %d0,%d1
516e6: 6414 bccs 516fc <_Timer_server_Body+0xb8>
/*
* 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 );
516e8: 486e ffe8 pea %fp@(-24)
516ec: 2c00 movel %d0,%d6
516ee: 9c81 subl %d1,%d6
516f0: 2f06 movel %d6,%sp@-
516f2: 2d40 ffdc movel %d0,%fp@(-36)
516f6: 2f04 movel %d4,%sp@-
516f8: 4e94 jsr %a4@
516fa: 6018 bras 51714 <_Timer_server_Body+0xd0>
} else if ( snapshot < last_snapshot ) {
516fc: b280 cmpl %d0,%d1
516fe: 631c blss 5171c <_Timer_server_Body+0xd8>
/*
* 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 );
51700: 9280 subl %d0,%d1
51702: 2f01 movel %d1,%sp@-
51704: 4878 0001 pea 1 <ADD>
51708: 2d40 ffdc movel %d0,%fp@(-36)
5170c: 2f04 movel %d4,%sp@-
5170e: 4eb9 0005 4fd4 jsr 54fd4 <_Watchdog_Adjust>
51714: 202e ffdc movel %fp@(-36),%d0
51718: 4fef 000c lea %sp@(12),%sp
}
watchdogs->last_snapshot = snapshot;
5171c: 2540 0074 movel %d0,%a2@(116)
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
51720: 202a 0078 movel %a2@(120),%d0
51724: 2f00 movel %d0,%sp@-
51726: 4eb9 0005 1fb8 jsr 51fb8 <_Chain_Get>
if ( timer == NULL ) {
5172c: 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 );
5172e: 2040 moveal %d0,%a0
if ( timer == NULL ) {
51730: 4a80 tstl %d0
51732: 6724 beqs 51758 <_Timer_server_Body+0x114>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51734: 2028 0038 movel %a0@(56),%d0 <== NOT EXECUTED
51738: 7201 moveq #1,%d1 <== NOT EXECUTED
5173a: b280 cmpl %d0,%d1 <== NOT EXECUTED
5173c: 6608 bnes 51746 <_Timer_server_Body+0x102> <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
5173e: 4868 0010 pea %a0@(16) <== NOT EXECUTED
51742: 2f07 movel %d7,%sp@- <== NOT EXECUTED
51744: 600c bras 51752 <_Timer_server_Body+0x10e> <== NOT EXECUTED
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
51746: 7c03 moveq #3,%d6 <== NOT EXECUTED
51748: bc80 cmpl %d0,%d6 <== NOT EXECUTED
5174a: 66d4 bnes 51720 <_Timer_server_Body+0xdc> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
5174c: 4868 0010 pea %a0@(16) <== NOT EXECUTED
51750: 2f04 movel %d4,%sp@- <== NOT EXECUTED
51752: 4e93 jsr %a3@ <== NOT EXECUTED
51754: 508f addql #8,%sp <== NOT EXECUTED
51756: 60c8 bras 51720 <_Timer_server_Body+0xdc> <== 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 );
51758: 200d movel %a5,%d0
5175a: 40c1 movew %sr,%d1
5175c: 8081 orl %d1,%d0
5175e: 46c0 movew %d0,%sr
if ( _Chain_Is_empty( insert_chain ) ) {
51760: baae fff4 cmpl %fp@(-12),%d5
51764: 6612 bnes 51778 <_Timer_server_Body+0x134>
ts->insert_chain = NULL;
51766: 42aa 0078 clrl %a2@(120)
_ISR_Enable( level );
5176a: 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 );
5176c: 3a7c 0700 moveaw #1792,%a5
_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 ) ) {
51770: b6ae ffe8 cmpl %fp@(-24),%d3
51774: 6608 bnes 5177e <_Timer_server_Body+0x13a>
51776: 6042 bras 517ba <_Timer_server_Body+0x176>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
51778: 46c1 movew %d1,%sr <== NOT EXECUTED
5177a: 6000 ff40 braw 516bc <_Timer_server_Body+0x78> <== 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 );
5177e: 220d movel %a5,%d1
51780: 40c0 movew %sr,%d0
51782: 8280 orl %d0,%d1
51784: 46c1 movew %d1,%sr
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
51786: 206e ffe8 moveal %fp@(-24),%a0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
5178a: b688 cmpl %a0,%d3
5178c: 6726 beqs 517b4 <_Timer_server_Body+0x170>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
5178e: 2250 moveal %a0@,%a1
the_chain->first = new_first;
51790: 2d49 ffe8 movel %a1,%fp@(-24)
new_first->previous = _Chain_Head(the_chain);
51794: 2342 0004 movel %d2,%a1@(4)
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
51798: 4a88 tstl %a0
5179a: 6718 beqs 517b4 <_Timer_server_Body+0x170>
watchdog->state = WATCHDOG_INACTIVE;
5179c: 42a8 0008 clrl %a0@(8)
_ISR_Enable( level );
517a0: 46c0 movew %d0,%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 );
517a2: 2f28 0024 movel %a0@(36),%sp@-
517a6: 2f28 0020 movel %a0@(32),%sp@-
517aa: 2068 001c moveal %a0@(28),%a0
517ae: 4e90 jsr %a0@
}
517b0: 508f addql #8,%sp
517b2: 60ca bras 5177e <_Timer_server_Body+0x13a>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
517b4: 46c0 movew %d0,%sr
517b6: 6000 fef8 braw 516b0 <_Timer_server_Body+0x6c>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
517ba: 4200 clrb %d0
517bc: 1540 007c moveb %d0,%a2@(124)
517c0: 2039 0007 4084 movel 74084 <_Thread_Dispatch_disable_level>,%d0
517c6: 5280 addql #1,%d0
517c8: 23c0 0007 4084 movel %d0,74084 <_Thread_Dispatch_disable_level>
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
517ce: 4878 0008 pea 8 <DIVIDE_BY_ZERO>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
517d2: 4bf9 0005 5200 lea 55200 <_Watchdog_Remove>,%a5
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
517d8: 2f12 movel %a2@,%sp@-
517da: 4eb9 0005 4828 jsr 54828 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
517e0: 2f0a movel %a2,%sp@-
517e2: 4eba fd9c jsr %pc@(51580 <_Timer_server_Reset_interval_system_watchdog>)
_Timer_server_Reset_tod_system_watchdog( ts );
517e6: 2f0a movel %a2,%sp@-
517e8: 4eba fdf6 jsr %pc@(515e0 <_Timer_server_Reset_tod_system_watchdog>)
_Thread_Enable_dispatch();
517ec: 4eb9 0005 3ec6 jsr 53ec6 <_Thread_Enable_dispatch>
ts->active = true;
517f2: 7201 moveq #1,%d1
517f4: 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 );
517f8: 2f2e ffe4 movel %fp@(-28),%sp@-
517fc: 4e95 jsr %a5@
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
517fe: 2f2e ffe0 movel %fp@(-32),%sp@-
51802: 4e95 jsr %a5@
51804: 4fef 0018 lea %sp@(24),%sp
51808: 6000 fea6 braw 516b0 <_Timer_server_Body+0x6c>
0005180c <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
5180c: 4e56 fff0 linkw %fp,#-16
51810: 206e 000c moveal %fp@(12),%a0
51814: 48d7 041c moveml %d2-%d4/%a2,%sp@
51818: 246e 0008 moveal %fp@(8),%a2
if ( ts->insert_chain == NULL ) {
5181c: 202a 0078 movel %a2@(120),%d0
51820: 6600 00f8 bnew 5191a <_Timer_server_Schedule_operation_method+0x10e>
51824: 2039 0007 4084 movel 74084 <_Thread_Dispatch_disable_level>,%d0
5182a: 5280 addql #1,%d0
5182c: 23c0 0007 4084 movel %d0,74084 <_Thread_Dispatch_disable_level>
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51832: 2028 0038 movel %a0@(56),%d0
51836: 7201 moveq #1,%d1
51838: b280 cmpl %d0,%d1
5183a: 6660 bnes 5189c <_Timer_server_Schedule_operation_method+0x90>
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
5183c: 203c 0000 0700 movel #1792,%d0
51842: 40c3 movew %sr,%d3
51844: 8083 orl %d3,%d0
51846: 46c0 movew %d0,%sr
snapshot = _Watchdog_Ticks_since_boot;
51848: 2039 0007 41c4 movel 741c4 <_Watchdog_Ticks_since_boot>,%d0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
5184e: 220a movel %a2,%d1
51850: 0681 0000 0034 addil #52,%d1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
51856: 242a 003c movel %a2@(60),%d2
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
5185a: 226a 0030 moveal %a2@(48),%a1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
5185e: b289 cmpl %a1,%d1
51860: 6716 beqs 51878 <_Timer_server_Schedule_operation_method+0x6c>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
51862: 2800 movel %d0,%d4
51864: 9882 subl %d2,%d4
delta_interval = first_watchdog->delta_interval;
51866: 2229 0010 movel %a1@(16),%d1
if (delta_interval > delta) {
5186a: b881 cmpl %d1,%d4
5186c: 6504 bcss 51872 <_Timer_server_Schedule_operation_method+0x66>
5186e: 4281 clrl %d1
51870: 6002 bras 51874 <_Timer_server_Schedule_operation_method+0x68>
delta_interval -= delta;
51872: 9284 subl %d4,%d1
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
51874: 2341 0010 movel %d1,%a1@(16)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
51878: 2540 003c movel %d0,%a2@(60)
_ISR_Enable( level );
5187c: 46c3 movew %d3,%sr
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
5187e: 4868 0010 pea %a0@(16)
51882: 486a 0030 pea %a2@(48)
51886: 4eb9 0005 50e4 jsr 550e4 <_Watchdog_Insert>
if ( !ts->active ) {
5188c: 508f addql #8,%sp
5188e: 102a 007c moveb %a2@(124),%d0
51892: 6678 bnes 5190c <_Timer_server_Schedule_operation_method+0x100>
_Timer_server_Reset_interval_system_watchdog( ts );
51894: 2f0a movel %a2,%sp@-
51896: 4eba fce8 jsr %pc@(51580 <_Timer_server_Reset_interval_system_watchdog>)
5189a: 606e bras 5190a <_Timer_server_Schedule_operation_method+0xfe>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
5189c: 7203 moveq #3,%d1
5189e: b280 cmpl %d0,%d1
518a0: 666a bnes 5190c <_Timer_server_Schedule_operation_method+0x100>
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
518a2: 203c 0000 0700 movel #1792,%d0
518a8: 40c3 movew %sr,%d3
518aa: 8083 orl %d3,%d0
518ac: 46c0 movew %d0,%sr
518ae: 200a movel %a2,%d0
518b0: 0680 0000 006c addil #108,%d0
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
518b6: 2239 0007 4116 movel 74116 <_TOD_Now>,%d1
last_snapshot = ts->TOD_watchdogs.last_snapshot;
518bc: 242a 0074 movel %a2@(116),%d2
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
518c0: 226a 0068 moveal %a2@(104),%a1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
518c4: b089 cmpl %a1,%d0
518c6: 6720 beqs 518e8 <_Timer_server_Schedule_operation_method+0xdc>
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
518c8: 2029 0010 movel %a1@(16),%d0
if ( snapshot > last_snapshot ) {
518cc: b481 cmpl %d1,%d2
518ce: 6410 bccs 518e0 <_Timer_server_Schedule_operation_method+0xd4>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
518d0: 2801 movel %d1,%d4
518d2: 9882 subl %d2,%d4
if (delta_interval > delta) {
518d4: b880 cmpl %d0,%d4
518d6: 6504 bcss 518dc <_Timer_server_Schedule_operation_method+0xd0>
518d8: 4280 clrl %d0 <== NOT EXECUTED
518da: 6008 bras 518e4 <_Timer_server_Schedule_operation_method+0xd8><== NOT EXECUTED
delta_interval -= delta;
518dc: 9084 subl %d4,%d0
518de: 6004 bras 518e4 <_Timer_server_Schedule_operation_method+0xd8>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
518e0: d082 addl %d2,%d0
delta_interval += delta;
518e2: 9081 subl %d1,%d0
}
first_watchdog->delta_interval = delta_interval;
518e4: 2340 0010 movel %d0,%a1@(16)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
518e8: 2541 0074 movel %d1,%a2@(116)
_ISR_Enable( level );
518ec: 46c3 movew %d3,%sr
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
518ee: 4868 0010 pea %a0@(16)
518f2: 486a 0068 pea %a2@(104)
518f6: 4eb9 0005 50e4 jsr 550e4 <_Watchdog_Insert>
if ( !ts->active ) {
518fc: 508f addql #8,%sp
518fe: 102a 007c moveb %a2@(124),%d0
51902: 6608 bnes 5190c <_Timer_server_Schedule_operation_method+0x100>
_Timer_server_Reset_tod_system_watchdog( ts );
51904: 2f0a movel %a2,%sp@-
51906: 4eba fcd8 jsr %pc@(515e0 <_Timer_server_Reset_tod_system_watchdog>)
5190a: 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 );
}
}
5190c: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2
51912: 4e5e unlk %fp
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
51914: 4ef9 0005 3ec6 jmp 53ec6 <_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 );
5191a: 202a 0078 movel %a2@(120),%d0 <== NOT EXECUTED
5191e: 2d48 000c movel %a0,%fp@(12) <== NOT EXECUTED
}
}
51922: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 <== 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 );
51928: 2d40 0008 movel %d0,%fp@(8) <== NOT EXECUTED
}
}
5192c: 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 );
5192e: 4ef9 0005 1f80 jmp 51f80 <_Chain_Append> <== NOT EXECUTED
00071008 <_Timespec_Greater_than>:
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
71008: 4e56 0000 linkw %fp,#0
7100c: 226e 0008 moveal %fp@(8),%a1
71010: 206e 000c moveal %fp@(12),%a0
if ( lhs->tv_sec > rhs->tv_sec )
71014: 2211 movel %a1@,%d1
71016: 2010 movel %a0@,%d0
71018: b081 cmpl %d1,%d0
7101a: 6c04 bges 71020 <_Timespec_Greater_than+0x18>
7101c: 7001 moveq #1,%d0
7101e: 6014 bras 71034 <_Timespec_Greater_than+0x2c>
return true;
if ( lhs->tv_sec < rhs->tv_sec )
71020: b081 cmpl %d1,%d0
71022: 6f04 bles 71028 <_Timespec_Greater_than+0x20>
71024: 4200 clrb %d0 <== NOT EXECUTED
71026: 600c bras 71034 <_Timespec_Greater_than+0x2c> <== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Greater_than(
71028: 2068 0004 moveal %a0@(4),%a0
7102c: b1e9 0004 cmpal %a1@(4),%a0
71030: 5dc0 slt %d0
71032: 4480 negl %d0
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
return true;
return false;
}
71034: 4e5e unlk %fp <== NOT EXECUTED
000479f4 <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
479f4: 4e56 0000 linkw %fp,#0
479f8: 2f0a movel %a2,%sp@-
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
479fa: 2479 0005 bc0e moveal 5bc0e <_User_extensions_List+0x8>,%a2
}
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
47a00: 2f02 movel %d2,%sp@-
47a02: 242e 0008 movel %fp@(8),%d2
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
47a06: 6012 bras 47a1a <_User_extensions_Thread_exitted+0x26>
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
47a08: 206a 002c moveal %a2@(44),%a0
47a0c: 4a88 tstl %a0
47a0e: 6706 beqs 47a16 <_User_extensions_Thread_exitted+0x22>
(*the_extension->Callouts.thread_exitted)( executing );
47a10: 2f02 movel %d2,%sp@-
47a12: 4e90 jsr %a0@
47a14: 588f addql #4,%sp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
47a16: 246a 0004 moveal %a2@(4),%a2
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
47a1a: b5fc 0005 bc06 cmpal #375814,%a2
47a20: 66e6 bnes 47a08 <_User_extensions_Thread_exitted+0x14>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
(*the_extension->Callouts.thread_exitted)( executing );
}
}
47a22: 242e fff8 movel %fp@(-8),%d2
47a26: 246e fffc moveal %fp@(-4),%a2
47a2a: 4e5e unlk %fp <== NOT EXECUTED
00046d58 <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
)
{
46d58: 4e56 0000 linkw %fp,#0
46d5c: 206e 000c moveal %fp@(12),%a0
46d60: 2f0a movel %a2,%sp@-
46d62: 226e 0010 moveal %fp@(16),%a1
46d66: 2f02 movel %d2,%sp@-
46d68: 242e 0008 movel %fp@(8),%d2
rtems_device_major_number major_limit = _IO_Number_of_drivers;
46d6c: 2039 0006 1026 movel 61026 <_IO_Number_of_drivers>,%d0
if ( rtems_interrupt_is_in_progress() )
46d72: 2239 0006 0e7a movel 60e7a <_ISR_Nest_level>,%d1
46d78: 6706 beqs 46d80 <rtems_io_register_driver+0x28>
46d7a: 7012 moveq #18,%d0
46d7c: 6000 00d6 braw 46e54 <rtems_io_register_driver+0xfc>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
46d80: 4a89 tstl %a1
46d82: 6700 00ce beqw 46e52 <rtems_io_register_driver+0xfa>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
46d86: 2280 movel %d0,%a1@
if ( driver_table == NULL )
46d88: 4a88 tstl %a0
46d8a: 6700 00c6 beqw 46e52 <rtems_io_register_driver+0xfa>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46d8e: 4a90 tstl %a0@
46d90: 6600 00ce bnew 46e60 <rtems_io_register_driver+0x108>
46d94: 4aa8 0004 tstl %a0@(4)
46d98: 6600 00c6 bnew 46e60 <rtems_io_register_driver+0x108>
46d9c: 6000 00b4 braw 46e52 <rtems_io_register_driver+0xfa>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
46da0: 2039 0006 0de0 movel 60de0 <_Thread_Dispatch_disable_level>,%d0
46da6: 5280 addql #1,%d0
46da8: 23c0 0006 0de0 movel %d0,60de0 <_Thread_Dispatch_disable_level>
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
46dae: 4a82 tstl %d2
46db0: 662c bnes 46dde <rtems_io_register_driver+0x86>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
46db2: 2039 0006 1026 movel 61026 <_IO_Number_of_drivers>,%d0
46db8: 2479 0006 102a moveal 6102a <_IO_Driver_address_table>,%a2
46dbe: 6010 bras 46dd0 <rtems_io_register_driver+0x78>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
46dc0: 4a92 tstl %a2@
46dc2: 6600 00a6 bnew 46e6a <rtems_io_register_driver+0x112>
46dc6: 4aaa 0004 tstl %a2@(4)
46dca: 6600 009e bnew 46e6a <rtems_io_register_driver+0x112>
46dce: 6004 bras 46dd4 <rtems_io_register_driver+0x7c>
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 ) {
46dd0: b082 cmpl %d2,%d0
46dd2: 62ec bhis 46dc0 <rtems_io_register_driver+0x68>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
46dd4: 2282 movel %d2,%a1@
if ( m != n )
46dd6: b082 cmpl %d2,%d0
46dd8: 6634 bnes 46e0e <rtems_io_register_driver+0xb6>
46dda: 6000 0098 braw 46e74 <rtems_io_register_driver+0x11c>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
46dde: 2202 movel %d2,%d1
46de0: 2002 movel %d2,%d0
46de2: e789 lsll #3,%d1
46de4: eb88 lsll #5,%d0
46de6: 2479 0006 102a moveal 6102a <_IO_Driver_address_table>,%a2
46dec: 9081 subl %d1,%d0
46dee: 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;
46df0: 4a92 tstl %a2@
46df2: 660e bnes 46e02 <rtems_io_register_driver+0xaa>
46df4: 4aaa 0004 tstl %a2@(4)
46df8: 57c0 seq %d0
46dfa: 49c0 extbl %d0
46dfc: 4480 negl %d0
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
46dfe: 4a00 tstb %d0
46e00: 660a bnes 46e0c <rtems_io_register_driver+0xb4>
_Thread_Enable_dispatch();
46e02: 4eb9 0004 8606 jsr 48606 <_Thread_Enable_dispatch>
46e08: 700c moveq #12,%d0
return RTEMS_RESOURCE_IN_USE;
46e0a: 6048 bras 46e54 <rtems_io_register_driver+0xfc>
}
*registered_major = major;
46e0c: 2282 movel %d2,%a1@
}
_IO_Driver_address_table [major] = *driver_table;
46e0e: 4878 0018 pea 18 <OPER2+0x4>
46e12: 2202 movel %d2,%d1
46e14: 2002 movel %d2,%d0
46e16: e789 lsll #3,%d1
46e18: eb88 lsll #5,%d0
46e1a: 2f08 movel %a0,%sp@-
46e1c: 9081 subl %d1,%d0
46e1e: d0b9 0006 102a addl 6102a <_IO_Driver_address_table>,%d0
46e24: 2f00 movel %d0,%sp@-
46e26: 4eb9 0005 0c28 jsr 50c28 <memcpy>
_Thread_Enable_dispatch();
46e2c: 4eb9 0004 8606 jsr 48606 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
}
46e32: 246e fffc moveal %fp@(-4),%a2
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46e36: 4fef 000c lea %sp@(12),%sp
46e3a: 2d42 0008 movel %d2,%fp@(8)
}
46e3e: 242e fff8 movel %fp@(-8),%d2
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46e42: 42ae 0010 clrl %fp@(16)
46e46: 42ae 000c clrl %fp@(12)
}
46e4a: 4e5e unlk %fp
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
46e4c: 4ef9 0004 e11c jmp 4e11c <rtems_io_initialize>
46e52: 7009 moveq #9,%d0
}
46e54: 242e fff8 movel %fp@(-8),%d2
46e58: 246e fffc moveal %fp@(-4),%a2
46e5c: 4e5e unlk %fp
46e5e: 4e75 rts
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
46e60: b082 cmpl %d2,%d0
46e62: 6200 ff3c bhiw 46da0 <rtems_io_register_driver+0x48>
46e66: 700a moveq #10,%d0
46e68: 60ea bras 46e54 <rtems_io_register_driver+0xfc>
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 ) {
46e6a: 5282 addql #1,%d2
46e6c: 45ea 0018 lea %a2@(24),%a2
46e70: 6000 ff5e braw 46dd0 <rtems_io_register_driver+0x78>
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
46e74: 4eb9 0004 8606 jsr 48606 <_Thread_Enable_dispatch>
46e7a: 7005 moveq #5,%d0
return sc;
46e7c: 60d6 bras 46e54 <rtems_io_register_driver+0xfc>
...
0004f390 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
4f390: 4e56 fffc linkw %fp,#-4
4f394: 2f0a movel %a2,%sp@-
4f396: 2f02 movel %d2,%sp@-
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
4f398: 486e fffc pea %fp@(-4)
4f39c: 2f2e 0008 movel %fp@(8),%sp@-
4f3a0: 4879 0007 3f18 pea 73f18 <_Partition_Information>
4f3a6: 242e 000c movel %fp@(12),%d2
4f3aa: 4eb9 0005 366c jsr 5366c <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
4f3b0: 4fef 000c lea %sp@(12),%sp
4f3b4: 2440 moveal %d0,%a2
4f3b6: 4aae fffc tstl %fp@(-4)
4f3ba: 6704 beqs 4f3c0 <rtems_partition_return_buffer+0x30>
4f3bc: 7004 moveq #4,%d0
4f3be: 603c bras 4f3fc <rtems_partition_return_buffer+0x6c>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
4f3c0: 202a 0010 movel %a2@(16),%d0
ending = _Addresses_Add_offset( starting, the_partition->length );
4f3c4: 222a 0014 movel %a2@(20),%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
4f3c8: b082 cmpl %d2,%d0
4f3ca: 623c bhis 4f408 <rtems_partition_return_buffer+0x78>
4f3cc: d280 addl %d0,%d1
4f3ce: b282 cmpl %d2,%d1
4f3d0: 6536 bcss 4f408 <rtems_partition_return_buffer+0x78>
return (
4f3d2: 2202 movel %d2,%d1
4f3d4: 9280 subl %d0,%d1
4f3d6: 2001 movel %d1,%d0
4f3d8: 4c6a 0001 0018 remul %a2@(24),%d1,%d0
4f3de: 4a81 tstl %d1
4f3e0: 6626 bnes 4f408 <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 );
4f3e2: 2f02 movel %d2,%sp@-
4f3e4: 486a 0024 pea %a2@(36)
4f3e8: 4eb9 0005 1f80 jsr 51f80 <_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;
4f3ee: 53aa 0020 subql #1,%a2@(32)
_Thread_Enable_dispatch();
4f3f2: 4eb9 0005 3ec6 jsr 53ec6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4f3f8: 508f addql #8,%sp
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
4f3fa: 4280 clrl %d0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4f3fc: 242e fff4 movel %fp@(-12),%d2
4f400: 246e fff8 moveal %fp@(-8),%a2
4f404: 4e5e unlk %fp
4f406: 4e75 rts
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
4f408: 4eb9 0005 3ec6 jsr 53ec6 <_Thread_Enable_dispatch>
4f40e: 7009 moveq #9,%d0
return RTEMS_INVALID_ADDRESS;
4f410: 60ea bras 4f3fc <rtems_partition_return_buffer+0x6c>
...
0007085c <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
7085c: 4e56 ffec linkw %fp,#-20
70860: 48d7 041c moveml %d2-%d4/%a2,%sp@
70864: 486e fffc pea %fp@(-4)
70868: 262e 0008 movel %fp@(8),%d3
7086c: 2f03 movel %d3,%sp@-
7086e: 4879 0009 ac86 pea 9ac86 <_Rate_monotonic_Information>
70874: 242e 000c movel %fp@(12),%d2
70878: 4eb9 0004 a870 jsr 4a870 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
7087e: 4fef 000c lea %sp@(12),%sp
70882: 2440 moveal %d0,%a2
70884: 4aae fffc tstl %fp@(-4)
70888: 6600 0138 bnew 709c2 <rtems_rate_monotonic_period+0x166>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
7088c: 2039 0009 a916 movel 9a916 <_Thread_Executing>,%d0
70892: b0aa 0040 cmpl %a2@(64),%d0
70896: 670c beqs 708a4 <rtems_rate_monotonic_period+0x48>
_Thread_Enable_dispatch();
70898: 4eb9 0004 b106 jsr 4b106 <_Thread_Enable_dispatch>
7089e: 7817 moveq #23,%d4
return RTEMS_NOT_OWNER_OF_RESOURCE;
708a0: 6000 0122 braw 709c4 <rtems_rate_monotonic_period+0x168>
}
if ( length == RTEMS_PERIOD_STATUS ) {
708a4: 4a82 tstl %d2
708a6: 6622 bnes 708ca <rtems_rate_monotonic_period+0x6e>
switch ( the_period->state ) {
708a8: 202a 0038 movel %a2@(56),%d0
708ac: 7204 moveq #4,%d1
708ae: b280 cmpl %d0,%d1
708b0: 6404 bccs 708b6 <rtems_rate_monotonic_period+0x5a>
708b2: 4284 clrl %d4 <== NOT EXECUTED
708b4: 600a bras 708c0 <rtems_rate_monotonic_period+0x64><== NOT EXECUTED
708b6: 41f9 0009 4904 lea 94904 <CSWTCH.43>,%a0
708bc: 2830 0c00 movel %a0@(00000000,%d0:l:4),%d4
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
708c0: 4eb9 0004 b106 jsr 4b106 <_Thread_Enable_dispatch>
return( return_value );
708c6: 6000 00fc braw 709c4 <rtems_rate_monotonic_period+0x168>
}
_ISR_Disable( level );
708ca: 203c 0000 0700 movel #1792,%d0
708d0: 40c4 movew %sr,%d4
708d2: 8084 orl %d4,%d0
708d4: 46c0 movew %d0,%sr
switch ( the_period->state ) {
708d6: 202a 0038 movel %a2@(56),%d0
708da: 7202 moveq #2,%d1
708dc: b280 cmpl %d0,%d1
708de: 6740 beqs 70920 <rtems_rate_monotonic_period+0xc4>
708e0: 123c 0004 moveb #4,%d1
708e4: b280 cmpl %d0,%d1
708e6: 6700 00a4 beqw 7098c <rtems_rate_monotonic_period+0x130>
708ea: 4a80 tstl %d0
708ec: 6600 00d4 bnew 709c2 <rtems_rate_monotonic_period+0x166>
case RATE_MONOTONIC_INACTIVE: {
_ISR_Enable( level );
708f0: 46c4 movew %d4,%sr
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
708f2: 2f0a movel %a2,%sp@-
);
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
708f4: 4284 clrl %d4
_ISR_Enable( level );
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
708f6: 4eb9 0007 0648 jsr 70648 <_Rate_monotonic_Initiate_statistics>
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
708fc: 203c 0007 09d0 movel #461264,%d0
the_period->state = RATE_MONOTONIC_ACTIVE;
70902: 7202 moveq #2,%d1
70904: 2540 002c movel %d0,%a2@(44)
the_watchdog->id = id;
70908: 2543 0030 movel %d3,%a2@(48)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
7090c: 2542 001c movel %d2,%a2@(28)
70910: 2541 0038 movel %d1,%a2@(56)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
70914: 42aa 0018 clrl %a2@(24)
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
70918: 42aa 0034 clrl %a2@(52)
7091c: 6000 0084 braw 709a2 <rtems_rate_monotonic_period+0x146>
case RATE_MONOTONIC_ACTIVE:
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
70920: 2f0a movel %a2,%sp@-
70922: 4eb9 0007 0768 jsr 70768 <_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;
the_period->next_length = length;
70928: 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;
7092c: 7401 moveq #1,%d2
7092e: 2542 0038 movel %d2,%a2@(56)
the_period->next_length = length;
_ISR_Enable( level );
70932: 46c4 movew %d4,%sr
_Thread_Executing->Wait.id = the_period->Object.id;
70934: 2079 0009 a916 moveal 9a916 <_Thread_Executing>,%a0
7093a: 216a 0008 0020 movel %a2@(8),%a0@(32)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
70940: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
70944: 2f08 movel %a0,%sp@-
70946: 4eb9 0004 b90c jsr 4b90c <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
7094c: 203c 0000 0700 movel #1792,%d0
70952: 40c1 movew %sr,%d1
70954: 8081 orl %d1,%d0
70956: 46c0 movew %d0,%sr
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
70958: 143c 0002 moveb #2,%d2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
7095c: 202a 0038 movel %a2@(56),%d0
the_period->state = RATE_MONOTONIC_ACTIVE;
70960: 2542 0038 movel %d2,%a2@(56)
_ISR_Enable( level );
70964: 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 )
70966: 7203 moveq #3,%d1
70968: 4fef 000c lea %sp@(12),%sp
7096c: b280 cmpl %d0,%d1
7096e: 6612 bnes 70982 <rtems_rate_monotonic_period+0x126>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
70970: 4878 4000 pea 4000 <D_MAX_EXP+0x3801>
70974: 2f39 0009 a916 movel 9a916 <_Thread_Executing>,%sp@-
7097a: 4eb9 0004 ad4c jsr 4ad4c <_Thread_Clear_state>
70980: 508f addql #8,%sp
_Thread_Enable_dispatch();
70982: 4eb9 0004 b106 jsr 4b106 <_Thread_Enable_dispatch>
70988: 4284 clrl %d4
return RTEMS_SUCCESSFUL;
7098a: 6038 bras 709c4 <rtems_rate_monotonic_period+0x168>
case RATE_MONOTONIC_EXPIRED:
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
7098c: 2f0a movel %a2,%sp@-
7098e: 4eb9 0007 0768 jsr 70768 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
70994: 46c4 movew %d4,%sr
the_period->state = RATE_MONOTONIC_ACTIVE;
70996: 7002 moveq #2,%d0
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
70998: 7806 moveq #6,%d4
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
7099a: 2542 001c movel %d2,%a2@(28)
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
7099e: 2540 0038 movel %d0,%a2@(56)
the_period->next_length = length;
709a2: 2542 003c movel %d2,%a2@(60)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
709a6: 486a 0010 pea %a2@(16)
709aa: 4879 0009 a934 pea 9a934 <_Watchdog_Ticks_chain>
709b0: 4eb9 0004 c018 jsr 4c018 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
709b6: 4eb9 0004 b106 jsr 4b106 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
709bc: 4fef 000c lea %sp@(12),%sp
709c0: 6002 bras 709c4 <rtems_rate_monotonic_period+0x168>
709c2: 7804 moveq #4,%d4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
709c4: 2004 movel %d4,%d0
709c6: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2
709cc: 4e5e unlk %fp <== NOT EXECUTED
0004ff88 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
4ff88: 4e56 fffc linkw %fp,#-4
4ff8c: 2f03 movel %d3,%sp@-
4ff8e: 262e 0010 movel %fp@(16),%d3
4ff92: 2f02 movel %d2,%sp@-
4ff94: 242e 000c movel %fp@(12),%d2
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
4ff98: 6766 beqs 50000 <rtems_region_get_segment_size+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !size )
4ff9a: 4a83 tstl %d3
4ff9c: 6762 beqs 50000 <rtems_region_get_segment_size+0x78>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
4ff9e: 2f39 0007 4136 movel 74136 <_RTEMS_Allocator_Mutex>,%sp@-
4ffa4: 4eb9 0005 1eec jsr 51eec <_API_Mutex_Lock>
4ffaa: 486e fffc pea %fp@(-4)
4ffae: 2f2e 0008 movel %fp@(8),%sp@-
4ffb2: 4879 0007 3f88 pea 73f88 <_Region_Information>
4ffb8: 4eb9 0005 3634 jsr 53634 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
4ffbe: 222e fffc movel %fp@(-4),%d1
4ffc2: 4fef 0010 lea %sp@(16),%sp
4ffc6: 670a beqs 4ffd2 <rtems_region_get_segment_size+0x4a>
4ffc8: 7001 moveq #1,%d0
4ffca: b081 cmpl %d1,%d0
4ffcc: 6620 bnes 4ffee <rtems_region_get_segment_size+0x66>
4ffce: 7404 moveq #4,%d2
4ffd0: 601e bras 4fff0 <rtems_region_get_segment_size+0x68>
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
4ffd2: 2f03 movel %d3,%sp@-
4ffd4: 2040 moveal %d0,%a0
4ffd6: 2f02 movel %d2,%sp@-
4ffd8: 4868 0068 pea %a0@(104)
4ffdc: 4eb9 0005 30b4 jsr 530b4 <_Heap_Size_of_alloc_area>
4ffe2: 4fef 000c lea %sp@(12),%sp
4ffe6: 4a00 tstb %d0
4ffe8: 6604 bnes 4ffee <rtems_region_get_segment_size+0x66>
4ffea: 7409 moveq #9,%d2 <== NOT EXECUTED
4ffec: 6002 bras 4fff0 <rtems_region_get_segment_size+0x68><== NOT EXECUTED
4ffee: 4282 clrl %d2
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
4fff0: 2f39 0007 4136 movel 74136 <_RTEMS_Allocator_Mutex>,%sp@-
4fff6: 4eb9 0005 1f4c jsr 51f4c <_API_Mutex_Unlock>
return return_status;
4fffc: 588f addql #4,%sp
4fffe: 6002 bras 50002 <rtems_region_get_segment_size+0x7a>
50000: 7409 moveq #9,%d2
}
50002: 2002 movel %d2,%d0
50004: 242e fff4 movel %fp@(-12),%d2
50008: 262e fff8 movel %fp@(-8),%d3
5000c: 4e5e unlk %fp <== NOT EXECUTED
0005132c <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
5132c: 4e56 ffe8 linkw %fp,#-24
51330: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@
51334: 282e 0008 movel %fp@(8),%d4
51338: 262e 000c movel %fp@(12),%d3
5133c: 242e 0010 movel %fp@(16),%d2
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
51340: 2679 0007 42de moveal 742de <_Timer_server>,%a3
if ( !timer_server )
51346: 4a8b tstl %a3
51348: 6606 bnes 51350 <rtems_timer_server_fire_when+0x24>
5134a: 700e moveq #14,%d0
5134c: 6000 00a4 braw 513f2 <rtems_timer_server_fire_when+0xc6>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
51350: 4a39 0007 4098 tstb 74098 <_TOD_Is_set>
51356: 6606 bnes 5135e <rtems_timer_server_fire_when+0x32>
51358: 700b moveq #11,%d0 <== NOT EXECUTED
5135a: 6000 0096 braw 513f2 <rtems_timer_server_fire_when+0xc6><== NOT EXECUTED
return RTEMS_NOT_DEFINED;
if ( !routine )
5135e: 4a82 tstl %d2
51360: 6606 bnes 51368 <rtems_timer_server_fire_when+0x3c>
51362: 7009 moveq #9,%d0
51364: 6000 008c braw 513f2 <rtems_timer_server_fire_when+0xc6>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
51368: 2f03 movel %d3,%sp@-
5136a: 4eb9 0004 e7a8 jsr 4e7a8 <_TOD_Validate>
51370: 588f addql #4,%sp
51372: 4a00 tstb %d0
51374: 677a beqs 513f0 <rtems_timer_server_fire_when+0xc4>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
51376: 2f03 movel %d3,%sp@-
51378: 4eb9 0004 e708 jsr 4e708 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
5137e: 588f addql #4,%sp
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
51380: 2600 movel %d0,%d3
if ( seconds <= _TOD_Seconds_since_epoch() )
51382: b0b9 0007 4116 cmpl 74116 <_TOD_Now>,%d0
51388: 6366 blss 513f0 <rtems_timer_server_fire_when+0xc4>
5138a: 486e fffc pea %fp@(-4)
5138e: 2f04 movel %d4,%sp@-
51390: 4879 0007 42a6 pea 742a6 <_Timer_Information>
51396: 4eb9 0005 366c jsr 5366c <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
5139c: 4fef 000c lea %sp@(12),%sp
513a0: 2440 moveal %d0,%a2
513a2: 4aae fffc tstl %fp@(-4)
513a6: 6704 beqs 513ac <rtems_timer_server_fire_when+0x80>
513a8: 7004 moveq #4,%d0
513aa: 6046 bras 513f2 <rtems_timer_server_fire_when+0xc6>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
513ac: 486a 0010 pea %a2@(16)
513b0: 4eb9 0005 5200 jsr 55200 <_Watchdog_Remove>
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
513b6: 256e 0014 0034 movel %fp@(20),%a2@(52)
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
513bc: 7003 moveq #3,%d0
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
513be: 2544 0030 movel %d4,%a2@(48)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
513c2: 96b9 0007 4116 subl 74116 <_TOD_Now>,%d3
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;
513c8: 2540 0038 movel %d0,%a2@(56)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
513cc: 2543 001c movel %d3,%a2@(28)
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
513d0: 2542 002c movel %d2,%a2@(44)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
513d4: 42aa 0018 clrl %a2@(24)
(*timer_server->schedule_operation)( timer_server, the_timer );
513d8: 2f0a movel %a2,%sp@-
513da: 2f0b movel %a3,%sp@-
513dc: 206b 0004 moveal %a3@(4),%a0
513e0: 4e90 jsr %a0@
_Thread_Enable_dispatch();
513e2: 4eb9 0005 3ec6 jsr 53ec6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
513e8: 4fef 000c lea %sp@(12),%sp
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
(*timer_server->schedule_operation)( timer_server, the_timer );
_Thread_Enable_dispatch();
513ec: 4280 clrl %d0
return RTEMS_SUCCESSFUL;
513ee: 6002 bras 513f2 <rtems_timer_server_fire_when+0xc6>
513f0: 7014 moveq #20,%d0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
513f2: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3
513f8: 4e5e unlk %fp <== NOT EXECUTED