0004617c <_API_Mutex_Unlock>:
#include <rtems/score/apimutex.h>
void _API_Mutex_Unlock(
API_Mutex_Control *the_mutex
)
{
4617c: 4e56 0000 linkw %fp,#0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
46180: 2039 0005 d558 movel 5d558 <_Thread_Dispatch_disable_level>,%d0 46186: 5280 addql #1,%d0 46188: 206e 0008 moveal %fp@(8),%a0 4618c: 23c0 0005 d558 movel %d0,5d558 <_Thread_Dispatch_disable_level>
_Thread_Disable_dispatch();
_CORE_mutex_Surrender(
46192: 42a7 clrl %sp@- 46194: 2f28 0008 movel %a0@(8),%sp@- 46198: 4868 0010 pea %a0@(16) 4619c: 4eb9 0004 6400 jsr 46400 <_CORE_mutex_Surrender>
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
461a2: 4fef 000c lea %sp@(12),%sp
}
461a6: 4e5e unlk %fp
_CORE_mutex_Surrender(
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
461a8: 4ef9 0004 7a36 jmp 47a36 <_Thread_Enable_dispatch>
...
0004cbd0 <_CORE_barrier_Wait>:
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4cbd0: 203c 0000 0700 movel #1792,%d0
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4cbd6: 4e56 fff4 linkw %fp,#-12
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
4cbda: 2279 0005 f9b8 moveal 5f9b8 <_Per_CPU_Information+0xc>,%a1
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4cbe0: 48d7 001c moveml %d2-%d4,%sp@ 4cbe4: 206e 0008 moveal %fp@(8),%a0
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
4cbe8: 42a9 0034 clrl %a1@(52)
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4cbec: 242e 000c movel %fp@(12),%d2 4cbf0: 262e 0014 movel %fp@(20),%d3 4cbf4: 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 );
4cbf8: 40c1 movew %sr,%d1 4cbfa: 8081 orl %d1,%d0 4cbfc: 46c0 movew %d0,%sr
the_barrier->number_of_waiting_threads++;
4cbfe: 2028 0048 movel %a0@(72),%d0 4cc02: 5280 addql #1,%d0 4cc04: 2140 0048 movel %d0,%a0@(72)
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
4cc08: 4aa8 0040 tstl %a0@(64)
4cc0c: 6626 bnes 4cc34 <_CORE_barrier_Wait+0x64>
if ( the_barrier->number_of_waiting_threads ==
4cc0e: b0a8 0044 cmpl %a0@(68),%d0
4cc12: 6620 bnes 4cc34 <_CORE_barrier_Wait+0x64>
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
4cc14: 7001 moveq #1,%d0 4cc16: 2340 0034 movel %d0,%a1@(52)
_ISR_Enable( level );
4cc1a: 46c1 movew %d1,%sr
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
4cc1c: 2d44 0010 movel %d4,%fp@(16) 4cc20: 2d42 000c movel %d2,%fp@(12)
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
4cc24: 4cd7 001c moveml %sp@,%d2-%d4
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
_ISR_Enable( level );
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
4cc28: 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 );
}
4cc2c: 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 );
4cc2e: 4ef9 0004 cb9c jmp 4cb9c <_CORE_barrier_Release> 4cc34: 7001 moveq #1,%d0 4cc36: 2140 0030 movel %d0,%a0@(48)
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
4cc3a: 2348 0044 movel %a0,%a1@(68)
executing->Wait.id = id;
4cc3e: 2342 0020 movel %d2,%a1@(32)
_ISR_Enable( level );
4cc42: 46c1 movew %d1,%sr
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
4cc44: 2d43 000c movel %d3,%fp@(12) 4cc48: 203c 0004 9cec movel #302316,%d0 4cc4e: 2d48 0008 movel %a0,%fp@(8)
}
4cc52: 4cd7 001c moveml %sp@,%d2-%d4
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
4cc56: 2d40 0010 movel %d0,%fp@(16)
}
4cc5a: 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 );
4cc5c: 4ef9 0004 99d8 jmp 499d8 <_Thread_queue_Enqueue_with_handler>
...
0004e02c <_CORE_message_queue_Initialize>:
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
4e02c: 7003 moveq #3,%d0
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
4e02e: 4e56 fff4 linkw %fp,#-12 4e032: 222e 0014 movel %fp@(20),%d1 4e036: 48d7 040c moveml %d2-%d3/%a2,%sp@ 4e03a: 246e 0008 moveal %fp@(8),%a2 4e03e: 242e 0010 movel %fp@(16),%d2
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
4e042: c081 andl %d1,%d0
)
{
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
4e044: 2542 0044 movel %d2,%a2@(68)
the_message_queue->number_of_pending_messages = 0;
4e048: 42aa 0048 clrl %a2@(72)
the_message_queue->maximum_message_size = maximum_message_size;
4e04c: 2541 004c movel %d1,%a2@(76)
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
4e050: 4a80 tstl %d0
4e052: 670e beqs 4e062 <_CORE_message_queue_Initialize+0x36>
allocated_message_size += sizeof(uint32_t);
4e054: 2001 movel %d1,%d0 4e056: 5880 addql #4,%d0
allocated_message_size &= ~(sizeof(uint32_t) - 1);
4e058: 76fc moveq #-4,%d3 4e05a: c083 andl %d3,%d0
}
if (allocated_message_size < maximum_message_size)
4e05c: b280 cmpl %d0,%d1
4e05e: 6272 bhis 4e0d2 <_CORE_message_queue_Initialize+0xa6><== NEVER TAKEN
4e060: 6002 bras 4e064 <_CORE_message_queue_Initialize+0x38>
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
4e062: 2001 movel %d1,%d0
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
4e064: 2600 movel %d0,%d3 4e066: 0683 0000 0010 addil #16,%d3
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
4e06c: 2203 movel %d3,%d1 4e06e: 4c02 1800 mulsl %d2,%d1
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
4e072: b081 cmpl %d1,%d0
4e074: 625c bhis 4e0d2 <_CORE_message_queue_Initialize+0xa6><== NEVER TAKEN
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
4e076: 2f01 movel %d1,%sp@- 4e078: 4eb9 0005 0998 jsr 50998 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
4e07e: 588f addql #4,%sp
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
4e080: 2540 005c movel %d0,%a2@(92)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
4e084: 674c beqs 4e0d2 <_CORE_message_queue_Initialize+0xa6>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
4e086: 2f03 movel %d3,%sp@- 4e088: 2f02 movel %d2,%sp@- 4e08a: 2f00 movel %d0,%sp@- 4e08c: 486a 0060 pea %a2@(96) 4e090: 4eb9 0005 22f0 jsr 522f0 <_Chain_Initialize>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
4e096: 41ea 0054 lea %a2@(84),%a0
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
4e09a: 7001 moveq #1,%d0 4e09c: 2548 0050 movel %a0,%a2@(80)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4e0a0: 41ea 0050 lea %a2@(80),%a0
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4e0a4: 42aa 0054 clrl %a2@(84)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4e0a8: 2548 0058 movel %a0,%a2@(88) 4e0ac: 4878 0006 pea 6 <EXTENDSFDF> 4e0b0: 206e 000c moveal %fp@(12),%a0 4e0b4: 4878 0080 pea 80 <DBL_MANT_DIG+0x4b> 4e0b8: b090 cmpl %a0@,%d0 4e0ba: 57c0 seq %d0 4e0bc: 49c0 extbl %d0 4e0be: 4480 negl %d0 4e0c0: 2f00 movel %d0,%sp@- 4e0c2: 2f0a movel %a2,%sp@- 4e0c4: 4eb9 0005 0128 jsr 50128 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
4e0ca: 4fef 0020 lea %sp@(32),%sp 4e0ce: 7001 moveq #1,%d0 4e0d0: 6002 bras 4e0d4 <_CORE_message_queue_Initialize+0xa8>
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
return false;
4e0d2: 4200 clrb %d0
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
4e0d4: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 4e0da: 4e5e unlk %fp
...
0004e0e0 <_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 );
4e0e0: 223c 0000 0700 movel #1792,%d1
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
4e0e6: 4e56 ffe0 linkw %fp,#-32
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
4e0ea: 2079 0006 61ac moveal 661ac <_Per_CPU_Information+0xc>,%a0
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
4e0f0: 48d7 3c3c moveml %d2-%d5/%a2-%a5,%sp@ 4e0f4: 246e 0008 moveal %fp@(8),%a2 4e0f8: 282e 000c movel %fp@(12),%d4 4e0fc: 242e 0010 movel %fp@(16),%d2 4e100: 226e 0014 moveal %fp@(20),%a1 4e104: 262e 001c movel %fp@(28),%d3 4e108: 1a2e 001b moveb %fp@(27),%d5
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;
4e10c: 42a8 0034 clrl %a0@(52)
_ISR_Disable( level );
4e110: 40c0 movew %sr,%d0 4e112: 8280 orl %d0,%d1 4e114: 46c1 movew %d1,%sr
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
4e116: 220a movel %a2,%d1 4e118: 0681 0000 0054 addil #84,%d1
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 );
}
4e11e: 266a 0050 moveal %a2@(80),%a3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
4e122: b28b cmpl %a3,%d1
4e124: 6752 beqs 4e178 <_CORE_message_queue_Seize+0x98>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
4e126: 2853 moveal %a3@,%a4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4e128: 4bea 0050 lea %a2@(80),%a5
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
4e12c: 254c 0050 movel %a4,%a2@(80)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
4e130: 294d 0004 movel %a5,%a4@(4)
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
4e134: 4a8b tstl %a3
4e136: 6740 beqs 4e178 <_CORE_message_queue_Seize+0x98> <== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
4e138: 53aa 0048 subql #1,%a2@(72)
_ISR_Enable( level );
4e13c: 46c0 movew %d0,%sr
*size_p = the_message->Contents.size;
4e13e: 22ab 0008 movel %a3@(8),%a1@
_Thread_Executing->Wait.count =
4e142: 2079 0006 61ac moveal 661ac <_Per_CPU_Information+0xc>,%a0 4e148: 42a8 0024 clrl %a0@(36)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4e14c: 2f11 movel %a1@,%sp@- 4e14e: 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 );
4e152: 45ea 0060 lea %a2@(96),%a2
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4e156: 2f02 movel %d2,%sp@- 4e158: 4eb9 0005 4654 jsr 54654 <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 );
4e15e: 4fef 000c lea %sp@(12),%sp 4e162: 2d4b 000c movel %a3,%fp@(12) 4e166: 2d4a 0008 movel %a2,%fp@(8)
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 );
}
4e16a: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5 4e170: 4e5e unlk %fp 4e172: 4ef9 0004 df68 jmp 4df68 <_Chain_Append>
return;
}
#endif
}
if ( !wait ) {
4e178: 4a05 tstb %d5
4e17a: 6612 bnes 4e18e <_CORE_message_queue_Seize+0xae>
_ISR_Enable( level );
4e17c: 46c0 movew %d0,%sr
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
4e17e: 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 );
}
4e180: 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;
4e186: 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 );
}
4e18a: 4e5e unlk %fp 4e18c: 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;
4e18e: 7201 moveq #1,%d1 4e190: 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;
4e194: 2142 002c movel %d2,%a0@(44)
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;
4e198: 214a 0044 movel %a2,%a0@(68)
executing->Wait.id = id;
4e19c: 2144 0020 movel %d4,%a0@(32)
executing->Wait.return_argument_second.mutable_object = buffer; executing->Wait.return_argument = size_p;
4e1a0: 2149 0028 movel %a1,%a0@(40)
/* Wait.count will be filled in with the message priority */ _ISR_Enable( level );
4e1a4: 46c0 movew %d0,%sr
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
4e1a6: 4bf9 0005 01f8 lea 501f8 <_Thread_queue_Timeout>,%a5 4e1ac: 2d43 000c movel %d3,%fp@(12) 4e1b0: 2d4d 0010 movel %a5,%fp@(16) 4e1b4: 2d4a 0008 movel %a2,%fp@(8)
}
4e1b8: 4cee 3c3c ffe0 moveml %fp@(-32),%d2-%d5/%a2-%a5 4e1be: 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 );
4e1c0: 4ef9 0004 fee4 jmp 4fee4 <_Thread_queue_Enqueue_with_handler>
...
0004635c <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
4635c: 4e56 0000 linkw %fp,#0
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
46360: 2039 0005 d558 movel 5d558 <_Thread_Dispatch_disable_level>,%d0
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
46366: 2f0a movel %a2,%sp@- 46368: 246e 0008 moveal %fp@(8),%a2 4636c: 2f02 movel %d2,%sp@- 4636e: 142e 0013 moveb %fp@(19),%d2
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
46372: 4a80 tstl %d0
46374: 671c beqs 46392 <_CORE_mutex_Seize+0x36>
46376: 4a02 tstb %d2
46378: 6718 beqs 46392 <_CORE_mutex_Seize+0x36> <== NEVER TAKEN
4637a: 7001 moveq #1,%d0 4637c: b0b9 0005 d6a0 cmpl 5d6a0 <_System_state_Current>,%d0
46382: 640e bccs 46392 <_CORE_mutex_Seize+0x36>
46384: 4878 0012 pea 12 <INVALID_OPERATION+0x2> 46388: 42a7 clrl %sp@- 4638a: 42a7 clrl %sp@- 4638c: 4eb9 0004 69b0 jsr 469b0 <_Internal_error_Occurred> 46392: 486e 0018 pea %fp@(24) 46396: 2f0a movel %a2,%sp@- 46398: 4eb9 0004 a274 jsr 4a274 <_CORE_mutex_Seize_interrupt_trylock> 4639e: 508f addql #8,%sp 463a0: 4a80 tstl %d0
463a2: 6750 beqs 463f4 <_CORE_mutex_Seize+0x98>
463a4: 4a02 tstb %d2
463a6: 6614 bnes 463bc <_CORE_mutex_Seize+0x60>
463a8: 202e 0018 movel %fp@(24),%d0 463ac: 46c0 movew %d0,%sr 463ae: 2079 0005 d6f4 moveal 5d6f4 <_Per_CPU_Information+0xc>,%a0 463b4: 7001 moveq #1,%d0 463b6: 2140 0034 movel %d0,%a0@(52) 463ba: 6038 bras 463f4 <_CORE_mutex_Seize+0x98>
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;
463bc: 7001 moveq #1,%d0 463be: 2079 0005 d6f4 moveal 5d6f4 <_Per_CPU_Information+0xc>,%a0 463c4: 2540 0030 movel %d0,%a2@(48) 463c8: 2039 0005 d558 movel 5d558 <_Thread_Dispatch_disable_level>,%d0 463ce: 5280 addql #1,%d0 463d0: 216e 000c 0020 movel %fp@(12),%a0@(32) 463d6: 214a 0044 movel %a2,%a0@(68) 463da: 23c0 0005 d558 movel %d0,5d558 <_Thread_Dispatch_disable_level> 463e0: 202e 0018 movel %fp@(24),%d0 463e4: 46c0 movew %d0,%sr 463e6: 2f2e 0014 movel %fp@(20),%sp@- 463ea: 2f0a movel %a2,%sp@- 463ec: 4eb9 0004 62f8 jsr 462f8 <_CORE_mutex_Seize_interrupt_blocking> 463f2: 508f addql #8,%sp
}
463f4: 242e fff8 movel %fp@(-8),%d2 463f8: 246e fffc moveal %fp@(-4),%a2
463fc: 4e5e unlk %fp <== NOT EXECUTED
00046538 <_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
)
{
46538: 4e56 0000 linkw %fp,#0 4653c: 2f0a movel %a2,%sp@- 4653e: 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)) ) {
46542: 2f0a movel %a2,%sp@- 46544: 4eb9 0004 7cf8 jsr 47cf8 <_Thread_queue_Dequeue> 4654a: 588f addql #4,%sp 4654c: 4a80 tstl %d0
4654e: 6624 bnes 46574 <_CORE_semaphore_Surrender+0x3c>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
46550: 303c 0700 movew #1792,%d0 46554: 40c1 movew %sr,%d1 46556: 8081 orl %d1,%d0 46558: 46c0 movew %d0,%sr
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
4655a: 202a 0048 movel %a2@(72),%d0 4655e: b0aa 0040 cmpl %a2@(64),%d0
46562: 640a bccs 4656e <_CORE_semaphore_Surrender+0x36> <== NEVER TAKEN
the_semaphore->count += 1;
46564: 5280 addql #1,%d0 46566: 2540 0048 movel %d0,%a2@(72)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
4656a: 4280 clrl %d0 4656c: 6002 bras 46570 <_CORE_semaphore_Surrender+0x38>
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
4656e: 7004 moveq #4,%d0 <== NOT EXECUTED
_ISR_Enable( level );
46570: 46c1 movew %d1,%sr 46572: 6002 bras 46576 <_CORE_semaphore_Surrender+0x3e>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
46574: 4280 clrl %d0
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
46576: 246e fffc moveal %fp@(-4),%a2 4657a: 4e5e unlk %fp
...
00045458 <_Event_Surrender>:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
45458: 203c 0000 0700 movel #1792,%d0
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
4545e: 4e56 ffe8 linkw %fp,#-24 45462: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@ 45466: 246e 0008 moveal %fp@(8),%a2
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
4546a: 206a 00fc moveal %a2@(252),%a0
option_set = (rtems_option) the_thread->Wait.option;
4546e: 282a 0030 movel %a2@(48),%d4
_ISR_Disable( level );
45472: 40c1 movew %sr,%d1 45474: 8081 orl %d1,%d0 45476: 46c0 movew %d0,%sr
pending_events = api->pending_events; event_condition = (rtems_event_set) the_thread->Wait.count;
45478: 262a 0024 movel %a2@(36),%d3
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Get(
rtems_event_set the_event_set,
rtems_event_set the_event_condition
)
{
return ( the_event_set & the_event_condition );
4547c: 2003 movel %d3,%d0
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
pending_events = api->pending_events;
4547e: 2410 movel %a0@,%d2 45480: c082 andl %d2,%d0
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
45482: 6606 bnes 4548a <_Event_Surrender+0x32>
_ISR_Enable( level );
45484: 46c1 movew %d1,%sr
return;
45486: 6000 00ca braw 45552 <_Event_Surrender+0xfa>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
4548a: 4ab9 0005 d6f0 tstl 5d6f0 <_Per_CPU_Information+0x8>
45490: 674a beqs 454dc <_Event_Surrender+0x84>
45492: b5f9 0005 d6f4 cmpal 5d6f4 <_Per_CPU_Information+0xc>,%a2
45498: 6642 bnes 454dc <_Event_Surrender+0x84>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
4549a: 2279 0005 d728 moveal 5d728 <_Event_Sync_state>,%a1
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
454a0: 7a02 moveq #2,%d5 454a2: ba89 cmpl %a1,%d5
454a4: 670e beqs 454b4 <_Event_Surrender+0x5c> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
454a6: 2279 0005 d728 moveal 5d728 <_Event_Sync_state>,%a1
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
454ac: 1a3c 0001 moveb #1,%d5 454b0: ba89 cmpl %a1,%d5
454b2: 6628 bnes 454dc <_Event_Surrender+0x84>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
454b4: b680 cmpl %d0,%d3
454b6: 6706 beqs 454be <_Event_Surrender+0x66>
454b8: 0804 0001 btst #1,%d4
454bc: 671a beqs 454d8 <_Event_Surrender+0x80> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
454be: 2600 movel %d0,%d3 454c0: 4683 notl %d3 454c2: c682 andl %d2,%d3 454c4: 2083 movel %d3,%a0@
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
454c6: 206a 0028 moveal %a2@(40),%a0
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
454ca: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
454ce: 2080 movel %d0,%a0@
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
454d0: 7003 moveq #3,%d0 454d2: 23c0 0005 d728 movel %d0,5d728 <_Event_Sync_state>
}
_ISR_Enable( level );
454d8: 46c1 movew %d1,%sr
return;
454da: 6076 bras 45552 <_Event_Surrender+0xfa>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
454dc: 2a2a 0010 movel %a2@(16),%d5 454e0: 0285 0000 0100 andil #256,%d5
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
454e6: 6768 beqs 45550 <_Event_Surrender+0xf8>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
454e8: b680 cmpl %d0,%d3
454ea: 6706 beqs 454f2 <_Event_Surrender+0x9a>
454ec: 0804 0001 btst #1,%d4
454f0: 675e beqs 45550 <_Event_Surrender+0xf8> <== NEVER TAKEN
454f2: 2600 movel %d0,%d3 454f4: 4683 notl %d3 454f6: c682 andl %d2,%d3 454f8: 2083 movel %d3,%a0@
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
454fa: 206a 0028 moveal %a2@(40),%a0
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
454fe: 42aa 0024 clrl %a2@(36)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
45502: 2080 movel %d0,%a0@
_ISR_Flash( level );
45504: 203c 0000 0700 movel #1792,%d0 4550a: 46c1 movew %d1,%sr 4550c: 8081 orl %d1,%d0 4550e: 46c0 movew %d0,%sr 45510: 47f9 0004 76f4 lea 476f4 <_Thread_Clear_state>,%a3
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
45516: 7a02 moveq #2,%d5 45518: baaa 0050 cmpl %a2@(80),%d5
4551c: 6710 beqs 4552e <_Event_Surrender+0xd6>
_ISR_Enable( level );
4551e: 46c1 movew %d1,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
45520: 2f3c 1003 fff8 movel #268697592,%sp@- 45526: 2f0a movel %a2,%sp@- 45528: 4e93 jsr %a3@ 4552a: 508f addql #8,%sp 4552c: 6024 bras 45552 <_Event_Surrender+0xfa>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
4552e: 7003 moveq #3,%d0 45530: 2540 0050 movel %d0,%a2@(80)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
45534: 46c1 movew %d1,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
45536: 486a 0048 pea %a2@(72) 4553a: 4eb9 0004 8794 jsr 48794 <_Watchdog_Remove> 45540: 2f3c 1003 fff8 movel #268697592,%sp@- 45546: 2f0a movel %a2,%sp@- 45548: 4e93 jsr %a3@ 4554a: 4fef 000c lea %sp@(12),%sp 4554e: 6002 bras 45552 <_Event_Surrender+0xfa>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
45550: 46c1 movew %d1,%sr
}
45552: 4cee 0c3c ffe8 moveml %fp@(-24),%d2-%d5/%a2-%a3
45558: 4e5e unlk %fp <== NOT EXECUTED
0004555c <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
4555c: 4e56 fffc linkw %fp,#-4 45560: 2f03 movel %d3,%sp@- 45562: 2f02 movel %d2,%sp@-
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
45564: 486e fffc pea %fp@(-4) 45568: 2f2e 0008 movel %fp@(8),%sp@- 4556c: 4eb9 0004 7a5c jsr 47a5c <_Thread_Get>
switch ( location ) {
45572: 508f addql #8,%sp 45574: 4aae fffc tstl %fp@(-4)
45578: 6656 bnes 455d0 <_Event_Timeout+0x74> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
4557a: 223c 0000 0700 movel #1792,%d1 45580: 40c2 movew %sr,%d2 45582: 8282 orl %d2,%d1 45584: 46c1 movew %d1,%sr
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
45586: 2040 moveal %d0,%a0 45588: 42a8 0024 clrl %a0@(36)
if ( _Thread_Is_executing( the_thread ) ) {
4558c: b0b9 0005 d6f4 cmpl 5d6f4 <_Per_CPU_Information+0xc>,%d0
45592: 6614 bnes 455a8 <_Event_Timeout+0x4c>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
45594: 2239 0005 d728 movel 5d728 <_Event_Sync_state>,%d1 4559a: 7601 moveq #1,%d3 4559c: b681 cmpl %d1,%d3
4559e: 6608 bnes 455a8 <_Event_Timeout+0x4c>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
455a0: 7202 moveq #2,%d1 455a2: 23c1 0005 d728 movel %d1,5d728 <_Event_Sync_state>
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
455a8: 7606 moveq #6,%d3 455aa: 2040 moveal %d0,%a0 455ac: 2143 0034 movel %d3,%a0@(52)
_ISR_Enable( level );
455b0: 46c2 movew %d2,%sr 455b2: 2f3c 1003 fff8 movel #268697592,%sp@- 455b8: 2f00 movel %d0,%sp@- 455ba: 4eb9 0004 76f4 jsr 476f4 <_Thread_Clear_state>
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
455c0: 508f addql #8,%sp
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
455c2: 2039 0005 d558 movel 5d558 <_Thread_Dispatch_disable_level>,%d0 455c8: 5380 subql #1,%d0 455ca: 23c0 0005 d558 movel %d0,5d558 <_Thread_Dispatch_disable_level>
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
455d0: 242e fff4 movel %fp@(-12),%d2 455d4: 262e fff8 movel %fp@(-8),%d3
455d8: 4e5e unlk %fp <== NOT EXECUTED
0004a838 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
4a838: 4e56 ffcc linkw %fp,#-52 4a83c: 202e 0010 movel %fp@(16),%d0 4a840: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 4a844: 246e 0008 moveal %fp@(8),%a2 4a848: 262e 000c movel %fp@(12),%d3
Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
4a84c: 2403 movel %d3,%d2 4a84e: d480 addl %d0,%d2
uintptr_t const free_size = stats->free_size;
4a850: 206a 0030 moveal %a2@(48),%a0
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
4a854: 282a 0020 movel %a2@(32),%d4
Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
4a858: 2a2a 0010 movel %a2@(16),%d5
uintptr_t const min_block_size = heap->min_block_size;
4a85c: 222a 0014 movel %a2@(20),%d1
Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL;
4a860: 42ae fffc clrl %fp@(-4)
Heap_Block *extend_last_block = NULL;
4a864: 42ae fff8 clrl %fp@(-8)
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size;
4a868: 2d48 fff4 movel %a0,%fp@(-12)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
4a86c: b682 cmpl %d2,%d3 4a86e: 6200 01aa bhiw 4aa1a <_Heap_Extend+0x1e2>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
4a872: 486e fff8 pea %fp@(-8) 4a876: 486e fffc pea %fp@(-4) 4a87a: 2f01 movel %d1,%sp@- 4a87c: 2f05 movel %d5,%sp@- 4a87e: 2f00 movel %d0,%sp@- 4a880: 2f03 movel %d3,%sp@- 4a882: 4eb9 0004 6a6e jsr 46a6e <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
4a888: 4fef 0018 lea %sp@(24),%sp 4a88c: 4a00 tstb %d0 4a88e: 6700 018a beqw 4aa1a <_Heap_Extend+0x1e2> 4a892: 2044 moveal %d4,%a0 4a894: 9bcd subal %a5,%a5 4a896: 4281 clrl %d1 4a898: 97cb subal %a3,%a3 4a89a: 99cc subal %a4,%a4
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
4a89c: b888 cmpl %a0,%d4
4a89e: 6704 beqs 4a8a4 <_Heap_Extend+0x6c>
4a8a0: 2248 moveal %a0,%a1 4a8a2: 6004 bras 4a8a8 <_Heap_Extend+0x70> 4a8a4: 226a 0018 moveal %a2@(24),%a1
uintptr_t const sub_area_end = start_block->prev_size;
4a8a8: 2010 movel %a0@,%d0
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
4a8aa: b680 cmpl %d0,%d3
4a8ac: 6406 bccs 4a8b4 <_Heap_Extend+0x7c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
4a8ae: b3c2 cmpal %d2,%a1 4a8b0: 6500 0168 bcsw 4aa1a <_Heap_Extend+0x1e2>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4a8b4: b3c2 cmpal %d2,%a1
4a8b6: 6706 beqs 4a8be <_Heap_Extend+0x86>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4a8b8: b082 cmpl %d2,%d0
4a8ba: 6206 bhis 4a8c2 <_Heap_Extend+0x8a>
4a8bc: 6006 bras 4a8c4 <_Heap_Extend+0x8c>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
4a8be: 2848 moveal %a0,%a4 4a8c0: 6002 bras 4a8c4 <_Heap_Extend+0x8c>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
4a8c2: 2208 movel %a0,%d1 4a8c4: 2e00 movel %d0,%d7 4a8c6: 2240 moveal %d0,%a1 4a8c8: 5189 subql #8,%a1 4a8ca: 4c45 7006 remul %d5,%d6,%d7
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
4a8ce: 93c6 subal %d6,%a1
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
4a8d0: b680 cmpl %d0,%d3
4a8d2: 6606 bnes 4a8da <_Heap_Extend+0xa2>
start_block->prev_size = extend_area_end;
4a8d4: 2082 movel %d2,%a0@
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
4a8d6: 2649 moveal %a1,%a3 4a8d8: 6006 bras 4a8e0 <_Heap_Extend+0xa8>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
4a8da: b680 cmpl %d0,%d3
4a8dc: 6302 blss 4a8e0 <_Heap_Extend+0xa8>
4a8de: 2a49 moveal %a1,%a5
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4a8e0: 70fe moveq #-2,%d0 4a8e2: c0a9 0004 andl %a1@(4),%d0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4a8e6: 41f1 0800 lea %a1@(00000000,%d0:l),%a0
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
4a8ea: b888 cmpl %a0,%d4
4a8ec: 66ae bnes 4a89c <_Heap_Extend+0x64>
if ( extend_area_begin < heap->area_begin ) {
4a8ee: b6aa 0018 cmpl %a2@(24),%d3
4a8f2: 6406 bccs 4a8fa <_Heap_Extend+0xc2>
heap->area_begin = extend_area_begin;
4a8f4: 2543 0018 movel %d3,%a2@(24) 4a8f8: 600a bras 4a904 <_Heap_Extend+0xcc>
} else if ( heap->area_end < extend_area_end ) {
4a8fa: b4aa 001c cmpl %a2@(28),%d2
4a8fe: 6304 blss 4a904 <_Heap_Extend+0xcc>
heap->area_end = extend_area_end;
4a900: 2542 001c movel %d2,%a2@(28)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4a904: 206e fff8 moveal %fp@(-8),%a0
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
4a908: 2008 movel %a0,%d0
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4a90a: 7801 moveq #1,%d4
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
4a90c: 226e fffc moveal %fp@(-4),%a1
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
4a910: 9089 subl %a1,%d0
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4a912: 8880 orl %d0,%d4
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
4a914: 2282 movel %d2,%a1@
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
4a916: 2344 0004 movel %d4,%a1@(4)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
4a91a: 2080 movel %d0,%a0@
extend_last_block->size_and_flag = 0;
4a91c: 42a8 0004 clrl %a0@(4)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
4a920: b3ea 0020 cmpal %a2@(32),%a1
4a924: 6406 bccs 4a92c <_Heap_Extend+0xf4>
heap->first_block = extend_first_block;
4a926: 2549 0020 movel %a1,%a2@(32) 4a92a: 600a bras 4a936 <_Heap_Extend+0xfe>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
4a92c: b1ea 0024 cmpal %a2@(36),%a0
4a930: 6304 blss 4a936 <_Heap_Extend+0xfe>
heap->last_block = extend_last_block;
4a932: 2548 0024 movel %a0,%a2@(36)
}
if ( merge_below_block != NULL ) {
4a936: 4a8c tstl %a4
4a938: 6732 beqs 4a96c <_Heap_Extend+0x134>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
4a93a: 202a 0010 movel %a2@(16),%d0
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
4a93e: 5083 addql #8,%d3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
4a940: 2803 movel %d3,%d4 4a942: 4c40 4001 remul %d0,%d1,%d4
if ( remainder != 0 ) {
4a946: 4a81 tstl %d1
4a948: 6704 beqs 4a94e <_Heap_Extend+0x116>
return value - remainder + alignment;
4a94a: d680 addl %d0,%d3 4a94c: 9681 subl %d1,%d3
uintptr_t const new_first_block_begin =
4a94e: 2043 moveal %d3,%a0 4a950: 5188 subql #8,%a0
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
4a952: 200c movel %a4,%d0 4a954: 9088 subl %a0,%d0
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4a956: 7201 moveq #1,%d1 4a958: 8280 orl %d0,%d1
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
4a95a: 2094 movel %a4@,%a0@
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
4a95c: 2141 0004 movel %d1,%a0@(4)
_Heap_Free_block( heap, new_first_block );
4a960: 2f08 movel %a0,%sp@- 4a962: 2f0a movel %a2,%sp@- 4a964: 4eba feb6 jsr %pc@(4a81c <_Heap_Free_block>) 4a968: 508f addql #8,%sp 4a96a: 6012 bras 4a97e <_Heap_Extend+0x146>
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
4a96c: 4a81 tstl %d1
4a96e: 670e beqs 4a97e <_Heap_Extend+0x146>
_Heap_Link_below(
4a970: 206e fff8 moveal %fp@(-8),%a0
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
4a974: 7801 moveq #1,%d4 4a976: 9288 subl %a0,%d1 4a978: 8881 orl %d1,%d4 4a97a: 2144 0004 movel %d4,%a0@(4)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
4a97e: 4a8b tstl %a3
4a980: 6734 beqs 4a9b6 <_Heap_Extend+0x17e>
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
4a982: 5182 subql #8,%d2
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
4a984: 948b subl %a3,%d2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
4a986: 2202 movel %d2,%d1 4a988: 4c6a 1000 0010 remul %a2@(16),%d0,%d1
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
4a98e: 7201 moveq #1,%d1 4a990: 9480 subl %d0,%d2
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
4a992: 202b 0004 movel %a3@(4),%d0 4a996: 9082 subl %d2,%d0
| HEAP_PREV_BLOCK_USED;
4a998: 8280 orl %d0,%d1
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4a99a: 7001 moveq #1,%d0 4a99c: 2781 2804 movel %d1,%a3@(00000004,%d2:l) 4a9a0: c0ab 0004 andl %a3@(4),%d0
block->size_and_flag = size | flag;
4a9a4: 8480 orl %d0,%d2 4a9a6: 2742 0004 movel %d2,%a3@(4)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
4a9aa: 2f0b movel %a3,%sp@- 4a9ac: 2f0a movel %a2,%sp@- 4a9ae: 4eba fe6c jsr %pc@(4a81c <_Heap_Free_block>) 4a9b2: 508f addql #8,%sp 4a9b4: 6020 bras 4a9d6 <_Heap_Extend+0x19e>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
4a9b6: 4a8d tstl %a5
4a9b8: 671c beqs 4a9d6 <_Heap_Extend+0x19e>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4a9ba: 7001 moveq #1,%d0
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4a9bc: 7801 moveq #1,%d4
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
4a9be: 222e fffc movel %fp@(-4),%d1 4a9c2: 928d subl %a5,%d1 4a9c4: c0ad 0004 andl %a5@(4),%d0
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
4a9c8: 206e fff8 moveal %fp@(-8),%a0
block->size_and_flag = size | flag;
4a9cc: 8280 orl %d0,%d1 4a9ce: 2b41 0004 movel %d1,%a5@(4)
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
4a9d2: 89a8 0004 orl %d4,%a0@(4)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
4a9d6: 4a8c tstl %a4
4a9d8: 6610 bnes 4a9ea <_Heap_Extend+0x1b2>
4a9da: 4a8b tstl %a3
4a9dc: 660c bnes 4a9ea <_Heap_Extend+0x1b2>
_Heap_Free_block( heap, extend_first_block );
4a9de: 2f2e fffc movel %fp@(-4),%sp@- 4a9e2: 2f0a movel %a2,%sp@- 4a9e4: 4eba fe36 jsr %pc@(4a81c <_Heap_Free_block>) 4a9e8: 508f addql #8,%sp
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
4a9ea: 206a 0024 moveal %a2@(36),%a0
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4a9ee: 7001 moveq #1,%d0
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
4a9f0: 222a 0020 movel %a2@(32),%d1 4a9f4: 9288 subl %a0,%d1
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
4a9f6: c0a8 0004 andl %a0@(4),%d0
block->size_and_flag = size | flag;
4a9fa: 8280 orl %d0,%d1
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
4a9fc: 202a 0030 movel %a2@(48),%d0 4aa00: 90ae fff4 subl %fp@(-12),%d0 4aa04: 2141 0004 movel %d1,%a0@(4)
/* Statistics */
stats->size += extended_size;
4aa08: d1aa 002c addl %d0,%a2@(44)
if ( extended_size_ptr != NULL )
4aa0c: 4aae 0014 tstl %fp@(20)
4aa10: 670c beqs 4aa1e <_Heap_Extend+0x1e6> <== NEVER TAKEN
*extended_size_ptr = extended_size;
4aa12: 206e 0014 moveal %fp@(20),%a0 4aa16: 2080 movel %d0,%a0@ 4aa18: 6004 bras 4aa1e <_Heap_Extend+0x1e6>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
4aa1a: 4200 clrb %d0 4aa1c: 6002 bras 4aa20 <_Heap_Extend+0x1e8>
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
4aa1e: 7001 moveq #1,%d0
}
4aa20: 4cee 3cfc ffcc moveml %fp@(-52),%d2-%d7/%a2-%a5 4aa26: 4e5e unlk %fp
...
0004a53c <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
4a53c: 4e56 ffe8 linkw %fp,#-24 4a540: 206e 0008 moveal %fp@(8),%a0 4a544: 48d7 0c3c moveml %d2-%d5/%a2-%a3,%sp@ 4a548: 202e 000c movel %fp@(12),%d0
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
4a54c: 6700 0150 beqw 4a69e <_Heap_Free+0x162> 4a550: 2240 moveal %d0,%a1 4a552: 5189 subql #8,%a1 4a554: 4c68 0001 0010 remul %a0@(16),%d1,%d0
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
4a55a: 2828 0020 movel %a0@(32),%d4
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
4a55e: 93c1 subal %d1,%a1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4a560: b889 cmpl %a1,%d4
4a562: 620c bhis 4a570 <_Heap_Free+0x34>
4a564: b3e8 0024 cmpal %a0@(36),%a1 4a568: 53c0 sls %d0 4a56a: 49c0 extbl %d0 4a56c: 4480 negl %d0 4a56e: 6002 bras 4a572 <_Heap_Free+0x36> 4a570: 4280 clrl %d0
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
4a572: 4a00 tstb %d0 4a574: 6700 012c beqw 4a6a2 <_Heap_Free+0x166>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4a578: 2629 0004 movel %a1@(4),%d3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4a57c: 70fe moveq #-2,%d0 4a57e: c083 andl %d3,%d0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4a580: 45f1 0800 lea %a1@(00000000,%d0:l),%a2
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4a584: b88a cmpl %a2,%d4
4a586: 620c bhis 4a594 <_Heap_Free+0x58> <== NEVER TAKEN
4a588: b5e8 0024 cmpal %a0@(36),%a2 4a58c: 53c1 sls %d1 4a58e: 49c1 extbl %d1 4a590: 4481 negl %d1 4a592: 6002 bras 4a596 <_Heap_Free+0x5a>
4a594: 4281 clrl %d1 <== NOT EXECUTED
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
4a596: 4a01 tstb %d1 4a598: 6700 0108 beqw 4a6a2 <_Heap_Free+0x166>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4a59c: 242a 0004 movel %a2@(4),%d2
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
4a5a0: 0802 0000 btst #0,%d2 4a5a4: 6700 00fc beqw 4a6a2 <_Heap_Free+0x166>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4a5a8: 72fe moveq #-2,%d1
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
4a5aa: 2668 0024 moveal %a0@(36),%a3 4a5ae: c481 andl %d1,%d2
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4a5b0: b7ca cmpal %a2,%a3
4a5b2: 670c beqs 4a5c0 <_Heap_Free+0x84>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4a5b4: 7201 moveq #1,%d1 4a5b6: c2b2 2804 andl %a2@(00000004,%d2:l),%d1
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
4a5ba: 5381 subql #1,%d1 4a5bc: 4481 negl %d1 4a5be: 6002 bras 4a5c2 <_Heap_Free+0x86>
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
4a5c0: 4281 clrl %d1
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
4a5c2: 1a01 moveb %d1,%d5
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
4a5c4: 0803 0000 btst #0,%d3
4a5c8: 6662 bnes 4a62c <_Heap_Free+0xf0>
uintptr_t const prev_size = block->prev_size;
4a5ca: 2611 movel %a1@,%d3
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4a5cc: 93c3 subal %d3,%a1
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4a5ce: b889 cmpl %a1,%d4
4a5d0: 620a bhis 4a5dc <_Heap_Free+0xa0> <== NEVER TAKEN
4a5d2: b3cb cmpal %a3,%a1 4a5d4: 53c1 sls %d1 4a5d6: 49c1 extbl %d1 4a5d8: 4481 negl %d1 4a5da: 6002 bras 4a5de <_Heap_Free+0xa2>
4a5dc: 4281 clrl %d1 <== NOT EXECUTED
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
4a5de: 4a01 tstb %d1 4a5e0: 6700 00c0 beqw 4a6a2 <_Heap_Free+0x166>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4a5e4: 7201 moveq #1,%d1 4a5e6: c2a9 0004 andl %a1@(4),%d1
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
4a5ea: 6700 00b6 beqw 4a6a2 <_Heap_Free+0x166>
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
4a5ee: 4a05 tstb %d5
4a5f0: 6726 beqs 4a618 <_Heap_Free+0xdc>
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
4a5f2: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + prev_size + next_block_size;
4a5f6: d480 addl %d0,%d2 4a5f8: d682 addl %d2,%d3
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a5fa: 7401 moveq #1,%d2
Heap_Block *prev = block->prev;
4a5fc: 246a 000c moveal %a2@(12),%a2
prev->next = next;
4a600: 254b 0008 movel %a3,%a2@(8) 4a604: 8483 orl %d3,%d2
next->prev = prev;
4a606: 274a 000c movel %a2,%a3@(12)
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
4a60a: 53a8 0038 subql #1,%a0@(56)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
4a60e: 2383 3800 movel %d3,%a1@(00000000,%d3:l)
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a612: 2342 0004 movel %d2,%a1@(4) 4a616: 607a bras 4a692 <_Heap_Free+0x156>
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
4a618: d680 addl %d0,%d3
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a61a: 7201 moveq #1,%d1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4a61c: 74fe moveq #-2,%d2
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a61e: 8283 orl %d3,%d1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
4a620: 2483 movel %d3,%a2@
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a622: 2341 0004 movel %d1,%a1@(4)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4a626: c5aa 0004 andl %d2,%a2@(4) 4a62a: 6066 bras 4a692 <_Heap_Free+0x156>
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
4a62c: 4a01 tstb %d1
4a62e: 672a beqs 4a65a <_Heap_Free+0x11e>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
4a630: 266a 0008 moveal %a2@(8),%a3
uintptr_t const size = block_size + next_block_size;
4a634: 2202 movel %d2,%d1 4a636: d280 addl %d0,%d1
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a638: 7401 moveq #1,%d2
Heap_Block *prev = old_block->prev;
4a63a: 246a 000c moveal %a2@(12),%a2
new_block->next = next;
4a63e: 234b 0008 movel %a3,%a1@(8) 4a642: 8481 orl %d1,%d2
new_block->prev = prev;
4a644: 234a 000c movel %a2,%a1@(12)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
4a648: 2381 1800 movel %d1,%a1@(00000000,%d1:l)
next->prev = new_block;
4a64c: 2749 000c movel %a1,%a3@(12)
prev->next = new_block;
4a650: 2549 0008 movel %a1,%a2@(8)
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
4a654: 2342 0004 movel %d2,%a1@(4) 4a658: 6038 bras 4a692 <_Heap_Free+0x156>
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
4a65a: 7201 moveq #1,%d1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4a65c: 74fe moveq #-2,%d2
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
4a65e: 8280 orl %d0,%d1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
4a660: 2668 0008 moveal %a0@(8),%a3
new_block->next = next;
new_block->prev = block_before;
4a664: 2348 000c movel %a0,%a1@(12) 4a668: 2341 0004 movel %d1,%a1@(4)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
4a66c: 2228 0038 movel %a0@(56),%d1 4a670: 5281 addql #1,%d1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
4a672: 234b 0008 movel %a3,%a1@(8)
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
4a676: c5aa 0004 andl %d2,%a2@(4)
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
4a67a: 2749 000c movel %a1,%a3@(12)
next_block->prev_size = block_size;
4a67e: 2480 movel %d0,%a2@
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
4a680: 2149 0008 movel %a1,%a0@(8)
/* Statistics */
++stats->free_blocks;
4a684: 2141 0038 movel %d1,%a0@(56)
if ( stats->max_free_blocks < stats->free_blocks ) {
4a688: b2a8 003c cmpl %a0@(60),%d1
4a68c: 6304 blss 4a692 <_Heap_Free+0x156>
stats->max_free_blocks = stats->free_blocks;
4a68e: 2141 003c movel %d1,%a0@(60)
}
}
/* Statistics */
--stats->used_blocks;
4a692: 53a8 0040 subql #1,%a0@(64)
++stats->frees;
4a696: 52a8 0050 addql #1,%a0@(80)
stats->free_size += block_size;
4a69a: d1a8 0030 addl %d0,%a0@(48)
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
4a69e: 7001 moveq #1,%d0 4a6a0: 6002 bras 4a6a4 <_Heap_Free+0x168>
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
_HAssert( false );
return( false );
4a6a2: 4200 clrb %d0
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
4a6a4: 4cd7 0c3c moveml %sp@,%d2-%d5/%a2-%a3
4a6a8: 4e5e unlk %fp <== NOT EXECUTED
00059f68 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
59f68: 4e56 0000 linkw %fp,#0 59f6c: 202e 000c movel %fp@(12),%d0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
59f70: 2040 moveal %d0,%a0 59f72: 5188 subql #8,%a0 59f74: 226e 0008 moveal %fp@(8),%a1 59f78: 2f02 movel %d2,%sp@- 59f7a: 2400 movel %d0,%d2 59f7c: 4c69 2001 0010 remul %a1@(16),%d1,%d2
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
59f82: 2429 0020 movel %a1@(32),%d2
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
59f86: 91c1 subal %d1,%a0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
59f88: b488 cmpl %a0,%d2
59f8a: 620c bhis 59f98 <_Heap_Size_of_alloc_area+0x30>
59f8c: b1e9 0024 cmpal %a1@(36),%a0 59f90: 53c1 sls %d1 59f92: 49c1 extbl %d1 59f94: 4481 negl %d1 59f96: 6002 bras 59f9a <_Heap_Size_of_alloc_area+0x32> 59f98: 4281 clrl %d1
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
59f9a: 4a01 tstb %d1
59f9c: 6738 beqs 59fd6 <_Heap_Size_of_alloc_area+0x6e>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
59f9e: 72fe moveq #-2,%d1 59fa0: c2a8 0004 andl %a0@(4),%d1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
59fa4: d1c1 addal %d1,%a0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
59fa6: b488 cmpl %a0,%d2
59fa8: 620c bhis 59fb6 <_Heap_Size_of_alloc_area+0x4e> <== NEVER TAKEN
59faa: b1e9 0024 cmpal %a1@(36),%a0 59fae: 53c1 sls %d1 59fb0: 49c1 extbl %d1 59fb2: 4481 negl %d1 59fb4: 6002 bras 59fb8 <_Heap_Size_of_alloc_area+0x50>
59fb6: 4281 clrl %d1 <== NOT EXECUTED
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
59fb8: 4a01 tstb %d1
59fba: 671a beqs 59fd6 <_Heap_Size_of_alloc_area+0x6e> <== NEVER TAKEN
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
59fbc: 7201 moveq #1,%d1 59fbe: c2a8 0004 andl %a0@(4),%d1
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
59fc2: 6712 beqs 59fd6 <_Heap_Size_of_alloc_area+0x6e> <== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
59fc4: 7204 moveq #4,%d1 59fc6: 9280 subl %d0,%d1 59fc8: 2001 movel %d1,%d0 59fca: d088 addl %a0,%d0 59fcc: 226e 0010 moveal %fp@(16),%a1 59fd0: 2280 movel %d0,%a1@
return true;
59fd2: 7001 moveq #1,%d0 59fd4: 6002 bras 59fd8 <_Heap_Size_of_alloc_area+0x70>
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
59fd6: 4200 clrb %d0
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
59fd8: 241f movel %sp@+,%d2 59fda: 4e5e unlk %fp
...
000473ce <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
473ce: 4e56 ffd0 linkw %fp,#-48 473d2: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 473d6: 266e 0008 moveal %fp@(8),%a3
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
473da: 45fa ffac lea %pc@(47388 <_Heap_Walk_print_nothing>),%a2
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
473de: 242e 000c movel %fp@(12),%d2
uintptr_t const page_size = heap->page_size;
473e2: 282b 0010 movel %a3@(16),%d4
uintptr_t const min_block_size = heap->min_block_size;
473e6: 2a2b 0014 movel %a3@(20),%d5
Heap_Block *const first_block = heap->first_block;
473ea: 2c2b 0020 movel %a3@(32),%d6
Heap_Block *const last_block = heap->last_block;
473ee: 2e2b 0024 movel %a3@(36),%d7
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
473f2: 4a2e 0013 tstb %fp@(19)
473f6: 6704 beqs 473fc <_Heap_Walk+0x2e>
473f8: 45fa ff96 lea %pc@(47390 <_Heap_Walk_print>),%a2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
473fc: 7003 moveq #3,%d0 473fe: b0b9 0005 fa48 cmpl 5fa48 <_System_state_Current>,%d0 47404: 6600 02fc bnew 47702 <_Heap_Walk+0x334>
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
47408: 2f2b 000c movel %a3@(12),%sp@- 4740c: 2f2b 0008 movel %a3@(8),%sp@- 47410: 2f07 movel %d7,%sp@- 47412: 2f06 movel %d6,%sp@- 47414: 2f2b 001c movel %a3@(28),%sp@- 47418: 2f2b 0018 movel %a3@(24),%sp@- 4741c: 2f05 movel %d5,%sp@- 4741e: 2f04 movel %d4,%sp@- 47420: 4879 0005 bf15 pea 5bf15 <_Status_Object_name_errors_to_status+0x5d> 47426: 42a7 clrl %sp@- 47428: 2f02 movel %d2,%sp@- 4742a: 4e92 jsr %a2@
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
4742c: 4fef 002c lea %sp@(44),%sp 47430: 4a84 tstl %d4
47432: 6608 bnes 4743c <_Heap_Walk+0x6e>
(*printer)( source, true, "page size is zero\n" );
47434: 4879 0005 bfa6 pea 5bfa6 <_Status_Object_name_errors_to_status+0xee> 4743a: 6050 bras 4748c <_Heap_Walk+0xbe>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
4743c: 7003 moveq #3,%d0 4743e: c084 andl %d4,%d0
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
47440: 670c beqs 4744e <_Heap_Walk+0x80>
(*printer)(
47442: 2f04 movel %d4,%sp@- 47444: 4879 0005 bfb9 pea 5bfb9 <_Status_Object_name_errors_to_status+0x101> 4744a: 6000 02ca braw 47716 <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
4744e: 2205 movel %d5,%d1 47450: 4c44 1000 remul %d4,%d0,%d1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
47454: 4a80 tstl %d0
47456: 670c beqs 47464 <_Heap_Walk+0x96>
(*printer)(
47458: 2f05 movel %d5,%sp@- 4745a: 4879 0005 bfd7 pea 5bfd7 <_Status_Object_name_errors_to_status+0x11f> 47460: 6000 02b4 braw 47716 <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
47464: 2006 movel %d6,%d0 47466: 5080 addql #8,%d0
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
47468: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if (
4746c: 4a81 tstl %d1
4746e: 670c beqs 4747c <_Heap_Walk+0xae>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
47470: 2f06 movel %d6,%sp@- 47472: 4879 0005 bffb pea 5bffb <_Status_Object_name_errors_to_status+0x143> 47478: 6000 029c braw 47716 <_Heap_Walk+0x348>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4747c: 7001 moveq #1,%d0 4747e: 2046 moveal %d6,%a0 47480: c0a8 0004 andl %a0@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
47484: 6616 bnes 4749c <_Heap_Walk+0xce>
(*printer)(
47486: 4879 0005 c02c pea 5c02c <_Status_Object_name_errors_to_status+0x174> 4748c: 4878 0001 pea 1 <ADD> 47490: 2f02 movel %d2,%sp@- 47492: 4e92 jsr %a2@ 47494: 4fef 000c lea %sp@(12),%sp 47498: 6000 00ba braw 47554 <_Heap_Walk+0x186>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4749c: 70fe moveq #-2,%d0 4749e: 2047 moveal %d7,%a0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
474a0: 2847 moveal %d7,%a4
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
474a2: c0a8 0004 andl %a0@(4),%d0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
474a6: d9c0 addal %d0,%a4
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
474a8: 7001 moveq #1,%d0 474aa: c0ac 0004 andl %a4@(4),%d0
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
474ae: 6608 bnes 474b8 <_Heap_Walk+0xea>
(*printer)(
474b0: 4879 0005 c05a pea 5c05a <_Status_Object_name_errors_to_status+0x1a2> 474b6: 60d4 bras 4748c <_Heap_Walk+0xbe>
);
return false;
}
if (
474b8: bc8c cmpl %a4,%d6
474ba: 6708 beqs 474c4 <_Heap_Walk+0xf6>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
474bc: 4879 0005 c06f pea 5c06f <_Status_Object_name_errors_to_status+0x1b7> 474c2: 60c8 bras 4748c <_Heap_Walk+0xbe>
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
474c4: 262b 0010 movel %a3@(16),%d3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
474c8: 220b movel %a3,%d1
block = next_block;
} while ( block != first_block );
return true;
}
474ca: 206b 0008 moveal %a3@(8),%a0 474ce: 2d44 fff8 movel %d4,%fp@(-8) 474d2: 2d43 fffc movel %d3,%fp@(-4) 474d6: 6000 0088 braw 47560 <_Heap_Walk+0x192>
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
474da: b1eb 0020 cmpal %a3@(32),%a0
474de: 650c bcss 474ec <_Heap_Walk+0x11e>
474e0: b1eb 0024 cmpal %a3@(36),%a0 474e4: 53c0 sls %d0 474e6: 49c0 extbl %d0 474e8: 4480 negl %d0 474ea: 6002 bras 474ee <_Heap_Walk+0x120> 474ec: 4280 clrl %d0
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
474ee: 4a00 tstb %d0
474f0: 660c bnes 474fe <_Heap_Walk+0x130>
(*printer)(
474f2: 2f08 movel %a0,%sp@- 474f4: 4879 0005 c09e pea 5c09e <_Status_Object_name_errors_to_status+0x1e6> 474fa: 6000 021a braw 47716 <_Heap_Walk+0x348>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
474fe: 4be8 0008 lea %a0@(8),%a5
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
47502: 200d movel %a5,%d0 47504: 262e fffc movel %fp@(-4),%d3 47508: 4c43 0004 remul %d3,%d4,%d0
);
return false;
}
if (
4750c: 4a84 tstl %d4
4750e: 670c beqs 4751c <_Heap_Walk+0x14e>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
47510: 2f08 movel %a0,%sp@- 47512: 4879 0005 c0be pea 5c0be <_Status_Object_name_errors_to_status+0x206> 47518: 6000 01fc braw 47716 <_Heap_Walk+0x348>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
4751c: 70fe moveq #-2,%d0
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4751e: 7601 moveq #1,%d3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
47520: c0a8 0004 andl %a0@(4),%d0
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
47524: c6b0 0804 andl %a0@(00000004,%d0:l),%d3
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
47528: 670c beqs 47536 <_Heap_Walk+0x168>
(*printer)(
4752a: 2f08 movel %a0,%sp@- 4752c: 4879 0005 c0ee pea 5c0ee <_Status_Object_name_errors_to_status+0x236> 47532: 6000 01e2 braw 47716 <_Heap_Walk+0x348>
);
return false;
}
if ( free_block->prev != prev_block ) {
47536: 2028 000c movel %a0@(12),%d0 4753a: b280 cmpl %d0,%d1
4753c: 671c beqs 4755a <_Heap_Walk+0x18c>
(*printer)(
4753e: 2f00 movel %d0,%sp@- 47540: 2f08 movel %a0,%sp@- 47542: 4879 0005 c10a pea 5c10a <_Status_Object_name_errors_to_status+0x252> 47548: 4878 0001 pea 1 <ADD> 4754c: 2f02 movel %d2,%sp@- 4754e: 4e92 jsr %a2@ 47550: 4fef 0014 lea %sp@(20),%sp
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
47554: 4200 clrb %d0 47556: 6000 01ac braw 47704 <_Heap_Walk+0x336>
return false;
}
prev_block = free_block;
free_block = free_block->next;
4755a: 2208 movel %a0,%d1 4755c: 2068 0008 moveal %a0@(8),%a0
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
47560: b7c8 cmpal %a0,%a3 47562: 6600 ff76 bnew 474da <_Heap_Walk+0x10c> 47566: 282e fff8 movel %fp@(-8),%d4 4756a: 6002 bras 4756e <_Heap_Walk+0x1a0>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
4756c: 284d moveal %a5,%a4
return true;
}
4756e: 202c 0004 movel %a4@(4),%d0
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
47572: 76fe moveq #-2,%d3 47574: c680 andl %d0,%d3 47576: 2d40 fffc movel %d0,%fp@(-4)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
4757a: 4bf4 3800 lea %a4@(00000000,%d3:l),%a5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
4757e: bbeb 0020 cmpal %a3@(32),%a5
47582: 650c bcss 47590 <_Heap_Walk+0x1c2> <== NEVER TAKEN
47584: bbeb 0024 cmpal %a3@(36),%a5 47588: 53c0 sls %d0 4758a: 49c0 extbl %d0 4758c: 4480 negl %d0 4758e: 6002 bras 47592 <_Heap_Walk+0x1c4>
47590: 4280 clrl %d0 <== NOT EXECUTED
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
47592: 4a00 tstb %d0
47594: 660c bnes 475a2 <_Heap_Walk+0x1d4>
(*printer)(
47596: 2f0d movel %a5,%sp@- 47598: 2f0c movel %a4,%sp@- 4759a: 4879 0005 c13c pea 5c13c <_Status_Object_name_errors_to_status+0x284> 475a0: 60a6 bras 47548 <_Heap_Walk+0x17a>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
475a2: be8c cmpl %a4,%d7 475a4: 56c0 sne %d0 475a6: 2200 movel %d0,%d1 475a8: 4481 negl %d1
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
475aa: 2003 movel %d3,%d0 475ac: 1d41 fffb moveb %d1,%fp@(-5) 475b0: 4c44 0001 remul %d4,%d1,%d0
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
475b4: 4a81 tstl %d1
475b6: 6714 beqs 475cc <_Heap_Walk+0x1fe>
475b8: 4a2e fffb tstb %fp@(-5)
475bc: 670e beqs 475cc <_Heap_Walk+0x1fe>
(*printer)(
475be: 2f03 movel %d3,%sp@- 475c0: 2f0c movel %a4,%sp@- 475c2: 4879 0005 c169 pea 5c169 <_Status_Object_name_errors_to_status+0x2b1> 475c8: 6000 ff7e braw 47548 <_Heap_Walk+0x17a>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
475cc: ba83 cmpl %d3,%d5
475ce: 6322 blss 475f2 <_Heap_Walk+0x224>
475d0: 4a2e fffb tstb %fp@(-5)
475d4: 671c beqs 475f2 <_Heap_Walk+0x224> <== NEVER TAKEN
(*printer)(
475d6: 2f05 movel %d5,%sp@- 475d8: 2f03 movel %d3,%sp@- 475da: 2f0c movel %a4,%sp@- 475dc: 4879 0005 c197 pea 5c197 <_Status_Object_name_errors_to_status+0x2df> 475e2: 4878 0001 pea 1 <ADD> 475e6: 2f02 movel %d2,%sp@- 475e8: 4e92 jsr %a2@
block,
block_size,
min_block_size
);
return false;
475ea: 4fef 0018 lea %sp@(24),%sp 475ee: 6000 ff64 braw 47554 <_Heap_Walk+0x186>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
475f2: b9cd cmpal %a5,%a4
475f4: 6514 bcss 4760a <_Heap_Walk+0x23c>
475f6: 4a2e fffb tstb %fp@(-5)
475fa: 670e beqs 4760a <_Heap_Walk+0x23c>
(*printer)(
475fc: 2f0d movel %a5,%sp@- 475fe: 2f0c movel %a4,%sp@- 47600: 4879 0005 c1c2 pea 5c1c2 <_Status_Object_name_errors_to_status+0x30a> 47606: 6000 ff40 braw 47548 <_Heap_Walk+0x17a>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
4760a: 7001 moveq #1,%d0 4760c: c0ae fffc andl %fp@(-4),%d0 47610: 2d40 fffc movel %d0,%fp@(-4) 47614: 7001 moveq #1,%d0 47616: c0ad 0004 andl %a5@(4),%d0
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
4761a: 6600 00ae bnew 476ca <_Heap_Walk+0x2fc>
block = next_block;
} while ( block != first_block );
return true;
}
4761e: 222b 0008 movel %a3@(8),%d1
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
47622: 43f9 0005 bee2 lea 5bee2 <_Status_Object_name_errors_to_status+0x2a>,%a1
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
47628: 206c 0008 moveal %a4@(8),%a0
block = next_block;
} while ( block != first_block );
return true;
}
4762c: 2d41 fff8 movel %d1,%fp@(-8)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
47630: b1eb 000c cmpal %a3@(12),%a0
47634: 6710 beqs 47646 <_Heap_Walk+0x278>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
47636: 43f9 0005 be2e lea 5be2e <rtems_filesystem_default_pathconf+0xb4>,%a1 4763c: b7c8 cmpal %a0,%a3
4763e: 6606 bnes 47646 <_Heap_Walk+0x278>
47640: 43f9 0005 bef1 lea 5bef1 <_Status_Object_name_errors_to_status+0x39>,%a1
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
47646: 202c 000c movel %a4@(12),%d0
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
4764a: 223c 0005 befb movel #376571,%d1 47650: b0ae fff8 cmpl %fp@(-8),%d0
47654: 6710 beqs 47666 <_Heap_Walk+0x298>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
47656: 223c 0005 be2e movel #376366,%d1 4765c: b7c0 cmpal %d0,%a3
4765e: 6606 bnes 47666 <_Heap_Walk+0x298>
47660: 223c 0005 bf0b movel #376587,%d1
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
47666: 2f09 movel %a1,%sp@- 47668: 2f08 movel %a0,%sp@- 4766a: 2f01 movel %d1,%sp@- 4766c: 2f00 movel %d0,%sp@- 4766e: 2f03 movel %d3,%sp@- 47670: 2f0c movel %a4,%sp@- 47672: 4879 0005 c1f6 pea 5c1f6 <_Status_Object_name_errors_to_status+0x33e> 47678: 42a7 clrl %sp@- 4767a: 2f02 movel %d2,%sp@- 4767c: 4e92 jsr %a2@
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
4767e: 2015 movel %a5@,%d0 47680: 4fef 0024 lea %sp@(36),%sp 47684: b083 cmpl %d3,%d0
47686: 671e beqs 476a6 <_Heap_Walk+0x2d8>
(*printer)(
47688: 2f0d movel %a5,%sp@- 4768a: 2f00 movel %d0,%sp@- 4768c: 2f03 movel %d3,%sp@- 4768e: 2f0c movel %a4,%sp@- 47690: 4879 0005 c22b pea 5c22b <_Status_Object_name_errors_to_status+0x373> 47696: 4878 0001 pea 1 <ADD> 4769a: 2f02 movel %d2,%sp@- 4769c: 4e92 jsr %a2@ 4769e: 4fef 001c lea %sp@(28),%sp 476a2: 6000 feb0 braw 47554 <_Heap_Walk+0x186>
);
return false;
}
if ( !prev_used ) {
476a6: 4aae fffc tstl %fp@(-4)
476aa: 660a bnes 476b6 <_Heap_Walk+0x2e8>
(*printer)(
476ac: 2f0c movel %a4,%sp@- 476ae: 4879 0005 c264 pea 5c264 <_Status_Object_name_errors_to_status+0x3ac> 476b4: 6060 bras 47716 <_Heap_Walk+0x348>
block = next_block;
} while ( block != first_block );
return true;
}
476b6: 206b 0008 moveal %a3@(8),%a0 476ba: 6008 bras 476c4 <_Heap_Walk+0x2f6>
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
476bc: b9c8 cmpal %a0,%a4
476be: 673c beqs 476fc <_Heap_Walk+0x32e>
return true;
}
free_block = free_block->next;
476c0: 2068 0008 moveal %a0@(8),%a0
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
476c4: b7c8 cmpal %a0,%a3
476c6: 66f4 bnes 476bc <_Heap_Walk+0x2ee>
476c8: 6044 bras 4770e <_Heap_Walk+0x340>
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
476ca: 4aae fffc tstl %fp@(-4)
476ce: 6716 beqs 476e6 <_Heap_Walk+0x318>
(*printer)(
476d0: 2f03 movel %d3,%sp@- 476d2: 2f0c movel %a4,%sp@- 476d4: 4879 0005 c293 pea 5c293 <_Status_Object_name_errors_to_status+0x3db> 476da: 42a7 clrl %sp@- 476dc: 2f02 movel %d2,%sp@- 476de: 4e92 jsr %a2@ 476e0: 4fef 0014 lea %sp@(20),%sp 476e4: 6016 bras 476fc <_Heap_Walk+0x32e>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
476e6: 2f14 movel %a4@,%sp@- 476e8: 2f03 movel %d3,%sp@- 476ea: 2f0c movel %a4,%sp@- 476ec: 4879 0005 c2aa pea 5c2aa <_Status_Object_name_errors_to_status+0x3f2> 476f2: 42a7 clrl %sp@- 476f4: 2f02 movel %d2,%sp@- 476f6: 4e92 jsr %a2@ 476f8: 4fef 0018 lea %sp@(24),%sp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
476fc: bc8d cmpl %a5,%d6 476fe: 6600 fe6c bnew 4756c <_Heap_Walk+0x19e>
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
47702: 7001 moveq #1,%d0
block = next_block;
} while ( block != first_block );
return true;
}
47704: 4cee 3cfc ffd0 moveml %fp@(-48),%d2-%d7/%a2-%a5 4770a: 4e5e unlk %fp 4770c: 4e75 rts
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
4770e: 2f0c movel %a4,%sp@- 47710: 4879 0005 c2cf pea 5c2cf <_Status_Object_name_errors_to_status+0x417> 47716: 4878 0001 pea 1 <ADD> 4771a: 2f02 movel %d2,%sp@- 4771c: 4e92 jsr %a2@ 4771e: 4fef 0010 lea %sp@(16),%sp 47722: 6000 fe30 braw 47554 <_Heap_Walk+0x186>
...
000469b0 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
469b0: 4e56 0000 linkw %fp,#0 469b4: 222e 000c movel %fp@(12),%d1 469b8: 2f02 movel %d2,%sp@- 469ba: 242e 0010 movel %fp@(16),%d2
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
469be: 13c1 0005 d5f2 moveb %d1,5d5f2 <_Internal_errors_What_happened+0x4>
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
469c4: 2f02 movel %d2,%sp@-
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
469c6: 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 );
469ca: 0281 0000 00ff andil #255,%d1
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
469d0: 23c0 0005 d5ee movel %d0,5d5ee <_Internal_errors_What_happened>
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
469d6: 2f01 movel %d1,%sp@-
)
{
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
469d8: 23c2 0005 d5f4 movel %d2,5d5f4 <_Internal_errors_What_happened+0x6>
_User_extensions_Fatal( the_source, is_internal, the_error );
469de: 2f00 movel %d0,%sp@- 469e0: 4eb9 0004 8522 jsr 48522 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
469e6: 7005 moveq #5,%d0 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
469e8: 2042 moveal %d2,%a0 <== NOT EXECUTED 469ea: 243c 0000 0700 movel #1792,%d2 <== NOT EXECUTED 469f0: 23c0 0005 d6a0 movel %d0,5d6a0 <_System_state_Current> <== NOT EXECUTED 469f6: 40c0 movew %sr,%d0 <== NOT EXECUTED 469f8: 8082 orl %d2,%d0 <== NOT EXECUTED 469fa: 46c0 movew %d0,%sr <== NOT EXECUTED 469fc: 2008 movel %a0,%d0 <== NOT EXECUTED 469fe: 223c dead beef movel #-559038737,%d1 <== NOT EXECUTED 46a04: 4ac8 halt <== NOT EXECUTED 46a06: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED 46a0a: 60fe bras 46a0a <_Internal_error_Occurred+0x5a> <== NOT EXECUTED
00046a6c <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
46a6c: 4e56 fff0 linkw %fp,#-16 46a70: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@ 46a74: 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 )
46a78: 4aaa 0014 tstl %a2@(20)
46a7c: 675e beqs 46adc <_Objects_Allocate+0x70> <== NEVER TAKEN
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
46a7e: 240a movel %a2,%d2 46a80: 0682 0000 001c addil #28,%d2 46a86: 47f9 0004 6210 lea 46210 <_Chain_Get>,%a3 46a8c: 2f02 movel %d2,%sp@- 46a8e: 4e93 jsr %a3@
if ( information->auto_extend ) {
46a90: 588f addql #4,%sp 46a92: 4a2a 0010 tstb %a2@(16)
46a96: 6746 beqs 46ade <_Objects_Allocate+0x72>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
46a98: 4a80 tstl %d0
46a9a: 6612 bnes 46aae <_Objects_Allocate+0x42>
_Objects_Extend_information( information );
46a9c: 2f0a movel %a2,%sp@- 46a9e: 4eb9 0004 6b14 jsr 46b14 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
46aa4: 2f02 movel %d2,%sp@- 46aa6: 4e93 jsr %a3@
}
if ( the_object ) {
46aa8: 508f addql #8,%sp 46aaa: 4a80 tstl %d0
46aac: 6730 beqs 46ade <_Objects_Allocate+0x72>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46aae: 2040 moveal %d0,%a0 46ab0: 4281 clrl %d1 46ab2: 4282 clrl %d2 46ab4: 3228 000a movew %a0@(10),%d1 46ab8: 342a 0008 movew %a2@(8),%d2
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
46abc: 206a 002a moveal %a2@(42),%a0
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
46ac0: 9282 subl %d2,%d1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
46ac2: 342a 0012 movew %a2@(18),%d2 46ac6: 4c42 1001 remul %d2,%d1,%d1
information->inactive_per_block[ block ]--;
46aca: e589 lsll #2,%d1 46acc: d1c1 addal %d1,%a0 46ace: 5390 subql #1,%a0@
information->inactive--;
46ad0: 322a 0028 movew %a2@(40),%d1 46ad4: 5381 subql #1,%d1 46ad6: 3541 0028 movew %d1,%a2@(40) 46ada: 6002 bras 46ade <_Objects_Allocate+0x72>
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
return NULL;
46adc: 4280 clrl %d0 <== NOT EXECUTED
);
}
#endif
return the_object;
}
46ade: 4cee 0c0c fff0 moveml %fp@(-16),%d2-%d3/%a2-%a3
46ae4: 4e5e unlk %fp <== NOT EXECUTED
00046ae8 <_Objects_Close>:
RTEMS_INLINE_ROUTINE void _Objects_Invalidate_Id(
Objects_Information *information,
Objects_Control *the_object
)
{
_Objects_Set_local_object(
46ae8: 4280 clrl %d0
void _Objects_Close(
Objects_Information *information,
Objects_Control *the_object
)
{
46aea: 4e56 0000 linkw %fp,#0 46aee: 226e 000c moveal %fp@(12),%a1 46af2: 206e 0008 moveal %fp@(8),%a0 46af6: 2f0a movel %a2,%sp@-
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
46af8: 2468 0018 moveal %a0@(24),%a2
RTEMS_INLINE_ROUTINE void _Objects_Invalidate_Id(
Objects_Information *information,
Objects_Control *the_object
)
{
_Objects_Set_local_object(
46afc: 3029 000a movew %a1@(10),%d0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
46b00: 42b2 0c00 clrl %a2@(00000000,%d0:l:4)
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
}
46b04: 245f moveal %sp@+,%a2
Objects_Control *the_object
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
46b06: 2d49 000c movel %a1,%fp@(12)
}
46b0a: 4e5e unlk %fp
Objects_Control *the_object
)
{
_Objects_Invalidate_Id( information, the_object );
_Objects_Namespace_remove( information, the_object );
46b0c: 4ef9 0004 7004 jmp 47004 <_Objects_Namespace_remove>
...
00046e0c <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
46e0c: 4e56 0000 linkw %fp,#0 46e10: 2f03 movel %d3,%sp@- 46e12: 362e 000e movew %fp@(14),%d3 46e16: 2f02 movel %d2,%sp@- 46e18: 242e 0008 movel %fp@(8),%d2
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
46e1c: 4a43 tstw %d3
46e1e: 673a beqs 46e5a <_Objects_Get_information+0x4e>
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
46e20: 2f02 movel %d2,%sp@- 46e22: 4eb9 0004 a6ac jsr 4a6ac <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
46e28: 588f addql #4,%sp 46e2a: 4a80 tstl %d0
46e2c: 672c beqs 46e5a <_Objects_Get_information+0x4e>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
46e2e: 0283 0000 ffff andil #65535,%d3 46e34: b083 cmpl %d3,%d0
46e36: 6522 bcss 46e5a <_Objects_Get_information+0x4e>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
46e38: 41f9 0005 d514 lea 5d514 <_Objects_Information_table>,%a0 46e3e: 2070 2c00 moveal %a0@(00000000,%d2:l:4),%a0 46e42: 4a88 tstl %a0
46e44: 6714 beqs 46e5a <_Objects_Get_information+0x4e> <== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
46e46: 2030 3c00 movel %a0@(00000000,%d3:l:4),%d0
if ( !info )
46e4a: 6710 beqs 46e5c <_Objects_Get_information+0x50> <== NEVER TAKEN
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
return NULL;
46e4c: 2040 moveal %d0,%a0 46e4e: 4a68 000e tstw %a0@(14) 46e52: 56c1 sne %d1 46e54: 49c1 extbl %d1 46e56: c081 andl %d1,%d0 46e58: 6002 bras 46e5c <_Objects_Get_information+0x50>
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
return NULL;
46e5a: 4280 clrl %d0
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
46e5c: 242e fff8 movel %fp@(-8),%d2 46e60: 262e fffc movel %fp@(-4),%d3
46e64: 4e5e unlk %fp <== NOT EXECUTED
00054574 <_Objects_Get_no_protection>:
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
54574: 7001 moveq #1,%d0
if ( information->maximum >= index ) {
54576: 4281 clrl %d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
54578: 4e56 0000 linkw %fp,#0 5457c: 206e 0008 moveal %fp@(8),%a0
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
54580: 90a8 0006 subl %a0@(6),%d0 54584: d0ae 000c addl %fp@(12),%d0
if ( information->maximum >= index ) {
54588: 3228 000e movew %a0@(14),%d1
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
5458c: 226e 0010 moveal %fp@(16),%a1
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
if ( information->maximum >= index ) {
54590: b081 cmpl %d1,%d0
54592: 620e bhis 545a2 <_Objects_Get_no_protection+0x2e>
if ( (the_object = information->local_table[ index ]) != NULL ) {
54594: 2068 0018 moveal %a0@(24),%a0 54598: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
5459c: 6704 beqs 545a2 <_Objects_Get_no_protection+0x2e><== NEVER TAKEN
*location = OBJECTS_LOCAL;
5459e: 4291 clrl %a1@
return the_object;
545a0: 6006 bras 545a8 <_Objects_Get_no_protection+0x34>
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
545a2: 7001 moveq #1,%d0 545a4: 2280 movel %d0,%a1@
return NULL;
545a6: 4280 clrl %d0
}
545a8: 4e5e unlk %fp <== NOT EXECUTED
00047dec <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
47dec: 4e56 fffc linkw %fp,#-4 47df0: 222e 0008 movel %fp@(8),%d1 47df4: 2f02 movel %d2,%sp@-
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
47df6: 4a81 tstl %d1
47df8: 660a bnes 47e04 <_Objects_Id_to_name+0x18>
47dfa: 2079 0005 ebac moveal 5ebac <_Per_CPU_Information+0xc>,%a0 47e00: 2228 0008 movel %a0@(8),%d1 47e04: 7418 moveq #24,%d2 47e06: 2001 movel %d1,%d0 47e08: e4a8 lsrl %d2,%d0 47e0a: 143c 0007 moveb #7,%d2 47e0e: c082 andl %d2,%d0
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
47e10: 143c 0002 moveb #2,%d2 47e14: 2040 moveal %d0,%a0 47e16: 5388 subql #1,%a0 47e18: b488 cmpl %a0,%d2
47e1a: 6538 bcss 47e54 <_Objects_Id_to_name+0x68> <== NEVER TAKEN
47e1c: 6040 bras 47e5e <_Objects_Id_to_name+0x72>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
47e1e: 2001 movel %d1,%d0 47e20: 741b moveq #27,%d2 47e22: e4a8 lsrl %d2,%d0
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
47e24: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
if ( !information )
47e28: 672a beqs 47e54 <_Objects_Id_to_name+0x68> <== NEVER TAKEN
#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 );
47e2a: 486e fffc pea %fp@(-4) 47e2e: 2f01 movel %d1,%sp@- 47e30: 2f00 movel %d0,%sp@- 47e32: 4eb9 0004 7d8c jsr 47d8c <_Objects_Get>
if ( !the_object )
47e38: 4fef 000c lea %sp@(12),%sp 47e3c: 4a80 tstl %d0
47e3e: 6714 beqs 47e54 <_Objects_Id_to_name+0x68>
return OBJECTS_INVALID_ID;
*name = the_object->name;
47e40: 206e 000c moveal %fp@(12),%a0 47e44: 2240 moveal %d0,%a1 47e46: 20a9 000c movel %a1@(12),%a0@
_Thread_Enable_dispatch();
47e4a: 4eb9 0004 8986 jsr 48986 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
47e50: 4280 clrl %d0 47e52: 6002 bras 47e56 <_Objects_Id_to_name+0x6a>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
47e54: 7003 moveq #3,%d0
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
47e56: 242e fff8 movel %fp@(-8),%d2 47e5a: 4e5e unlk %fp 47e5c: 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 ] )
47e5e: 41f9 0005 e9cc lea 5e9cc <_Objects_Information_table>,%a0 47e64: 2070 0c00 moveal %a0@(00000000,%d0:l:4),%a0 47e68: 4a88 tstl %a0
47e6a: 66b2 bnes 47e1e <_Objects_Id_to_name+0x32>
47e6c: 60e6 bras 47e54 <_Objects_Id_to_name+0x68>
...
00049fe0 <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
49fe0: 4e56 ffec linkw %fp,#-20
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
49fe4: 206e 0008 moveal %fp@(8),%a0
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
49fe8: 48d7 0c0c moveml %d2-%d3/%a2-%a3,%sp@
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
49fec: 2468 00fc moveal %a0@(252),%a2
if ( !api )
49ff0: 4a8a tstl %a2
49ff2: 6754 beqs 4a048 <_RTEMS_tasks_Post_switch_extension+0x68><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
49ff4: 203c 0000 0700 movel #1792,%d0 49ffa: 40c1 movew %sr,%d1 49ffc: 8081 orl %d1,%d0 49ffe: 46c0 movew %d0,%sr
signal_set = asr->signals_posted;
4a000: 262a 0012 movel %a2@(18),%d3
asr->signals_posted = 0;
4a004: 42aa 0012 clrl %a2@(18)
_ISR_Enable( level );
4a008: 46c1 movew %d1,%sr
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
4a00a: 4a83 tstl %d3
4a00c: 673a beqs 4a048 <_RTEMS_tasks_Post_switch_extension+0x68>
return;
asr->nest_level += 1;
4a00e: 52aa 001a addql #1,%a2@(26)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
4a012: 240e movel %fp,%d2 4a014: 5982 subql #4,%d2 4a016: 47f9 0004 b8a0 lea 4b8a0 <rtems_task_mode>,%a3 4a01c: 2f02 movel %d2,%sp@- 4a01e: 2f3c 0000 ffff movel #65535,%sp@- 4a024: 2f2a 000e movel %a2@(14),%sp@- 4a028: 4e93 jsr %a3@
(*asr->handler)( signal_set );
4a02a: 2f03 movel %d3,%sp@- 4a02c: 206a 000a moveal %a2@(10),%a0 4a030: 4e90 jsr %a0@
asr->nest_level -= 1;
4a032: 53aa 001a subql #1,%a2@(26)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
4a036: 2f02 movel %d2,%sp@- 4a038: 2f3c 0000 ffff movel #65535,%sp@- 4a03e: 2f2e fffc movel %fp@(-4),%sp@- 4a042: 4e93 jsr %a3@ 4a044: 4fef 001c lea %sp@(28),%sp
}
4a048: 4cee 0c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a3
4a04e: 4e5e unlk %fp <== NOT EXECUTED
0004637c <_Rate_monotonic_Get_status>:
bool _Rate_monotonic_Get_status(
Rate_monotonic_Control *the_period,
Rate_monotonic_Period_time_t *wall_since_last_period,
Thread_CPU_usage_t *cpu_since_last_period
)
{
4637c: 4e56 ffd4 linkw %fp,#-44 46380: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ 46384: 266e 0008 moveal %fp@(8),%a3
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
46388: 240e movel %fp,%d2 4638a: 5182 subql #8,%d2
_Timestamp_Subtract(
4638c: 45f9 0004 9ab4 lea 49ab4 <_Timespec_Subtract>,%a2
)
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
46392: 286b 0040 moveal %a3@(64),%a4
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
46396: 2f02 movel %d2,%sp@- 46398: 4eb9 0004 7ac0 jsr 47ac0 <_TOD_Get_uptime>
_Timestamp_Subtract(
4639e: 2f2e 000c movel %fp@(12),%sp@- 463a2: 2f02 movel %d2,%sp@- 463a4: 486b 004c pea %a3@(76) 463a8: 4e92 jsr %a2@
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
463aa: 4fef 0010 lea %sp@(16),%sp
#endif
/*
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
463ae: 202c 0082 movel %a4@(130),%d0 463b2: 222c 0086 movel %a4@(134),%d1 463b6: 2d40 fff0 movel %d0,%fp@(-16) 463ba: 2d41 fff4 movel %d1,%fp@(-12)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
463be: b9f9 0005 f2ec cmpal 5f2ec <_Per_CPU_Information+0xc>,%a4
463c4: 6644 bnes 4640a <_Rate_monotonic_Get_status+0x8e><== NEVER TAKEN
Thread_CPU_usage_t ran;
/* How much time time since last context switch */
_Timestamp_Subtract(
463c6: 260e movel %fp,%d3 463c8: 0683 ffff ffe8 addil #-24,%d3
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
463ce: 47eb 0044 lea %a3@(68),%a3
if (owning_thread == _Thread_Executing) {
Thread_CPU_usage_t ran;
/* How much time time since last context switch */
_Timestamp_Subtract(
463d2: 2f03 movel %d3,%sp@- 463d4: 2f02 movel %d2,%sp@- 463d6: 4879 0005 f1fc pea 5f1fc <_Thread_Time_of_last_context_switch>
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
/* cpu usage += ran */
_Timestamp_Add_to( &used, &ran );
463dc: 5182 subql #8,%d2
if (owning_thread == _Thread_Executing) {
Thread_CPU_usage_t ran;
/* How much time time since last context switch */
_Timestamp_Subtract(
463de: 4e92 jsr %a2@
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
/* cpu usage += ran */
_Timestamp_Add_to( &used, &ran );
463e0: 2f03 movel %d3,%sp@- 463e2: 2f02 movel %d2,%sp@- 463e4: 4eb9 0004 998c jsr 4998c <_Timespec_Add_to>
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
463ea: 2f0b movel %a3,%sp@- 463ec: 2f02 movel %d2,%sp@- 463ee: 4eb9 0004 9a84 jsr 49a84 <_Timespec_Less_than> 463f4: 4fef 001c lea %sp@(28),%sp 463f8: 4a00 tstb %d0
463fa: 6612 bnes 4640e <_Rate_monotonic_Get_status+0x92>
return false;
/* used = current cpu usage - cpu usage at start of period */
_Timestamp_Subtract(
463fc: 2f2e 0010 movel %fp@(16),%sp@- 46400: 2f02 movel %d2,%sp@- 46402: 2f0b movel %a3,%sp@- 46404: 4e92 jsr %a2@ 46406: 4fef 000c lea %sp@(12),%sp
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
4640a: 7001 moveq #1,%d0 4640c: 6002 bras 46410 <_Rate_monotonic_Get_status+0x94>
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
return false;
4640e: 4200 clrb %d0
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
46410: 4cee 1c0c ffd4 moveml %fp@(-44),%d2-%d3/%a2-%a4
46416: 4e5e unlk %fp <== NOT EXECUTED
0005783c <_Region_Process_queue>:
*/
void _Region_Process_queue(
Region_Control *the_region
)
{
5783c: 4e56 ffe4 linkw %fp,#-28
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
57840: 2039 0007 5f54 movel 75f54 <_Thread_Dispatch_disable_level>,%d0 57846: 5280 addql #1,%d0 57848: 48d7 3c1c moveml %d2-%d4/%a2-%a5,%sp@ 5784c: 266e 0008 moveal %fp@(8),%a3 57850: 23c0 0007 5f54 movel %d0,75f54 <_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();
57856: 2f39 0007 5ff4 movel 75ff4 <_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 );
5785c: 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 );
5785e: 260b movel %a3,%d3 57860: 0682 0000 0010 addil #16,%d2 57866: 0683 0000 0068 addil #104,%d3 5786c: 4bf9 0005 3644 lea 53644 <_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 );
57872: 49f9 0005 7e20 lea 57e20 <_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();
57878: 4eb9 0005 2c98 jsr 52c98 <_API_Mutex_Unlock> 5787e: 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 );
57880: 283c 0005 7f24 movel #360228,%d4 57886: 2f02 movel %d2,%sp@- 57888: 2044 moveal %d4,%a0 5788a: 4e90 jsr %a0@
if ( the_thread == NULL )
5788c: 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 );
5788e: 2440 moveal %d0,%a2
if ( the_thread == NULL )
57890: 4a80 tstl %d0
57892: 672c beqs 578c0 <_Region_Process_queue+0x84>
57894: 42a7 clrl %sp@- 57896: 42a7 clrl %sp@- 57898: 2f2a 0024 movel %a2@(36),%sp@- 5789c: 2f03 movel %d3,%sp@- 5789e: 4e95 jsr %a5@
the_segment = (void **) _Region_Allocate_segment(
the_region,
the_thread->Wait.count
);
if ( the_segment == NULL )
578a0: 4fef 0010 lea %sp@(16),%sp 578a4: 4a80 tstl %d0
578a6: 6718 beqs 578c0 <_Region_Process_queue+0x84>
break;
*(void **)the_thread->Wait.return_argument = the_segment;
578a8: 206a 0028 moveal %a2@(40),%a0 578ac: 2080 movel %d0,%a0@
the_region->number_of_used_blocks += 1;
578ae: 52ab 0064 addql #1,%a3@(100)
_Thread_queue_Extract( &the_region->Wait_queue, the_thread );
578b2: 2f0a movel %a2,%sp@- 578b4: 2f02 movel %d2,%sp@- 578b6: 4e94 jsr %a4@
the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
}
578b8: 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;
578ba: 42aa 0034 clrl %a2@(52)
}
578be: 60c6 bras 57886 <_Region_Process_queue+0x4a>
_Thread_Enable_dispatch(); }
578c0: 4cee 3c1c ffe4 moveml %fp@(-28),%d2-%d4/%a2-%a5 578c6: 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();
578c8: 4ef9 0005 5122 jmp 55122 <_Thread_Enable_dispatch>
...
000471b8 <_Scheduler_Handler_initialization>:
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
471b8: 4e56 0000 linkw %fp,#0
(*_Scheduler.Operations.initialize)(); }
471bc: 4e5e unlk %fp
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
void _Scheduler_Handler_initialization(void)
{
(*_Scheduler.Operations.initialize)();
471be: 2279 0005 bc24 moveal 5bc24 <_Scheduler+0x4>,%a1 471c4: 4ed1 jmp %a1@
...
000471e4 <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
471e4: 4e56 0000 linkw %fp,#0 471e8: 226e 0008 moveal %fp@(8),%a1 471ec: 2f0a movel %a2,%sp@-
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
471ee: 2469 008a moveal %a1@(138),%a2
ready = sched_info->ready_chain;
471f2: 2052 moveal %a2@,%a0
if ( _Chain_Has_only_one_node( ready ) ) {
471f4: 2028 0008 movel %a0@(8),%d0 471f8: b090 cmpl %a0@,%d0
471fa: 6632 bnes 4722e <_Scheduler_priority_Block+0x4a> Chain_Node *tail = _Chain_Tail( the_chain );
471fc: 2008 movel %a0,%d0 471fe: 5880 addql #4,%d0
head->next = tail;
head->previous = NULL;
47200: 42a8 0004 clrl %a0@(4)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
47204: 2080 movel %d0,%a0@
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
47206: 302a 000e movew %a2@(14),%d0
head->next = tail;
head->previous = NULL;
tail->previous = head;
4720a: 2148 0008 movel %a0,%a0@(8) 4720e: 206a 0004 moveal %a2@(4),%a0 47212: 3210 movew %a0@,%d1 47214: c081 andl %d1,%d0 47216: 3080 movew %d0,%a0@
if ( *the_priority_map->minor == 0 )
47218: 6620 bnes 4723a <_Scheduler_priority_Block+0x56>
_Priority_Major_bit_map &= the_priority_map->block_major;
4721a: 3039 0005 d704 movew 5d704 <_Priority_Major_bit_map>,%d0 47220: 322a 000c movew %a2@(12),%d1 47224: c081 andl %d1,%d0 47226: 33c0 0005 d704 movew %d0,5d704 <_Priority_Major_bit_map> 4722c: 600c bras 4723a <_Scheduler_priority_Block+0x56>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4722e: 2451 moveal %a1@,%a2
previous = the_node->previous;
47230: 2069 0004 moveal %a1@(4),%a0
next->previous = previous;
47234: 2548 0004 movel %a0,%a2@(4)
previous->next = next;
47238: 208a movel %a2,%a0@
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
4723a: b3f9 0005 d6f8 cmpal 5d6f8 <_Per_CPU_Information+0x10>,%a1
47240: 6646 bnes 47288 <_Scheduler_priority_Block+0xa4>
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
47242: 3039 0005 d704 movew 5d704 <_Priority_Major_bit_map>,%d0 47248: 4840 swap %d0 4724a: 04c0 ff1 %d0
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
4724c: 41f9 0005 d708 lea 5d708 <_Priority_Bit_map>,%a0 47252: 0280 0000 ffff andil #65535,%d0 47258: 3230 0a00 movew %a0@(00000000,%d0:l:2),%d1 4725c: 4841 swap %d1 4725e: 04c1 ff1 %d1
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
47260: 2079 0005 bc20 moveal 5bc20 <_Scheduler>,%a0
return (_Priority_Bits_index( major ) << 4) +
47266: 0281 0000 ffff andil #65535,%d1 4726c: e988 lsll #4,%d0 4726e: d081 addl %d1,%d0
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
47270: 2200 movel %d0,%d1 47272: e988 lsll #4,%d0 47274: e589 lsll #2,%d1 47276: 9081 subl %d1,%d0 47278: d1c0 addal %d0,%a0 4727a: 2018 movel %a0@+,%d0 4727c: b1c0 cmpal %d0,%a0
4727e: 6602 bnes 47282 <_Scheduler_priority_Block+0x9e> <== ALWAYS TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
47280: 4280 clrl %d0 <== NOT EXECUTED
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
47282: 23c0 0005 d6f8 movel %d0,5d6f8 <_Per_CPU_Information+0x10>
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
47288: b3f9 0005 d6f4 cmpal 5d6f4 <_Per_CPU_Information+0xc>,%a1
4728e: 6608 bnes 47298 <_Scheduler_priority_Block+0xb4>
_Thread_Dispatch_necessary = true;
47290: 7001 moveq #1,%d0 47292: 13c0 0005 d700 moveb %d0,5d700 <_Per_CPU_Information+0x18>
}
47298: 245f moveal %sp@+,%a2 4729a: 4e5e unlk %fp
...
00047390 <_Scheduler_priority_Free>:
#include <rtems/score/wkspace.h>
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
47390: 4e56 0000 linkw %fp,#0
_Workspace_Free( the_thread->scheduler_info );
47394: 206e 0008 moveal %fp@(8),%a0 47398: 2d68 008a 0008 movel %a0@(138),%fp@(8)
}
4739e: 4e5e unlk %fp
void _Scheduler_priority_Free (
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
473a0: 4ef9 0004 8908 jmp 48908 <_Workspace_Free>
...
00047410 <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
47410: 4e56 0000 linkw %fp,#0
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
47414: 3039 0005 d704 movew 5d704 <_Priority_Major_bit_map>,%d0 4741a: 4840 swap %d0 4741c: 04c0 ff1 %d0
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
4741e: 41f9 0005 d708 lea 5d708 <_Priority_Bit_map>,%a0 47424: 0280 0000 ffff andil #65535,%d0 4742a: 3230 0a00 movew %a0@(00000000,%d0:l:2),%d1 4742e: 4841 swap %d1 47430: 04c1 ff1 %d1
_Scheduler_priority_Schedule_body(); }
47432: 2079 0005 bc20 moveal 5bc20 <_Scheduler>,%a0
return (_Priority_Bits_index( major ) << 4) +
47438: 0281 0000 ffff andil #65535,%d1 4743e: e988 lsll #4,%d0 47440: d081 addl %d1,%d0
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
47442: 2200 movel %d0,%d1 47444: e988 lsll #4,%d0 47446: e589 lsll #2,%d1 47448: 9081 subl %d1,%d0 4744a: d1c0 addal %d0,%a0 4744c: 2018 movel %a0@+,%d0 4744e: b1c0 cmpal %d0,%a0
47450: 6602 bnes 47454 <_Scheduler_priority_Schedule+0x44><== ALWAYS TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
47452: 4280 clrl %d0 <== NOT EXECUTED
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
47454: 23c0 0005 d6f8 movel %d0,5d6f8 <_Per_CPU_Information+0x10> 4745a: 4e5e unlk %fp
...
0004754c <_Scheduler_priority_Yield>:
* ready chain
* select heir
*/
void _Scheduler_priority_Yield(void)
{
4754c: 4e56 fff4 linkw %fp,#-12
Scheduler_priority_Per_thread *sched_info;
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
47550: 2079 0005 d6f4 moveal 5d6f4 <_Per_CPU_Information+0xc>,%a0
* ready chain
* select heir
*/
void _Scheduler_priority_Yield(void)
{
47556: 48d7 0c04 moveml %d2/%a2-%a3,%sp@
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info;
ready = sched_info->ready_chain;
4755a: 2268 008a moveal %a0@(138),%a1
_ISR_Disable( level );
4755e: 243c 0000 0700 movel #1792,%d2 47564: 2002 movel %d2,%d0
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info;
ready = sched_info->ready_chain;
47566: 2251 moveal %a1@,%a1
_ISR_Disable( level );
47568: 40c1 movew %sr,%d1 4756a: 8081 orl %d1,%d0 4756c: 46c0 movew %d0,%sr
if ( !_Chain_Has_only_one_node( ready ) ) {
4756e: 2029 0008 movel %a1@(8),%d0 47572: b091 cmpl %a1@,%d0
47574: 6738 beqs 475ae <_Scheduler_priority_Yield+0x62>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
47576: 2468 0004 moveal %a0@(4),%a2
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
4757a: 2009 movel %a1,%d0 4757c: 5880 addql #4,%d0
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4757e: 2650 moveal %a0@,%a3
previous = the_node->previous; next->previous = previous;
47580: 274a 0004 movel %a2,%a3@(4)
previous->next = next;
47584: 248b movel %a3,%a2@
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
47586: 2469 0008 moveal %a1@(8),%a2
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
4758a: 2080 movel %d0,%a0@
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
4758c: 2348 0008 movel %a0,%a1@(8)
old_last->next = the_node;
47590: 2488 movel %a0,%a2@
the_node->previous = old_last;
47592: 214a 0004 movel %a2,%a0@(4)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
47596: 2002 movel %d2,%d0 47598: 46c1 movew %d1,%sr 4759a: 8081 orl %d1,%d0 4759c: 46c0 movew %d0,%sr
if ( _Thread_Is_heir( executing ) )
4759e: b1f9 0005 d6f8 cmpal 5d6f8 <_Per_CPU_Information+0x10>,%a0
475a4: 6610 bnes 475b6 <_Scheduler_priority_Yield+0x6a> <== NEVER TAKEN
_Thread_Heir = (Thread_Control *) _Chain_First( ready );
475a6: 23d1 0005 d6f8 movel %a1@,5d6f8 <_Per_CPU_Information+0x10> 475ac: 6008 bras 475b6 <_Scheduler_priority_Yield+0x6a>
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
475ae: b1f9 0005 d6f8 cmpal 5d6f8 <_Per_CPU_Information+0x10>,%a0
475b4: 6708 beqs 475be <_Scheduler_priority_Yield+0x72> <== ALWAYS TAKEN
_Thread_Dispatch_necessary = true;
475b6: 7001 moveq #1,%d0 475b8: 13c0 0005 d700 moveb %d0,5d700 <_Per_CPU_Information+0x18>
_ISR_Enable( level );
475be: 46c1 movew %d1,%sr
}
475c0: 4cd7 0c04 moveml %sp@,%d2/%a2-%a3
475c4: 4e5e unlk %fp <== NOT EXECUTED
00046284 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
46284: 4e56 0000 linkw %fp,#0 46288: 206e 0008 moveal %fp@(8),%a0 4628c: 2f03 movel %d3,%sp@-
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
4628e: 2039 0005 dd80 movel 5dd80 <Configuration+0xc>,%d0
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
46294: 2f02 movel %d2,%sp@-
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
46296: 4a88 tstl %a0
46298: 6762 beqs 462fc <_TOD_Validate+0x78> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
4629a: 243c 000f 4240 movel #1000000,%d2 462a0: 4c40 2002 remul %d0,%d2,%d2
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
462a4: b4a8 0018 cmpl %a0@(24),%d2
462a8: 6352 blss 462fc <_TOD_Validate+0x78>
(the_tod->ticks >= ticks_per_second) ||
462aa: 763b moveq #59,%d3 462ac: b6a8 0014 cmpl %a0@(20),%d3
462b0: 654a bcss 462fc <_TOD_Validate+0x78>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
462b2: b6a8 0010 cmpl %a0@(16),%d3
462b6: 6544 bcss 462fc <_TOD_Validate+0x78>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
462b8: 7017 moveq #23,%d0 462ba: b0a8 000c cmpl %a0@(12),%d0
462be: 653c bcss 462fc <_TOD_Validate+0x78>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
462c0: 2028 0004 movel %a0@(4),%d0
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
462c4: 6736 beqs 462fc <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->month == 0) ||
462c6: 720c moveq #12,%d1 462c8: b280 cmpl %d0,%d1
462ca: 6530 bcss 462fc <_TOD_Validate+0x78>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
462cc: 2410 movel %a0@,%d2
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
462ce: 0c82 0000 07c3 cmpil #1987,%d2
462d4: 6326 blss 462fc <_TOD_Validate+0x78>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
462d6: 2228 0008 movel %a0@(8),%d1
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
462da: 6720 beqs 462fc <_TOD_Validate+0x78> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
462dc: 163c 0003 moveb #3,%d3 462e0: 41f9 0005 cf06 lea 5cf06 <_TOD_Days_per_month>,%a0 462e6: c483 andl %d3,%d2
462e8: 6606 bnes 462f0 <_TOD_Validate+0x6c>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
462ea: 2030 0c34 movel %a0@(00000034,%d0:l:4),%d0 462ee: 6004 bras 462f4 <_TOD_Validate+0x70>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
462f0: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
462f4: b081 cmpl %d1,%d0 462f6: 54c0 scc %d0 462f8: 4480 negl %d0 462fa: 6002 bras 462fe <_TOD_Validate+0x7a>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
462fc: 4200 clrb %d0
if ( the_tod->day > days_in_month )
return false;
return true;
}
462fe: 241f movel %sp@+,%d2 46300: 261f movel %sp@+,%d3 46302: 4e5e unlk %fp
...
00047618 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47618: 4e56 fff0 linkw %fp,#-16 4761c: 48d7 041c moveml %d2-%d4/%a2,%sp@ 47620: 246e 0008 moveal %fp@(8),%a2
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
47624: 282a 0010 movel %a2@(16),%d4
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
47628: 242e 000c movel %fp@(12),%d2
/* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread );
4762c: 2f0a movel %a2,%sp@-
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
4762e: 162e 0013 moveb %fp@(19),%d3
/* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread );
47632: 4eb9 0004 81e0 jsr 481e0 <_Thread_Set_transient>
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
47638: 588f addql #4,%sp 4763a: b4aa 0014 cmpl %a2@(20),%d2
4763e: 670c beqs 4764c <_Thread_Change_priority+0x34>
_Thread_Set_priority( the_thread, new_priority );
47640: 2f02 movel %d2,%sp@- 47642: 2f0a movel %a2,%sp@- 47644: 4eb9 0004 8184 jsr 48184 <_Thread_Set_priority> 4764a: 508f addql #8,%sp
_ISR_Disable( level );
4764c: 203c 0000 0700 movel #1792,%d0 47652: 40c2 movew %sr,%d2 47654: 8082 orl %d2,%d0 47656: 46c0 movew %d0,%sr 47658: 7204 moveq #4,%d1
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
4765a: 202a 0010 movel %a2@(16),%d0 4765e: c284 andl %d4,%d1
if ( state != STATES_TRANSIENT ) {
47660: 7804 moveq #4,%d4 47662: b880 cmpl %d0,%d4
47664: 672e beqs 47694 <_Thread_Change_priority+0x7c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
47666: 4a81 tstl %d1
47668: 6608 bnes 47672 <_Thread_Change_priority+0x5a> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
4766a: 72fb moveq #-5,%d1 4766c: c280 andl %d0,%d1 4766e: 2541 0010 movel %d1,%a2@(16)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
47672: 46c2 movew %d2,%sr
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
47674: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
4767a: 676c beqs 476e8 <_Thread_Change_priority+0xd0>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
4767c: 2d4a 000c movel %a2,%fp@(12) 47680: 2d6a 0044 0008 movel %a2@(68),%fp@(8)
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
47686: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 4768c: 4e5e unlk %fp
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
4768e: 4ef9 0004 80e8 jmp 480e8 <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
47694: 4a81 tstl %d1
47696: 661e bnes 476b6 <_Thread_Change_priority+0x9e> <== NEVER TAKEN
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
47698: 42aa 0010 clrl %a2@(16)
if ( prepend_it )
4769c: 4a03 tstb %d3
4769e: 670a beqs 476aa <_Thread_Change_priority+0x92>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
476a0: 2f0a movel %a2,%sp@- 476a2: 2079 0005 bc48 moveal 5bc48 <_Scheduler+0x28>,%a0 476a8: 6008 bras 476b2 <_Thread_Change_priority+0x9a>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
476aa: 2079 0005 bc44 moveal 5bc44 <_Scheduler+0x24>,%a0 476b0: 2f0a movel %a2,%sp@- 476b2: 4e90 jsr %a0@ 476b4: 588f addql #4,%sp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
476b6: 203c 0000 0700 movel #1792,%d0 476bc: 46c2 movew %d2,%sr 476be: 8082 orl %d2,%d0 476c0: 46c0 movew %d0,%sr
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
476c2: 2079 0005 bc28 moveal 5bc28 <_Scheduler+0x8>,%a0 476c8: 4e90 jsr %a0@
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
476ca: 2079 0005 d6f4 moveal 5d6f4 <_Per_CPU_Information+0xc>,%a0
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
476d0: b1f9 0005 d6f8 cmpal 5d6f8 <_Per_CPU_Information+0x10>,%a0
476d6: 670e beqs 476e6 <_Thread_Change_priority+0xce>
476d8: 4a28 0074 tstb %a0@(116)
476dc: 6708 beqs 476e6 <_Thread_Change_priority+0xce>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
476de: 7801 moveq #1,%d4 476e0: 13c4 0005 d700 moveb %d4,5d700 <_Per_CPU_Information+0x18>
_ISR_Enable( level );
476e6: 46c2 movew %d2,%sr
}
476e8: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 476ee: 4e5e unlk %fp
...
000478bc <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
478bc: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
478c0: 486e fffc pea %fp@(-4) 478c4: 2f2e 0008 movel %fp@(8),%sp@- 478c8: 4eb9 0004 7a5c jsr 47a5c <_Thread_Get>
switch ( location ) {
478ce: 508f addql #8,%sp 478d0: 4aae fffc tstl %fp@(-4)
478d4: 661e bnes 478f4 <_Thread_Delay_ended+0x38> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
478d6: 2f3c 1000 0018 movel #268435480,%sp@- 478dc: 2f00 movel %d0,%sp@- 478de: 4eb9 0004 76f4 jsr 476f4 <_Thread_Clear_state> 478e4: 508f addql #8,%sp 478e6: 2039 0005 d558 movel 5d558 <_Thread_Dispatch_disable_level>,%d0 478ec: 5380 subql #1,%d0 478ee: 23c0 0005 d558 movel %d0,5d558 <_Thread_Dispatch_disable_level>
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
478f4: 4e5e unlk %fp <== NOT EXECUTED
000478f8 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
478f8: 4e56 ffc8 linkw %fp,#-56 478fc: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
47900: 283c 0000 0700 movel #1792,%d4 47906: 2204 movel %d4,%d1
{
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
47908: 2479 0005 d6f4 moveal 5d6f4 <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
4790e: 40c0 movew %sr,%d0 47910: 8280 orl %d0,%d1 47912: 46c1 movew %d1,%sr
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47914: 260e movel %fp,%d3
_Timestamp_Subtract(
47916: 240e movel %fp,%d2
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47918: 5183 subql #8,%d3
_Timestamp_Subtract(
4791a: 0682 ffff fff0 addil #-16,%d2
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
47920: 2e3c 0004 8380 movel #295808,%d7
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
47926: 2c3c 0004 8634 movel #296500,%d6
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
4792c: 2a3c 0004 8958 movel #297304,%d5
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
_Context_Restore_fp( &executing->fp_context );
47932: 4bf9 0004 8ac0 lea 48ac0 <_CPU_Context_restore_fp>,%a5
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
47938: 49f9 0004 8a9e lea 48a9e <_CPU_Context_save_fp>,%a4
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
4793e: 6000 00d4 braw 47a14 <_Thread_Dispatch+0x11c>
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
47942: 7201 moveq #1,%d1 47944: 23c1 0005 d558 movel %d1,5d558 <_Thread_Dispatch_disable_level>
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
4794a: 2679 0005 d6f8 moveal 5d6f8 <_Per_CPU_Information+0x10>,%a3
_Thread_Dispatch_disable_level = 1;
_Thread_Dispatch_necessary = false;
47950: 4201 clrb %d1
_Thread_Executing = heir;
47952: 23cb 0005 d6f4 movel %a3,5d6f4 <_Per_CPU_Information+0xc>
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
_Thread_Dispatch_necessary = false;
47958: 13c1 0005 d700 moveb %d1,5d700 <_Per_CPU_Information+0x18>
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
4795e: b5cb cmpal %a3,%a2 47960: 6700 00bc beqw 47a1e <_Thread_Dispatch+0x126>
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
47964: 7201 moveq #1,%d1 47966: b2ab 007a cmpl %a3@(122),%d1
4796a: 660a bnes 47976 <_Thread_Dispatch+0x7e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
4796c: 41f9 0005 d510 lea 5d510 <_Thread_Ticks_per_timeslice>,%a0 47972: 2750 0076 movel %a0@,%a3@(118)
_ISR_Enable( level );
47976: 46c0 movew %d0,%sr
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
47978: 2f03 movel %d3,%sp@- 4797a: 4eb9 0004 a358 jsr 4a358 <_TOD_Get_uptime>
_Timestamp_Subtract(
47980: 2f02 movel %d2,%sp@- 47982: 2f03 movel %d3,%sp@- 47984: 4879 0005 d604 pea 5d604 <_Thread_Time_of_last_context_switch> 4798a: 4eb9 0004 83b8 jsr 483b8 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
47990: 2047 moveal %d7,%a0 47992: 2f02 movel %d2,%sp@- 47994: 486a 0082 pea %a2@(130) 47998: 4e90 jsr %a0@
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
4799a: 2079 0005 d5de moveal 5d5de <_Thread_libc_reent>,%a0 479a0: 4fef 0018 lea %sp@(24),%sp
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
479a4: 202e fff8 movel %fp@(-8),%d0 479a8: 222e fffc movel %fp@(-4),%d1 479ac: 23c0 0005 d604 movel %d0,5d604 <_Thread_Time_of_last_context_switch> 479b2: 23c1 0005 d608 movel %d1,5d608 <_Thread_Time_of_last_context_switch+0x4>
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
479b8: 4a88 tstl %a0
479ba: 6708 beqs 479c4 <_Thread_Dispatch+0xcc> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
479bc: 2550 00f8 movel %a0@,%a2@(248)
*_Thread_libc_reent = heir->libc_reent;
479c0: 20ab 00f8 movel %a3@(248),%a0@
}
_User_extensions_Thread_switch( executing, heir );
479c4: 2f0b movel %a3,%sp@- 479c6: 2046 moveal %d6,%a0 479c8: 2f0a movel %a2,%sp@- 479ca: 4e90 jsr %a0@
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
479cc: 486b 00c0 pea %a3@(192) 479d0: 2045 moveal %d5,%a0 479d2: 486a 00c0 pea %a2@(192) 479d6: 4e90 jsr %a0@
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
479d8: 4fef 0010 lea %sp@(16),%sp 479dc: 4aaa 00f4 tstl %a2@(244)
479e0: 6724 beqs 47a06 <_Thread_Dispatch+0x10e>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
479e2: 2079 0005 d5da moveal 5d5da <_Thread_Allocated_fp>,%a0 479e8: b1ca cmpal %a2,%a0
479ea: 671a beqs 47a06 <_Thread_Dispatch+0x10e>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
479ec: 4a88 tstl %a0
479ee: 6708 beqs 479f8 <_Thread_Dispatch+0x100>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
479f0: 4868 00f4 pea %a0@(244) 479f4: 4e94 jsr %a4@ 479f6: 588f addql #4,%sp
_Context_Restore_fp( &executing->fp_context );
479f8: 486a 00f4 pea %a2@(244) 479fc: 4e95 jsr %a5@
_Thread_Allocated_fp = executing;
479fe: 588f addql #4,%sp 47a00: 23ca 0005 d5da movel %a2,5d5da <_Thread_Allocated_fp>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
47a06: 2479 0005 d6f4 moveal 5d6f4 <_Per_CPU_Information+0xc>,%a2
_ISR_Disable( level );
47a0c: 2204 movel %d4,%d1 47a0e: 40c0 movew %sr,%d0 47a10: 8280 orl %d0,%d1 47a12: 46c1 movew %d1,%sr
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
47a14: 1239 0005 d700 moveb 5d700 <_Per_CPU_Information+0x18>,%d1 47a1a: 6600 ff26 bnew 47942 <_Thread_Dispatch+0x4a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
47a1e: 42b9 0005 d558 clrl 5d558 <_Thread_Dispatch_disable_level>
_ISR_Enable( level );
47a24: 46c0 movew %d0,%sr
_API_extensions_Run_postswitch();
47a26: 4eb9 0004 6088 jsr 46088 <_API_extensions_Run_postswitch>
}
47a2c: 4cee 3cfc ffc8 moveml %fp@(-56),%d2-%d7/%a2-%a5
47a32: 4e5e unlk %fp <== NOT EXECUTED
0004bb20 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4bb20: 4e56 0000 linkw %fp,#0 4bb24: 2f0a movel %a2,%sp@-
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
4bb26: 2479 0005 d6f4 moveal 5d6f4 <_Per_CPU_Information+0xc>,%a2
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4bb2c: 2f02 movel %d2,%sp@-
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
4bb2e: 222a 00a8 movel %a2@(168),%d1
_ISR_Set_level(level);
4bb32: 40c0 movew %sr,%d0 4bb34: e189 lsll #8,%d1 4bb36: 0280 0000 f8ff andil #63743,%d0 4bb3c: 8081 orl %d1,%d0 4bb3e: 46c0 movew %d0,%sr
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
doneConstructors = 1;
4bb40: 7001 moveq #1,%d0
level = executing->Start.isr_level;
_ISR_Set_level(level);
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
4bb42: 1439 0005 cd1c moveb 5cd1c <doneConstructors.3351>,%d2
doneConstructors = 1;
4bb48: 13c0 0005 cd1c moveb %d0,5cd1c <doneConstructors.3351>
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
4bb4e: 4aaa 00f4 tstl %a2@(244)
4bb52: 6720 beqs 4bb74 <_Thread_Handler+0x54>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
4bb54: 2079 0005 d5da moveal 5d5da <_Thread_Allocated_fp>,%a0 4bb5a: b1ca cmpal %a2,%a0
4bb5c: 6716 beqs 4bb74 <_Thread_Handler+0x54>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
4bb5e: 4a88 tstl %a0
4bb60: 670c beqs 4bb6e <_Thread_Handler+0x4e>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
4bb62: 4868 00f4 pea %a0@(244) 4bb66: 4eb9 0004 8a9e jsr 48a9e <_CPU_Context_save_fp> 4bb6c: 588f addql #4,%sp
_Thread_Allocated_fp = executing;
4bb6e: 23ca 0005 d5da movel %a2,5d5da <_Thread_Allocated_fp>
/* * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing );
4bb74: 2f0a movel %a2,%sp@- 4bb76: 4eb9 0004 84b0 jsr 484b0 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
4bb7c: 4eb9 0004 7a36 jsr 47a36 <_Thread_Enable_dispatch>
/*
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (!doneCons) /* && (volatile void *)_init) */ {
4bb82: 588f addql #4,%sp 4bb84: 4a02 tstb %d2
4bb86: 6606 bnes 4bb8e <_Thread_Handler+0x6e>
INIT_NAME ();
4bb88: 4eb9 0005 a074 jsr 5a074 <_init>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
4bb8e: 4aaa 0092 tstl %a2@(146)
4bb92: 6610 bnes 4bba4 <_Thread_Handler+0x84> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
4bb94: 2f2a 009a movel %a2@(154),%sp@- 4bb98: 206a 008e moveal %a2@(142),%a0 4bb9c: 4e90 jsr %a0@
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
4bb9e: 588f addql #4,%sp 4bba0: 2540 0028 movel %d0,%a2@(40)
* was placed in return_argument. This assumed that if it returned
* anything (which is not supporting in all APIs), then it would be
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
4bba4: 2f0a movel %a2,%sp@- 4bba6: 4eb9 0004 84e8 jsr 484e8 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
4bbac: 4878 0005 pea 5 <COMPARE> 4bbb0: 4878 0001 pea 1 <ADD> 4bbb4: 42a7 clrl %sp@- 4bbb6: 4eb9 0004 69b0 jsr 469b0 <_Internal_error_Occurred>
0004893c <_Thread_Restart>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
4893c: 7001 moveq #1,%d0
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
4893e: 4e56 0000 linkw %fp,#0 48942: 2f0a movel %a2,%sp@- 48944: 246e 0008 moveal %fp@(8),%a2 48948: c0aa 0010 andl %a2@(16),%d0
if ( !_States_Is_dormant( the_thread->current_state ) ) {
4894c: 6664 bnes 489b2 <_Thread_Restart+0x76>
_Thread_Set_transient( the_thread );
4894e: 2f0a movel %a2,%sp@- 48950: 4eb9 0004 8a1c jsr 48a1c <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
48956: 2f2e 0010 movel %fp@(16),%sp@- 4895a: 2f2e 000c movel %fp@(12),%sp@- 4895e: 2f0a movel %a2,%sp@- 48960: 4eb9 0004 b214 jsr 4b214 <_Thread_Reset>
_Thread_Load_environment( the_thread );
48966: 2f0a movel %a2,%sp@- 48968: 4eb9 0004 af4c jsr 4af4c <_Thread_Load_environment>
_Thread_Ready( the_thread );
4896e: 2f0a movel %a2,%sp@- 48970: 4eb9 0004 b1e4 jsr 4b1e4 <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
48976: 2f0a movel %a2,%sp@- 48978: 4eb9 0004 8e30 jsr 48e30 <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
4897e: 4fef 001c lea %sp@(28),%sp 48982: b5f9 0005 e21c cmpal 5e21c <_Per_CPU_Information+0xc>,%a2
48988: 662c bnes 489b6 <_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 )
4898a: 4aaa 00f4 tstl %a2@(244)
4898e: 670c beqs 4899c <_Thread_Restart+0x60>
_Context_Restore_fp( &_Thread_Executing->fp_context );
48990: 486a 00f4 pea %a2@(244) 48994: 4eb9 0004 933c jsr 4933c <_CPU_Context_restore_fp> 4899a: 588f addql #4,%sp
#endif
_CPU_Context_Restart_self( &_Thread_Executing->Registers );
4899c: 2079 0005 e21c moveal 5e21c <_Per_CPU_Information+0xc>,%a0 489a2: 41e8 00c0 lea %a0@(192),%a0 489a6: 2f08 movel %a0,%sp@- 489a8: 4eb9 0004 91ea jsr 491ea <_CPU_Context_Restart_self>
489ae: 588f addql #4,%sp <== NOT EXECUTED 489b0: 6004 bras 489b6 <_Thread_Restart+0x7a> <== NOT EXECUTED
_Thread_Restart_self();
return true;
}
return false;
489b2: 4200 clrb %d0 489b4: 6002 bras 489b8 <_Thread_Restart+0x7c>
_User_extensions_Thread_restart( the_thread );
if ( _Thread_Is_executing ( the_thread ) )
_Thread_Restart_self();
return true;
489b6: 7001 moveq #1,%d0
}
return false;
}
489b8: 246e fffc moveal %fp@(-4),%a2
489bc: 4e5e unlk %fp <== NOT EXECUTED
00048268 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
48268: 4e56 0000 linkw %fp,#0 4826c: 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 )
48270: 2279 0005 bd18 moveal 5bd18 <Configuration+0x24>,%a1 48276: 4a89 tstl %a1
48278: 670a beqs 48284 <_Thread_Stack_Free+0x1c>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
4827a: 2d68 00b4 0008 movel %a0@(180),%fp@(8)
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
48280: 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 );
48282: 4ed1 jmp %a1@
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
48284: 2d68 00b4 0008 movel %a0@(180),%fp@(8)
}
4828a: 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 );
4828c: 4ef9 0004 8908 jmp 48908 <_Workspace_Free>
...
000475c8 <_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 ) ) {
475c8: 7202 moveq #2,%d1
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
475ca: 4e56 0000 linkw %fp,#0 475ce: 202e 0010 movel %fp@(16),%d0 475d2: 2f0a movel %a2,%sp@- 475d4: 246e 000c moveal %fp@(12),%a2
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
475d8: 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 ) ) {
475dc: b2aa 0050 cmpl %a2@(80),%d1
475e0: 6618 bnes 475fa <_Thread_blocking_operation_Cancel+0x32>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
475e2: 123c 0003 moveb #3,%d1 475e6: 2541 0050 movel %d1,%a2@(80)
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
475ea: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
475ec: 486a 0048 pea %a2@(72) 475f0: 4eb9 0004 8794 jsr 48794 <_Watchdog_Remove> 475f6: 588f addql #4,%sp 475f8: 6002 bras 475fc <_Thread_blocking_operation_Cancel+0x34>
} else
_ISR_Enable( level );
475fa: 46c0 movew %d0,%sr
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
475fc: 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
}
47600: 246e fffc moveal %fp@(-4),%a2 47604: 203c 1003 fff8 movel #268697592,%d0 4760a: 2d40 000c movel %d0,%fp@(12) 4760e: 4e5e unlk %fp 47610: 4ef9 0004 76f4 jmp 476f4 <_Thread_Clear_state>
...
0004bbbc <_Thread_queue_Extract_fifo>:
Thread_Control *the_thread
)
{
ISR_Level level;
_ISR_Disable( level );
4bbbc: 223c 0000 0700 movel #1792,%d1
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
4bbc2: 4e56 0000 linkw %fp,#0 4bbc6: 2f0a movel %a2,%sp@- 4bbc8: 246e 000c moveal %fp@(12),%a2
ISR_Level level;
_ISR_Disable( level );
4bbcc: 40c0 movew %sr,%d0 4bbce: 8280 orl %d0,%d1 4bbd0: 46c1 movew %d1,%sr 4bbd2: 222a 0010 movel %a2@(16),%d1 4bbd6: 0281 0003 bee0 andil #245472,%d1
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4bbdc: 660a bnes 4bbe8 <_Thread_queue_Extract_fifo+0x2c>
_ISR_Enable( level );
4bbde: 46c0 movew %d0,%sr
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
4bbe0: 246e fffc moveal %fp@(-4),%a2 4bbe4: 4e5e unlk %fp 4bbe6: 4e75 rts
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
4bbe8: 2252 moveal %a2@,%a1
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4bbea: 7202 moveq #2,%d1
previous = the_node->previous;
4bbec: 206a 0004 moveal %a2@(4),%a0
next->previous = previous;
4bbf0: 2348 0004 movel %a0,%a1@(4)
previous->next = next;
4bbf4: 2089 movel %a1,%a0@
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
4bbf6: 42aa 0044 clrl %a2@(68)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4bbfa: b2aa 0050 cmpl %a2@(80),%d1
4bbfe: 6704 beqs 4bc04 <_Thread_queue_Extract_fifo+0x48>
_ISR_Enable( level );
4bc00: 46c0 movew %d0,%sr 4bc02: 6014 bras 4bc18 <_Thread_queue_Extract_fifo+0x5c> 4bc04: 7203 moveq #3,%d1 4bc06: 2541 0050 movel %d1,%a2@(80)
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4bc0a: 46c0 movew %d0,%sr
(void) _Watchdog_Remove( &the_thread->Timer );
4bc0c: 486a 0048 pea %a2@(72) 4bc10: 4eb9 0004 8794 jsr 48794 <_Watchdog_Remove> 4bc16: 588f addql #4,%sp
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4bc18: 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
}
4bc1c: 246e fffc moveal %fp@(-4),%a2 4bc20: 203c 1003 fff8 movel #268697592,%d0 4bc26: 2d40 000c movel %d0,%fp@(12) 4bc2a: 4e5e unlk %fp 4bc2c: 4ef9 0004 76f4 jmp 476f4 <_Thread_Clear_state>
...
0004a924 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
4a924: 4e56 0000 linkw %fp,#0 4a928: 226e 0008 moveal %fp@(8),%a1
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
4a92c: 2069 0044 moveal %a1@(68),%a0
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
4a930: 2028 0030 movel %a0@(48),%d0
4a934: 671c beqs 4a952 <_Thread_queue_Process_timeout+0x2e>
4a936: b3f9 0005 d6f4 cmpal 5d6f4 <_Per_CPU_Information+0xc>,%a1
4a93c: 6614 bnes 4a952 <_Thread_queue_Process_timeout+0x2e><== NEVER TAKEN
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
4a93e: 7203 moveq #3,%d1 4a940: b280 cmpl %d0,%d1
4a942: 6720 beqs 4a964 <_Thread_queue_Process_timeout+0x40>
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
4a944: 7002 moveq #2,%d0
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
4a946: 2368 003c 0034 movel %a0@(60),%a1@(52)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
4a94c: 2140 0030 movel %d0,%a0@(48) 4a950: 6012 bras 4a964 <_Thread_queue_Process_timeout+0x40>
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
4a952: 2368 003c 0034 movel %a0@(60),%a1@(52)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
4a958: 2f09 movel %a1,%sp@- 4a95a: 2f08 movel %a0,%sp@- 4a95c: 4eb9 0004 a820 jsr 4a820 <_Thread_queue_Extract> 4a962: 508f addql #8,%sp
} }
4a964: 4e5e unlk %fp <== NOT EXECUTED
000480e8 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
480e8: 4e56 fff0 linkw %fp,#-16 480ec: 48d7 0c04 moveml %d2/%a2-%a3,%sp@ 480f0: 246e 0008 moveal %fp@(8),%a2 480f4: 266e 000c moveal %fp@(12),%a3
/* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue )
480f8: 4a8a tstl %a2
480fa: 6746 beqs 48142 <_Thread_queue_Requeue+0x5a> <== NEVER TAKEN
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
480fc: 7001 moveq #1,%d0 480fe: b0aa 0034 cmpl %a2@(52),%d0
48102: 663e bnes 48142 <_Thread_queue_Requeue+0x5a> <== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
48104: 303c 0700 movew #1792,%d0 48108: 40c2 movew %sr,%d2 4810a: 8082 orl %d2,%d0 4810c: 46c0 movew %d0,%sr 4810e: 202b 0010 movel %a3@(16),%d0 48112: 0280 0003 bee0 andil #245472,%d0
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
48118: 6726 beqs 48140 <_Thread_queue_Requeue+0x58> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
4811a: 7001 moveq #1,%d0 4811c: 2540 0030 movel %d0,%a2@(48)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
48120: 4878 0001 pea 1 <ADD> 48124: 2f0b movel %a3,%sp@- 48126: 2f0a movel %a2,%sp@- 48128: 4eb9 0004 a858 jsr 4a858 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
4812e: 486e fffc pea %fp@(-4) 48132: 2f0b movel %a3,%sp@- 48134: 2f0a movel %a2,%sp@- 48136: 4eb9 0004 7ed0 jsr 47ed0 <_Thread_queue_Enqueue_priority> 4813c: 4fef 0018 lea %sp@(24),%sp
}
_ISR_Enable( level );
48140: 46c2 movew %d2,%sr
} }
48142: 4cee 0c04 fff0 moveml %fp@(-16),%d2/%a2-%a3
48148: 4e5e unlk %fp <== NOT EXECUTED
0004814c <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
4814c: 4e56 fffc linkw %fp,#-4
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
48150: 486e fffc pea %fp@(-4) 48154: 2f2e 0008 movel %fp@(8),%sp@- 48158: 4eb9 0004 7a5c jsr 47a5c <_Thread_Get>
switch ( location ) {
4815e: 508f addql #8,%sp 48160: 4aae fffc tstl %fp@(-4)
48164: 6618 bnes 4817e <_Thread_queue_Timeout+0x32> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
48166: 2f00 movel %d0,%sp@- 48168: 4eb9 0004 a924 jsr 4a924 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
4816e: 588f addql #4,%sp 48170: 2039 0005 d558 movel 5d558 <_Thread_Dispatch_disable_level>,%d0 48176: 5380 subql #1,%d0 48178: 23c0 0005 d558 movel %d0,5d558 <_Thread_Dispatch_disable_level>
_Thread_Unnest_dispatch();
break;
}
}
4817e: 4e5e unlk %fp
...
00052292 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
52292: 4e56 ffb4 linkw %fp,#-76
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
52296: 41ee ffec lea %fp@(-20),%a0 5229a: 200e movel %fp,%d0 5229c: 220e movel %fp,%d1 5229e: 5181 subql #8,%d1 522a0: 0680 ffff fff4 addil #-12,%d0 522a6: 48d7 3cfc moveml %d2-%d7/%a2-%a5,%sp@ 522aa: 246e 0008 moveal %fp@(8),%a2 522ae: 260e movel %fp,%d3
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
522b0: 2808 movel %a0,%d4
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
522b2: 2c0a movel %a2,%d6
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
522b4: 0683 ffff ffe8 addil #-24,%d3 522ba: 0686 0000 0040 addil #64,%d6
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
522c0: 2a0a movel %a2,%d5
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
522c2: 240a movel %a2,%d2
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
522c4: 0685 0000 0030 addil #48,%d5 522ca: 47f9 0005 5efc lea 55efc <_Watchdog_Adjust_to_chain>,%a3
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
522d0: 0682 0000 0068 addil #104,%d2 522d6: 4bf9 0005 5e7c lea 55e7c <_Watchdog_Adjust>,%a5
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
522dc: 2e01 movel %d1,%d7
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
522de: 2d48 ffe8 movel %a0,%fp@(-24)
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
522e2: 41ea 0008 lea %a2@(8),%a0 522e6: 2d41 fff4 movel %d1,%fp@(-12)
head->previous = NULL;
522ea: 42ae fff8 clrl %fp@(-8)
tail->previous = head;
522ee: 2d40 fffc movel %d0,%fp@(-4)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
522f2: 42ae ffec clrl %fp@(-20)
tail->previous = head;
522f6: 2d43 fff0 movel %d3,%fp@(-16) 522fa: 2d48 ffe4 movel %a0,%fp@(-28)
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
522fe: 2d46 ffe0 movel %d6,%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;
52302: 41ee fff4 lea %fp@(-12),%a0
)
{
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 );
52306: 49f9 0005 5f8c lea 55f8c <_Watchdog_Insert>,%a4
{
/*
* 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;
5230c: 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;
52310: 2039 0007 605c movel 7605c <_Watchdog_Ticks_since_boot>,%d0
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
52316: 222a 003c movel %a2@(60),%d1
watchdogs->last_snapshot = snapshot;
5231a: 2540 003c movel %d0,%a2@(60)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
5231e: 9081 subl %d1,%d0 52320: 2f03 movel %d3,%sp@- 52322: 2f00 movel %d0,%sp@- 52324: 2f05 movel %d5,%sp@- 52326: 4e93 jsr %a3@
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
52328: 2039 0007 5fde movel 75fde <_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 ) {
5232e: 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;
52332: 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 ) {
52336: b280 cmpl %d0,%d1
52338: 6412 bccs 5234c <_Timer_server_Body+0xba>
/*
* 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 );
5233a: 2f03 movel %d3,%sp@- 5233c: 2c00 movel %d0,%d6 5233e: 9c81 subl %d1,%d6 52340: 2f06 movel %d6,%sp@- 52342: 2d40 ffdc movel %d0,%fp@(-36) 52346: 2f02 movel %d2,%sp@- 52348: 4e93 jsr %a3@ 5234a: 6014 bras 52360 <_Timer_server_Body+0xce>
} else if ( snapshot < last_snapshot ) {
5234c: b280 cmpl %d0,%d1
5234e: 6318 blss 52368 <_Timer_server_Body+0xd6>
/*
* 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 );
52350: 9280 subl %d0,%d1 52352: 2f01 movel %d1,%sp@- 52354: 4878 0001 pea 1 <ADD> 52358: 2d40 ffdc movel %d0,%fp@(-36) 5235c: 2f02 movel %d2,%sp@- 5235e: 4e95 jsr %a5@ 52360: 202e ffdc movel %fp@(-36),%d0 52364: 4fef 000c lea %sp@(12),%sp
}
watchdogs->last_snapshot = snapshot;
52368: 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 );
5236c: 202a 0078 movel %a2@(120),%d0 52370: 2f00 movel %d0,%sp@- 52372: 4eb9 0005 2d2c jsr 52d2c <_Chain_Get>
if ( timer == NULL ) {
52378: 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 );
5237a: 2040 moveal %d0,%a0
if ( timer == NULL ) {
5237c: 4a80 tstl %d0
5237e: 6724 beqs 523a4 <_Timer_server_Body+0x112>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
52380: 2028 0038 movel %a0@(56),%d0 52384: 7201 moveq #1,%d1 52386: b280 cmpl %d0,%d1
52388: 6608 bnes 52392 <_Timer_server_Body+0x100>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
5238a: 4868 0010 pea %a0@(16) 5238e: 2f05 movel %d5,%sp@- 52390: 600c bras 5239e <_Timer_server_Body+0x10c>
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
52392: 7c03 moveq #3,%d6 52394: bc80 cmpl %d0,%d6
52396: 66d4 bnes 5236c <_Timer_server_Body+0xda> <== NEVER TAKEN
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
52398: 4868 0010 pea %a0@(16) 5239c: 2f02 movel %d2,%sp@- 5239e: 4e94 jsr %a4@ 523a0: 508f addql #8,%sp 523a2: 60c8 bras 5236c <_Timer_server_Body+0xda>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
523a4: 203c 0000 0700 movel #1792,%d0 523aa: 40c1 movew %sr,%d1 523ac: 8081 orl %d1,%d0 523ae: 46c0 movew %d0,%sr
if ( _Chain_Is_empty( insert_chain ) ) {
523b0: beae fff4 cmpl %fp@(-12),%d7
523b4: 6614 bnes 523ca <_Timer_server_Body+0x138> <== NEVER TAKEN
ts->insert_chain = NULL;
523b6: 42aa 0078 clrl %a2@(120)
_ISR_Enable( level );
523ba: 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 );
523bc: 2c3c 0000 0700 movel #1792,%d6
_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 ) ) {
523c2: b8ae ffe8 cmpl %fp@(-24),%d4
523c6: 6608 bnes 523d0 <_Timer_server_Body+0x13e>
523c8: 6042 bras 5240c <_Timer_server_Body+0x17a>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
523ca: 46c1 movew %d1,%sr <== NOT EXECUTED 523cc: 6000 ff42 braw 52310 <_Timer_server_Body+0x7e> <== 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 );
523d0: 2006 movel %d6,%d0 523d2: 40c1 movew %sr,%d1 523d4: 8081 orl %d1,%d0 523d6: 46c0 movew %d0,%sr
initialized = false;
}
#endif
return status;
}
523d8: 206e ffe8 moveal %fp@(-24),%a0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
523dc: b888 cmpl %a0,%d4
523de: 6726 beqs 52406 <_Timer_server_Body+0x174>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
523e0: 2250 moveal %a0@,%a1
head->next = new_first;
523e2: 2d49 ffe8 movel %a1,%fp@(-24)
new_first->previous = head;
523e6: 2343 0004 movel %d3,%a1@(4)
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
523ea: 4a88 tstl %a0
523ec: 6718 beqs 52406 <_Timer_server_Body+0x174> <== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
523ee: 42a8 0008 clrl %a0@(8)
_ISR_Enable( level );
523f2: 46c1 movew %d1,%sr
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
523f4: 2f28 0024 movel %a0@(36),%sp@- 523f8: 2f28 0020 movel %a0@(32),%sp@- 523fc: 2068 001c moveal %a0@(28),%a0 52400: 4e90 jsr %a0@
}
52402: 508f addql #8,%sp 52404: 60ca bras 523d0 <_Timer_server_Body+0x13e>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
52406: 46c1 movew %d1,%sr 52408: 6000 fef8 braw 52302 <_Timer_server_Body+0x70>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
5240c: 49f9 0005 60b4 lea 560b4 <_Watchdog_Remove>,%a4
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
52412: 4200 clrb %d0 52414: 1540 007c moveb %d0,%a2@(124)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
52418: 4eba fd9e jsr %pc@(521b8 <_Thread_Disable_dispatch>)
_Thread_Set_state( ts->thread, STATES_DELAYING );
5241c: 4878 0008 pea 8 <DIVIDE_BY_ZERO> 52420: 2f12 movel %a2@,%sp@- 52422: 4eb9 0005 590c jsr 5590c <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
52428: 2f0a movel %a2,%sp@- 5242a: 4eba fda2 jsr %pc@(521ce <_Timer_server_Reset_interval_system_watchdog>)
_Timer_server_Reset_tod_system_watchdog( ts );
5242e: 2f0a movel %a2,%sp@- 52430: 4eba fdfc jsr %pc@(5222e <_Timer_server_Reset_tod_system_watchdog>)
_Thread_Enable_dispatch();
52434: 4eb9 0005 5122 jsr 55122 <_Thread_Enable_dispatch>
ts->active = true;
5243a: 7201 moveq #1,%d1 5243c: 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 );
52440: 2f2e ffe4 movel %fp@(-28),%sp@- 52444: 4e94 jsr %a4@
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
52446: 2f2e ffe0 movel %fp@(-32),%sp@- 5244a: 4e94 jsr %a4@ 5244c: 4fef 0018 lea %sp@(24),%sp 52450: 6000 feb0 braw 52302 <_Timer_server_Body+0x70>
00052454 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
52454: 4e56 fff0 linkw %fp,#-16 52458: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 5245c: 246e 0008 moveal %fp@(8),%a2 52460: 266e 000c moveal %fp@(12),%a3
if ( ts->insert_chain == NULL ) {
52464: 202a 0078 movel %a2@(120),%d0 52468: 6600 00ea bnew 52554 <_Timer_server_Schedule_operation_method+0x100>
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
5246c: 4eba fd4a jsr %pc@(521b8 <_Thread_Disable_dispatch>)
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
52470: 202b 0038 movel %a3@(56),%d0 52474: 7201 moveq #1,%d1 52476: b280 cmpl %d0,%d1
52478: 665c bnes 524d6 <_Timer_server_Schedule_operation_method+0x82>
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
5247a: 203c 0000 0700 movel #1792,%d0 52480: 40c2 movew %sr,%d2 52482: 8082 orl %d2,%d0 52484: 46c0 movew %d0,%sr
snapshot = _Watchdog_Ticks_since_boot;
52486: 2039 0007 605c movel 7605c <_Watchdog_Ticks_since_boot>,%d0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
5248c: 43ea 0034 lea %a2@(52),%a1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
52490: 222a 003c movel %a2@(60),%d1
initialized = false;
}
#endif
return status;
}
52494: 206a 0030 moveal %a2@(48),%a0
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
52498: b3c8 cmpal %a0,%a1
5249a: 6716 beqs 524b2 <_Timer_server_Schedule_operation_method+0x5e>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
5249c: 2240 moveal %d0,%a1 5249e: 93c1 subal %d1,%a1
delta_interval = first_watchdog->delta_interval;
524a0: 2228 0010 movel %a0@(16),%d1
if (delta_interval > delta) {
524a4: b3c1 cmpal %d1,%a1
524a6: 6404 bccs 524ac <_Timer_server_Schedule_operation_method+0x58>
delta_interval -= delta;
524a8: 9289 subl %a1,%d1 524aa: 6002 bras 524ae <_Timer_server_Schedule_operation_method+0x5a>
} else {
delta_interval = 0;
524ac: 4281 clrl %d1
}
first_watchdog->delta_interval = delta_interval;
524ae: 2141 0010 movel %d1,%a0@(16)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
524b2: 2540 003c movel %d0,%a2@(60)
_ISR_Enable( level );
524b6: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
524b8: 486b 0010 pea %a3@(16) 524bc: 486a 0030 pea %a2@(48) 524c0: 4eb9 0005 5f8c jsr 55f8c <_Watchdog_Insert>
if ( !ts->active ) {
524c6: 508f addql #8,%sp 524c8: 102a 007c moveb %a2@(124),%d0
524cc: 6678 bnes 52546 <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_interval_system_watchdog( ts );
524ce: 2f0a movel %a2,%sp@- 524d0: 4eba fcfc jsr %pc@(521ce <_Timer_server_Reset_interval_system_watchdog>) 524d4: 606e bras 52544 <_Timer_server_Schedule_operation_method+0xf0>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
524d6: 7203 moveq #3,%d1 524d8: b280 cmpl %d0,%d1
524da: 666a bnes 52546 <_Timer_server_Schedule_operation_method+0xf2>
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
524dc: 203c 0000 0700 movel #1792,%d0 524e2: 40c2 movew %sr,%d2 524e4: 8082 orl %d2,%d0 524e6: 46c0 movew %d0,%sr 524e8: 200a movel %a2,%d0 524ea: 0680 0000 006c addil #108,%d0
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
524f0: 2239 0007 5fde movel 75fde <_TOD_Now>,%d1
last_snapshot = ts->TOD_watchdogs.last_snapshot;
524f6: 226a 0074 moveal %a2@(116),%a1
initialized = false;
}
#endif
return status;
}
524fa: 206a 0068 moveal %a2@(104),%a0
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
524fe: b088 cmpl %a0,%d0
52500: 6720 beqs 52522 <_Timer_server_Schedule_operation_method+0xce>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
52502: 2028 0010 movel %a0@(16),%d0
if ( snapshot > last_snapshot ) {
52506: b3c1 cmpal %d1,%a1
52508: 640c bccs 52516 <_Timer_server_Schedule_operation_method+0xc2>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
5250a: 2841 moveal %d1,%a4 5250c: 99c9 subal %a1,%a4
if (delta_interval > delta) {
5250e: b9c0 cmpal %d0,%a4
52510: 640a bccs 5251c <_Timer_server_Schedule_operation_method+0xc8><== NEVER TAKEN
delta_interval -= delta;
52512: 908c subl %a4,%d0 52514: 6008 bras 5251e <_Timer_server_Schedule_operation_method+0xca>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
52516: d089 addl %a1,%d0
delta_interval += delta;
52518: 9081 subl %d1,%d0 5251a: 6002 bras 5251e <_Timer_server_Schedule_operation_method+0xca>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
5251c: 4280 clrl %d0 <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
5251e: 2140 0010 movel %d0,%a0@(16)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
52522: 2541 0074 movel %d1,%a2@(116)
_ISR_Enable( level );
52526: 46c2 movew %d2,%sr
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
52528: 486b 0010 pea %a3@(16) 5252c: 486a 0068 pea %a2@(104) 52530: 4eb9 0005 5f8c jsr 55f8c <_Watchdog_Insert>
if ( !ts->active ) {
52536: 508f addql #8,%sp 52538: 102a 007c moveb %a2@(124),%d0
5253c: 6608 bnes 52546 <_Timer_server_Schedule_operation_method+0xf2>
_Timer_server_Reset_tod_system_watchdog( ts );
5253e: 2f0a movel %a2,%sp@- 52540: 4eba fcec jsr %pc@(5222e <_Timer_server_Reset_tod_system_watchdog>) 52544: 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 );
}
}
52546: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 5254c: 4e5e unlk %fp
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
5254e: 4ef9 0005 5122 jmp 55122 <_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 );
52554: 202a 0078 movel %a2@(120),%d0 52558: 2d4b 000c movel %a3,%fp@(12)
} }
5255c: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4
* 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 );
52562: 2d40 0008 movel %d0,%fp@(8)
} }
52566: 4e5e unlk %fp
* 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 );
52568: 4ef9 0005 2ccc jmp 52ccc <_Chain_Append>
0005b5f4 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
5b5f4: 4e56 fff4 linkw %fp,#-12 5b5f8: 48d7 040c moveml %d2-%d3/%a2,%sp@ 5b5fc: 246e 0008 moveal %fp@(8),%a2
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
5b600: 2412 movel %a2@,%d2
5b602: 6606 bnes 5b60a <_Timespec_To_ticks+0x16>
5b604: 4aaa 0004 tstl %a2@(4)
5b608: 672c beqs 5b636 <_Timespec_To_ticks+0x42> <== NEVER TAKEN
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
5b60a: 4eb9 0005 b7c0 jsr 5b7c0 <TOD_TICKS_PER_SECOND_method>
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
5b610: 2239 0005 d9e0 movel 5d9e0 <Configuration+0xc>,%d1
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
5b616: 4c02 0800 mulsl %d2,%d0
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
5b61a: 243c 0000 03e8 movel #1000,%d2 5b620: 4c02 1800 mulsl %d2,%d1 5b624: 262a 0004 movel %a2@(4),%d3 5b628: 4c41 3003 remul %d1,%d3,%d3 5b62c: d083 addl %d3,%d0
if (ticks)
5b62e: 6608 bnes 5b638 <_Timespec_To_ticks+0x44>
return ticks;
return 1;
5b630: 103c 0001 moveb #1,%d0 5b634: 6002 bras 5b638 <_Timespec_To_ticks+0x44>
)
{
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
5b636: 4280 clrl %d0
if (ticks)
return ticks;
return 1;
}
5b638: 4cee 040c fff4 moveml %fp@(-12),%d2-%d3/%a2 5b63e: 4e5e unlk %fp
...
00048522 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
48522: 4e56 fff0 linkw %fp,#-16 48526: 48d7 041c moveml %d2-%d4/%a2,%sp@
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
4852a: 4282 clrl %d2 4852c: 142e 000f moveb %fp@(15),%d2
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
48530: 282e 0008 movel %fp@(8),%d4 48534: 262e 0010 movel %fp@(16),%d3
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
48538: 2479 0005 d6ac moveal 5d6ac <_User_extensions_List+0x8>,%a2
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
4853e: 6018 bras 48558 <_User_extensions_Fatal+0x36>
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
48540: 206a 0030 moveal %a2@(48),%a0 48544: 4a88 tstl %a0
48546: 670c beqs 48554 <_User_extensions_Fatal+0x32>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
48548: 2f03 movel %d3,%sp@- 4854a: 2f02 movel %d2,%sp@- 4854c: 2f04 movel %d4,%sp@- 4854e: 4e90 jsr %a0@
48550: 4fef 000c lea %sp@(12),%sp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
48554: 246a 0004 moveal %a2@(4),%a2
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
48558: b5fc 0005 d6a4 cmpal #382628,%a2
4855e: 66e0 bnes 48540 <_User_extensions_Fatal+0x1e> <== ALWAYS TAKEN
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
48560: 4cee 041c fff0 moveml %fp@(-16),%d2-%d4/%a2 <== NOT EXECUTED 48566: 4e5e unlk %fp <== NOT EXECUTED
...
000483fc <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
483fc: 4e56 ffe8 linkw %fp,#-24
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
48400: 203c 0005 d6a8 movel #382632,%d0 48406: 23c0 0005 d6a4 movel %d0,5d6a4 <_User_extensions_List>
head->previous = NULL; tail->previous = head;
4840c: 203c 0005 d6a4 movel #382628,%d0 48412: 23c0 0005 d6ac movel %d0,5d6ac <_User_extensions_List+0x8>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
48418: 203c 0005 d560 movel #382304,%d0 4841e: 23c0 0005 d55c movel %d0,5d55c <_User_extensions_Switches_list>
head->previous = NULL; tail->previous = head;
48424: 203c 0005 d55c movel #382300,%d0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
4842a: 42b9 0005 d6a8 clrl 5d6a8 <_User_extensions_List+0x4> 48430: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@
User_extensions_Control *extension;
uint32_t i;
uint32_t number_of_extensions;
User_extensions_Table *initial_extensions;
number_of_extensions = Configuration.number_of_initial_extensions;
48434: 2839 0005 bd2a movel 5bd2a <Configuration+0x36>,%d4
initial_extensions = Configuration.User_extension_table;
4843a: 2639 0005 bd2e movel 5bd2e <Configuration+0x3a>,%d3 48440: 42b9 0005 d560 clrl 5d560 <_User_extensions_Switches_list+0x4>
tail->previous = head;
48446: 23c0 0005 d564 movel %d0,5d564 <_User_extensions_Switches_list+0x8>
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
4844c: 4a83 tstl %d3
4844e: 6754 beqs 484a4 <_User_extensions_Handler_initialization+0xa8><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
48450: 7434 moveq #52,%d2 48452: 4c04 2800 mulsl %d4,%d2
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
48456: 49f9 0004 c54c lea 4c54c <memcpy>,%a4
_User_extensions_Add_set( extension );
4845c: 47f9 0004 a998 lea 4a998 <_User_extensions_Add_set>,%a3 48462: 2f02 movel %d2,%sp@- 48464: 4eb9 0004 8922 jsr 48922 <_Workspace_Allocate_or_fatal_error> 4846a: 2440 moveal %d0,%a2
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
4846c: 2f02 movel %d2,%sp@-
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
4846e: 4282 clrl %d2
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
48470: 42a7 clrl %sp@- 48472: 2f00 movel %d0,%sp@- 48474: 4eb9 0004 c5bc jsr 4c5bc <memset>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
4847a: 4fef 0010 lea %sp@(16),%sp 4847e: 6020 bras 484a0 <_User_extensions_Handler_initialization+0xa4>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
48480: 4878 0020 pea 20 <OPER2+0xc> 48484: 5282 addql #1,%d2 48486: 2f03 movel %d3,%sp@- 48488: 486a 0014 pea %a2@(20) 4848c: 0683 0000 0020 addil #32,%d3 48492: 4e94 jsr %a4@
_User_extensions_Add_set( extension );
48494: 2f0a movel %a2,%sp@-
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
48496: 45ea 0034 lea %a2@(52),%a2 4849a: 4e93 jsr %a3@
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
4849c: 4fef 0010 lea %sp@(16),%sp 484a0: b882 cmpl %d2,%d4
484a2: 62dc bhis 48480 <_User_extensions_Handler_initialization+0x84>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
484a4: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4 484aa: 4e5e unlk %fp
...
00049b3c <_Watchdog_Adjust>:
Watchdog_Interval units
)
{
ISR_Level level;
_ISR_Disable( level );
49b3c: 327c 0700 moveaw #1792,%a1 49b40: 2209 movel %a1,%d1
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
49b42: 4e56 ffe8 linkw %fp,#-24 49b46: 48d7 1c1c moveml %d2-%d4/%a2-%a4,%sp@ 49b4a: 266e 0008 moveal %fp@(8),%a3 49b4e: 262e 000c movel %fp@(12),%d3 49b52: 242e 0010 movel %fp@(16),%d2
ISR_Level level;
_ISR_Disable( level );
49b56: 40c0 movew %sr,%d0 49b58: 8280 orl %d0,%d1 49b5a: 46c1 movew %d1,%sr
}
}
_ISR_Enable( level );
}
49b5c: 244b moveal %a3,%a2 49b5e: 205a moveal %a2@+,%a0
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
49b60: b5c8 cmpal %a0,%a2
49b62: 674c beqs 49bb0 <_Watchdog_Adjust+0x74>
switch ( direction ) {
49b64: 4a83 tstl %d3
49b66: 673c beqs 49ba4 <_Watchdog_Adjust+0x68>
49b68: 7201 moveq #1,%d1 49b6a: b283 cmpl %d3,%d1
49b6c: 6642 bnes 49bb0 <_Watchdog_Adjust+0x74> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
49b6e: d5a8 0010 addl %d2,%a0@(16)
break;
49b72: 603c bras 49bb0 <_Watchdog_Adjust+0x74>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
49b74: 2053 moveal %a3@,%a0
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
49b76: 2628 0010 movel %a0@(16),%d3 49b7a: b682 cmpl %d2,%d3
49b7c: 6308 blss 49b86 <_Watchdog_Adjust+0x4a>
_Watchdog_First( header )->delta_interval -= units;
49b7e: 9682 subl %d2,%d3 49b80: 2143 0010 movel %d3,%a0@(16)
break;
49b84: 602a bras 49bb0 <_Watchdog_Adjust+0x74>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
49b86: 7201 moveq #1,%d1 49b88: 2141 0010 movel %d1,%a0@(16)
_ISR_Enable( level );
49b8c: 46c0 movew %d0,%sr
_Watchdog_Tickle( header );
49b8e: 2f0b movel %a3,%sp@- 49b90: 4e94 jsr %a4@
_ISR_Disable( level );
49b92: 2204 movel %d4,%d1 49b94: 40c0 movew %sr,%d0 49b96: 8280 orl %d0,%d1 49b98: 46c1 movew %d1,%sr
if ( _Chain_Is_empty( header ) )
49b9a: 588f addql #4,%sp 49b9c: b5d3 cmpal %a3@,%a2
49b9e: 6710 beqs 49bb0 <_Watchdog_Adjust+0x74>
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
49ba0: 9483 subl %d3,%d2 49ba2: 6008 bras 49bac <_Watchdog_Adjust+0x70>
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
_Watchdog_Tickle( header );
49ba4: 49f9 0004 9d60 lea 49d60 <_Watchdog_Tickle>,%a4
_ISR_Disable( level );
49baa: 2809 movel %a1,%d4
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
49bac: 4a82 tstl %d2
49bae: 66c4 bnes 49b74 <_Watchdog_Adjust+0x38> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
49bb0: 46c0 movew %d0,%sr
}
49bb2: 4cee 1c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a4
49bb8: 4e5e unlk %fp <== NOT EXECUTED
00048794 <_Watchdog_Remove>:
{
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
48794: 203c 0000 0700 movel #1792,%d0
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
4879a: 4e56 0000 linkw %fp,#0 4879e: 206e 0008 moveal %fp@(8),%a0 487a2: 2f0a movel %a2,%sp@- 487a4: 2f02 movel %d2,%sp@-
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
487a6: 40c1 movew %sr,%d1 487a8: 8081 orl %d1,%d0 487aa: 46c0 movew %d0,%sr
previous_state = the_watchdog->state;
487ac: 2028 0008 movel %a0@(8),%d0
switch ( previous_state ) {
487b0: 7401 moveq #1,%d2 487b2: b480 cmpl %d0,%d2
487b4: 670c beqs 487c2 <_Watchdog_Remove+0x2e> 487b6: 6242 bhis 487fa <_Watchdog_Remove+0x66>
487b8: 143c 0003 moveb #3,%d2 487bc: b480 cmpl %d0,%d2
487be: 653a bcss 487fa <_Watchdog_Remove+0x66> <== NEVER TAKEN
487c0: 6006 bras 487c8 <_Watchdog_Remove+0x34>
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
487c2: 42a8 0008 clrl %a0@(8)
break;
487c6: 6032 bras 487fa <_Watchdog_Remove+0x66>
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
487c8: 2250 moveal %a0@,%a1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
487ca: 42a8 0008 clrl %a0@(8)
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
487ce: 4a91 tstl %a1@
487d0: 6708 beqs 487da <_Watchdog_Remove+0x46>
next_watchdog->delta_interval += the_watchdog->delta_interval;
487d2: 2428 0010 movel %a0@(16),%d2 487d6: d5a9 0010 addl %d2,%a1@(16)
if ( _Watchdog_Sync_count )
487da: 2479 0005 d65c moveal 5d65c <_Watchdog_Sync_count>,%a2 487e0: 4a8a tstl %a2
487e2: 670c beqs 487f0 <_Watchdog_Remove+0x5c>
_Watchdog_Sync_level = _ISR_Nest_level;
487e4: 45f9 0005 d6f0 lea 5d6f0 <_Per_CPU_Information+0x8>,%a2 487ea: 23d2 0005 d5fc movel %a2@,5d5fc <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
487f0: 2468 0004 moveal %a0@(4),%a2
next->previous = previous;
487f4: 234a 0004 movel %a2,%a1@(4)
previous->next = next;
487f8: 2489 movel %a1,%a2@
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
487fa: 2279 0005 d660 moveal 5d660 <_Watchdog_Ticks_since_boot>,%a1 48800: 2149 0018 movel %a1,%a0@(24)
_ISR_Enable( level );
48804: 46c1 movew %d1,%sr
return( previous_state ); }
48806: 241f movel %sp@+,%d2 48808: 245f moveal %sp@+,%a2 4880a: 4e5e unlk %fp
...
00049744 <_Watchdog_Report_chain>:
)
{
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
49744: 203c 0000 0700 movel #1792,%d0
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
4974a: 4e56 ffec linkw %fp,#-20 4974e: 48d7 1c0c moveml %d2-%d3/%a2-%a4,%sp@ 49752: 242e 0008 movel %fp@(8),%d2 49756: 266e 000c moveal %fp@(12),%a3
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
4975a: 40c3 movew %sr,%d3 4975c: 8083 orl %d3,%d0 4975e: 46c0 movew %d0,%sr
printk( "Watchdog Chain: %s %p\n", name, header );
49760: 2f0b movel %a3,%sp@- 49762: 49f9 0004 404c lea 4404c <printk>,%a4 49768: 2f02 movel %d2,%sp@- 4976a: 4879 0005 caf6 pea 5caf6 <_Status_Object_name_errors_to_status+0x14> 49770: 4e94 jsr %a4@
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
49772: 245b moveal %a3@+,%a2
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
49774: 4fef 000c lea %sp@(12),%sp 49778: b7ca cmpal %a2,%a3
4977a: 6726 beqs 497a2 <_Watchdog_Report_chain+0x5e>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
4977c: 49f9 0004 97b8 lea 497b8 <_Watchdog_Report>,%a4 49782: 2f0a movel %a2,%sp@- 49784: 42a7 clrl %sp@- 49786: 4e94 jsr %a4@
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
49788: 2452 moveal %a2@,%a2
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
4978a: 508f addql #8,%sp 4978c: b7ca cmpal %a2,%a3
4978e: 66f2 bnes 49782 <_Watchdog_Report_chain+0x3e> <== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
49790: 2f02 movel %d2,%sp@- 49792: 4879 0005 cb0d pea 5cb0d <_Status_Object_name_errors_to_status+0x2b> 49798: 4eb9 0004 404c jsr 4404c <printk> 4979e: 508f addql #8,%sp 497a0: 600a bras 497ac <_Watchdog_Report_chain+0x68>
} else {
printk( "Chain is empty\n" );
497a2: 4879 0005 cb1c pea 5cb1c <_Status_Object_name_errors_to_status+0x3a> 497a8: 4e94 jsr %a4@ 497aa: 588f addql #4,%sp
}
_ISR_Enable( level );
497ac: 46c3 movew %d3,%sr
}
497ae: 4cee 1c0c ffec moveml %fp@(-20),%d2-%d3/%a2-%a4
497b4: 4e5e unlk %fp <== NOT EXECUTED
00048810 <_Watchdog_Tickle>:
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
48810: 203c 0000 0700 movel #1792,%d0
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
48816: 4e56 ffe8 linkw %fp,#-24 4881a: 48d7 3c0c moveml %d2-%d3/%a2-%a5,%sp@ 4881e: 286e 0008 moveal %fp@(8),%a4
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
48822: 40c2 movew %sr,%d2 48824: 8082 orl %d2,%d0 48826: 46c0 movew %d0,%sr
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
48828: 264c moveal %a4,%a3 4882a: 245b moveal %a3@+,%a2
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
4882c: b7ca cmpal %a2,%a3
4882e: 674c beqs 4887c <_Watchdog_Tickle+0x6c>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
48830: 202a 0010 movel %a2@(16),%d0
48834: 6708 beqs 4883e <_Watchdog_Tickle+0x2e>
the_watchdog->delta_interval--;
48836: 5380 subql #1,%d0 48838: 2540 0010 movel %d0,%a2@(16)
if ( the_watchdog->delta_interval != 0 )
4883c: 663e bnes 4887c <_Watchdog_Tickle+0x6c>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
4883e: 4bf9 0004 8794 lea 48794 <_Watchdog_Remove>,%a5
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
48844: 263c 0000 0700 movel #1792,%d3
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
4884a: 2f0a movel %a2,%sp@- 4884c: 4e95 jsr %a5@
_ISR_Enable( level );
4884e: 46c2 movew %d2,%sr
switch( watchdog_state ) {
48850: 7202 moveq #2,%d1 48852: 588f addql #4,%sp 48854: b280 cmpl %d0,%d1
48856: 6610 bnes 48868 <_Watchdog_Tickle+0x58> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
48858: 2f2a 0024 movel %a2@(36),%sp@- 4885c: 2f2a 0020 movel %a2@(32),%sp@- 48860: 206a 001c moveal %a2@(28),%a0 48864: 4e90 jsr %a0@
the_watchdog->id,
the_watchdog->user_data
);
break;
48866: 508f addql #8,%sp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
48868: 2003 movel %d3,%d0 4886a: 40c2 movew %sr,%d2 4886c: 8082 orl %d2,%d0 4886e: 46c0 movew %d0,%sr
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
48870: 2454 moveal %a4@,%a2
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
48872: b7ca cmpal %a2,%a3
48874: 6706 beqs 4887c <_Watchdog_Tickle+0x6c>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
48876: 4aaa 0010 tstl %a2@(16)
4887a: 67ce beqs 4884a <_Watchdog_Tickle+0x3a>
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
4887c: 46c2 movew %d2,%sr
}
4887e: 4cee 3c0c ffe8 moveml %fp@(-24),%d2-%d3/%a2-%a5
48884: 4e5e unlk %fp <== NOT EXECUTED
0004c43c <rtems_barrier_delete>:
*/
rtems_status_code rtems_barrier_delete(
rtems_id id
)
{
4c43c: 4e56 fffc linkw %fp,#-4 4c440: 2f0a movel %a2,%sp@-
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
4c442: 486e fffc pea %fp@(-4) 4c446: 2f2e 0008 movel %fp@(8),%sp@- 4c44a: 4879 0005 f9ec pea 5f9ec <_Barrier_Information> 4c450: 4eb9 0004 8aa4 jsr 48aa4 <_Objects_Get>
Barrier_Control *the_barrier;
Objects_Locations location;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
4c456: 4fef 000c lea %sp@(12),%sp 4c45a: 2440 moveal %d0,%a2 4c45c: 4aae fffc tstl %fp@(-4)
4c460: 663a bnes 4c49c <rtems_barrier_delete+0x60> <== NEVER TAKEN
case OBJECTS_LOCAL:
_CORE_barrier_Flush(
4c462: 4878 0002 pea 2 <DOUBLE_FLOAT> 4c466: 42a7 clrl %sp@- 4c468: 486a 0014 pea %a2@(20) 4c46c: 4eb9 0004 9be8 jsr 49be8 <_Thread_queue_Flush>
&the_barrier->Barrier,
NULL,
CORE_BARRIER_WAS_DELETED
);
_Objects_Close( &_Barrier_Information, &the_barrier->Object );
4c472: 2f0a movel %a2,%sp@- 4c474: 4879 0005 f9ec pea 5f9ec <_Barrier_Information> 4c47a: 4eb9 0004 86cc jsr 486cc <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Barrier_Free (
Barrier_Control *the_barrier
)
{
_Objects_Free( &_Barrier_Information, &the_barrier->Object );
4c480: 2f0a movel %a2,%sp@- 4c482: 4879 0005 f9ec pea 5f9ec <_Barrier_Information> 4c488: 4eb9 0004 8940 jsr 48940 <_Objects_Free>
_Barrier_Free( the_barrier );
_Thread_Enable_dispatch();
4c48e: 4eb9 0004 95d6 jsr 495d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4c494: 4fef 001c lea %sp@(28),%sp 4c498: 4280 clrl %d0 4c49a: 6002 bras 4c49e <rtems_barrier_delete+0x62>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4c49c: 7004 moveq #4,%d0
}
4c49e: 246e fff8 moveal %fp@(-8),%a2 4c4a2: 4e5e unlk %fp
...
000464a4 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
464a4: 4e56 ffe0 linkw %fp,#-32 464a8: 48d7 0c7c moveml %d2-%d6/%a2-%a3,%sp@
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
464ac: 260e movel %fp,%d3
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
464ae: 47f9 0004 6a28 lea 46a28 <_Chain_Get>,%a3 464b4: 5983 subql #4,%d3 464b6: 45f9 0004 5930 lea 45930 <rtems_event_receive>,%a2
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
464bc: 2c2e 0008 movel %fp@(8),%d6 464c0: 2a2e 000c movel %fp@(12),%d5 464c4: 282e 0010 movel %fp@(16),%d4 464c8: 6012 bras 464dc <rtems_chain_get_with_wait+0x38>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
464ca: 2f03 movel %d3,%sp@- 464cc: 2f04 movel %d4,%sp@- 464ce: 42a7 clrl %sp@- 464d0: 2f05 movel %d5,%sp@- 464d2: 4e92 jsr %a2@
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
464d4: 4fef 0010 lea %sp@(16),%sp 464d8: 4a80 tstl %d0
464da: 660c bnes 464e8 <rtems_chain_get_with_wait+0x44> <== ALWAYS TAKEN
464dc: 2f06 movel %d6,%sp@- 464de: 4e93 jsr %a3@
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
464e0: 588f addql #4,%sp 464e2: 2400 movel %d0,%d2
464e4: 67e4 beqs 464ca <rtems_chain_get_with_wait+0x26>
464e6: 4280 clrl %d0
timeout,
&out
);
}
*node_ptr = node;
464e8: 206e 0014 moveal %fp@(20),%a0 464ec: 2082 movel %d2,%a0@
return sc;
}
464ee: 4cee 0c7c ffe0 moveml %fp@(-32),%d2-%d6/%a2-%a3
464f4: 4e5e unlk %fp <== NOT EXECUTED
0004f3b8 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
4f3b8: 4e56 fff8 linkw %fp,#-8 4f3bc: 2f0a movel %a2,%sp@- 4f3be: 246e 0008 moveal %fp@(8),%a2 4f3c2: 2f02 movel %d2,%sp@-
if ( !time )
4f3c4: 4a8a tstl %a2
4f3c6: 673c beqs 4f404 <rtems_clock_get_tod_timeval+0x4c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
4f3c8: 4a39 0007 5f64 tstb 75f64 <_TOD_Is_set>
4f3ce: 6738 beqs 4f408 <rtems_clock_get_tod_timeval+0x50><== NEVER TAKEN
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
4f3d0: 203c 0000 0700 movel #1792,%d0 4f3d6: 40c2 movew %sr,%d2 4f3d8: 8082 orl %d2,%d0 4f3da: 46c0 movew %d0,%sr
_TOD_Get( &now );
4f3dc: 486e fff8 pea %fp@(-8) 4f3e0: 4eb9 0005 3444 jsr 53444 <_TOD_Get>
_ISR_Enable(level);
4f3e6: 46c2 movew %d2,%sr
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
4f3e8: 243c 0000 03e8 movel #1000,%d2
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
4f3ee: 588f addql #4,%sp
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
4f3f0: 202e fffc movel %fp@(-4),%d0
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
4f3f4: 4c42 0800 remsl %d2,%d0,%d0
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
4f3f8: 24ae fff8 movel %fp@(-8),%a2@
time->tv_usec = useconds;
4f3fc: 2540 0004 movel %d0,%a2@(4) 4f400: 4280 clrl %d0 4f402: 6006 bras 4f40a <rtems_clock_get_tod_timeval+0x52>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
4f404: 7009 moveq #9,%d0 4f406: 6002 bras 4f40a <rtems_clock_get_tod_timeval+0x52>
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
4f408: 700b moveq #11,%d0
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
4f40a: 242e fff0 movel %fp@(-16),%d2 4f40e: 246e fff4 moveal %fp@(-12),%a2 4f412: 4e5e unlk %fp
...
00045e7a <rtems_initialize_start_multitasking>:
45e7a: 7002 moveq #2,%d0
}
void rtems_initialize_start_multitasking(void)
{
45e7c: 4e56 0000 linkw %fp,#0
****** APPLICATION RUNS HERE ****** ****** RETURNS WHEN SYSTEM IS SHUT DOWN ****** ******************************************************************* ******************************************************************* *******************************************************************/ }
45e80: 4e5e unlk %fp 45e82: 23c0 0005 d6a0 movel %d0,5d6a0 <_System_state_Current>
void rtems_initialize_start_multitasking(void)
{
_System_state_Set( SYSTEM_STATE_BEGIN_MULTITASKING );
_Thread_Start_multitasking();
45e88: 4ef9 0004 8294 jmp 48294 <_Thread_Start_multitasking>
...
00047d70 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
47d70: 4e56 fff0 linkw %fp,#-16 47d74: 48d7 1c04 moveml %d2/%a2-%a4,%sp@ 47d78: 286e 0008 moveal %fp@(8),%a4
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
47d7c: 4a8c tstl %a4
47d7e: 673c beqs 47dbc <rtems_iterate_over_all_threads+0x4c><== NEVER TAKEN
47d80: 45f9 0005 f988 lea 5f988 <_Objects_Information_table+0x4>,%a2
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
47d86: 205a moveal %a2@+,%a0 47d88: 4a88 tstl %a0
47d8a: 6728 beqs 47db4 <rtems_iterate_over_all_threads+0x44>
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
47d8c: 2668 0004 moveal %a0@(4),%a3
if ( !information )
47d90: 4a8b tstl %a3
47d92: 6720 beqs 47db4 <rtems_iterate_over_all_threads+0x44>
47d94: 7401 moveq #1,%d2 47d96: 6012 bras 47daa <rtems_iterate_over_all_threads+0x3a>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
47d98: 206b 0018 moveal %a3@(24),%a0 47d9c: 2030 2c00 movel %a0@(00000000,%d2:l:4),%d0
if ( !the_thread )
47da0: 6706 beqs 47da8 <rtems_iterate_over_all_threads+0x38><== NEVER TAKEN
continue;
(*routine)(the_thread);
47da2: 2f00 movel %d0,%sp@- 47da4: 4e94 jsr %a4@ 47da6: 588f addql #4,%sp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
47da8: 5282 addql #1,%d2 47daa: 4280 clrl %d0 47dac: 302b 000e movew %a3@(14),%d0 47db0: b082 cmpl %d2,%d0
47db2: 64e4 bccs 47d98 <rtems_iterate_over_all_threads+0x28>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
47db4: b5fc 0005 f994 cmpal #391572,%a2
47dba: 66ca bnes 47d86 <rtems_iterate_over_all_threads+0x16>
(*routine)(the_thread);
}
}
}
47dbc: 4cee 1c04 fff0 moveml %fp@(-16),%d2/%a2-%a4 47dc2: 4e5e unlk %fp
...
0004642c <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
4642c: 4e56 fffc linkw %fp,#-4 46430: 2f0a movel %a2,%sp@- 46432: 246e 000c moveal %fp@(12),%a2
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
46436: 4a8a tstl %a2
46438: 6720 beqs 4645a <rtems_object_get_classic_name+0x2e><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
4643a: 486e fffc pea %fp@(-4) 4643e: 2f2e 0008 movel %fp@(8),%sp@- 46442: 4eb9 0004 7dec jsr 47dec <_Objects_Id_to_name>
*name = name_u.name_u32;
46448: 24ae fffc movel %fp@(-4),%a2@
return _Status_Object_name_errors_to_status[ status ];
4644c: 41f9 0005 c45e lea 5c45e <_Status_Object_name_errors_to_status>,%a0 46452: 508f addql #8,%sp 46454: 2030 0c00 movel %a0@(00000000,%d0:l:4),%d0 46458: 6002 bras 4645c <rtems_object_get_classic_name+0x30>
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
return RTEMS_INVALID_ADDRESS;
4645a: 7009 moveq #9,%d0
status = _Objects_Id_to_name( id, &name_u );
*name = name_u.name_u32;
return _Status_Object_name_errors_to_status[ status ];
}
4645c: 246e fff8 moveal %fp@(-8),%a2
46460: 4e5e unlk %fp <== NOT EXECUTED
00050188 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
50188: 4e56 fffc linkw %fp,#-4 5018c: 2f0a movel %a2,%sp@- 5018e: 2f02 movel %d2,%sp@-
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
50190: 486e fffc pea %fp@(-4) 50194: 2f2e 0008 movel %fp@(8),%sp@- 50198: 4879 0007 5df4 pea 75df4 <_Partition_Information> 5019e: 242e 000c movel %fp@(12),%d2 501a2: 4eb9 0005 45ac jsr 545ac <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
501a8: 4fef 000c lea %sp@(12),%sp 501ac: 2440 moveal %d0,%a2 501ae: 4aae fffc tstl %fp@(-4)
501b2: 663e bnes 501f2 <rtems_partition_return_buffer+0x6a>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
501b4: 202a 0010 movel %a2@(16),%d0
ending = _Addresses_Add_offset( starting, the_partition->length );
501b8: 222a 0014 movel %a2@(20),%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
501bc: b082 cmpl %d2,%d0
501be: 6240 bhis 50200 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
501c0: d280 addl %d0,%d1
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
501c2: b282 cmpl %d2,%d1
501c4: 653a bcss 50200 <rtems_partition_return_buffer+0x78><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
501c6: 2202 movel %d2,%d1 501c8: 9280 subl %d0,%d1 501ca: 2001 movel %d1,%d0
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
501cc: 4c6a 0001 0018 remul %a2@(24),%d1,%d0
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
501d2: 4a81 tstl %d1
501d4: 662a bnes 50200 <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 );
501d6: 2f02 movel %d2,%sp@- 501d8: 486a 0024 pea %a2@(36) 501dc: 4eb9 0005 2ccc jsr 52ccc <_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;
501e2: 53aa 0020 subql #1,%a2@(32)
_Thread_Enable_dispatch();
501e6: 4eb9 0005 5122 jsr 55122 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
501ec: 508f addql #8,%sp 501ee: 4280 clrl %d0 501f0: 6002 bras 501f4 <rtems_partition_return_buffer+0x6c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
501f2: 7004 moveq #4,%d0
}
501f4: 242e fff4 movel %fp@(-12),%d2 501f8: 246e fff8 moveal %fp@(-8),%a2 501fc: 4e5e unlk %fp 501fe: 4e75 rts
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
50200: 4eb9 0005 5122 jsr 55122 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
50206: 7009 moveq #9,%d0 50208: 60ea bras 501f4 <rtems_partition_return_buffer+0x6c>
...
0004f7ac <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
rtems_id id,
void *internal,
void **external
)
{
4f7ac: 4e56 fffc linkw %fp,#-4 4f7b0: 2f0a movel %a2,%sp@- 4f7b2: 246e 0010 moveal %fp@(16),%a2 4f7b6: 2f02 movel %d2,%sp@- 4f7b8: 242e 000c movel %fp@(12),%d2
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
4f7bc: 4a8a tstl %a2
4f7be: 6740 beqs 4f800 <rtems_port_internal_to_external+0x54><== NEVER TAKEN
4f7c0: 486e fffc pea %fp@(-4) 4f7c4: 2f2e 0008 movel %fp@(8),%sp@- 4f7c8: 4879 0007 5dbc pea 75dbc <_Dual_ported_memory_Information> 4f7ce: 4eb9 0005 45ac jsr 545ac <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
4f7d4: 4fef 000c lea %sp@(12),%sp 4f7d8: 2040 moveal %d0,%a0 4f7da: 4aae fffc tstl %fp@(-4)
4f7de: 6624 bnes 4f804 <rtems_port_internal_to_external+0x58><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
4f7e0: 2002 movel %d2,%d0 4f7e2: 90a8 0010 subl %a0@(16),%d0
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
4f7e6: b0a8 0018 cmpl %a0@(24),%d0
4f7ea: 6304 blss 4f7f0 <rtems_port_internal_to_external+0x44>
*external = internal;
4f7ec: 2482 movel %d2,%a2@ 4f7ee: 6006 bras 4f7f6 <rtems_port_internal_to_external+0x4a>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
4f7f0: d0a8 0014 addl %a0@(20),%d0 4f7f4: 2480 movel %d0,%a2@
else
*external = _Addresses_Add_offset( the_port->external_base,
ending );
_Thread_Enable_dispatch();
4f7f6: 4eb9 0005 5122 jsr 55122 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4f7fc: 4280 clrl %d0 4f7fe: 6006 bras 4f806 <rtems_port_internal_to_external+0x5a>
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
return RTEMS_INVALID_ADDRESS;
4f800: 7009 moveq #9,%d0 4f802: 6002 bras 4f806 <rtems_port_internal_to_external+0x5a>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4f804: 7004 moveq #4,%d0
}
4f806: 242e fff4 movel %fp@(-12),%d2 4f80a: 246e fff8 moveal %fp@(-8),%a2 4f80e: 4e5e unlk %fp
...
00046586 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
46586: 4e56 ffec linkw %fp,#-20 4658a: 48d7 041c moveml %d2-%d4/%a2,%sp@
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
4658e: 486e fffc pea %fp@(-4) 46592: 262e 0008 movel %fp@(8),%d3 46596: 2f03 movel %d3,%sp@- 46598: 4879 0005 f060 pea 5f060 <_Rate_monotonic_Information> 4659e: 242e 000c movel %fp@(12),%d2 465a2: 4eb9 0004 84cc jsr 484cc <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
465a8: 4fef 000c lea %sp@(12),%sp 465ac: 2440 moveal %d0,%a2 465ae: 4aae fffc tstl %fp@(-4) 465b2: 6600 0148 bnew 466fc <rtems_rate_monotonic_period+0x176>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
465b6: 2039 0005 f2ec movel 5f2ec <_Per_CPU_Information+0xc>,%d0 465bc: b0aa 0040 cmpl %a2@(64),%d0
465c0: 670c beqs 465ce <rtems_rate_monotonic_period+0x48>
_Thread_Enable_dispatch();
465c2: 4eb9 0004 9042 jsr 49042 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
465c8: 7417 moveq #23,%d2 465ca: 6000 0132 braw 466fe <rtems_rate_monotonic_period+0x178>
}
if ( length == RTEMS_PERIOD_STATUS ) {
465ce: 4a82 tstl %d2
465d0: 6622 bnes 465f4 <rtems_rate_monotonic_period+0x6e>
switch ( the_period->state ) {
465d2: 202a 0038 movel %a2@(56),%d0 465d6: 7204 moveq #4,%d1 465d8: b280 cmpl %d0,%d1
465da: 650c bcss 465e8 <rtems_rate_monotonic_period+0x62><== NEVER TAKEN
465dc: 41f9 0005 c906 lea 5c906 <CSWTCH.2>,%a0 465e2: 2430 0c00 movel %a0@(00000000,%d0:l:4),%d2 465e6: 6002 bras 465ea <rtems_rate_monotonic_period+0x64>
465e8: 4282 clrl %d2 <== NOT EXECUTED
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
465ea: 4eb9 0004 9042 jsr 49042 <_Thread_Enable_dispatch>
return( return_value );
465f0: 6000 010c braw 466fe <rtems_rate_monotonic_period+0x178>
}
_ISR_Disable( level );
465f4: 203c 0000 0700 movel #1792,%d0 465fa: 40c4 movew %sr,%d4 465fc: 8084 orl %d4,%d0 465fe: 46c0 movew %d0,%sr
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
46600: 202a 0038 movel %a2@(56),%d0
46604: 664a bnes 46650 <rtems_rate_monotonic_period+0xca>
_ISR_Enable( level );
46606: 46c4 movew %d4,%sr
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
46608: 2f0a movel %a2,%sp@- 4660a: 4eb9 0004 641a jsr 4641a <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
46610: 7002 moveq #2,%d0
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
46612: 223c 0004 6948 movel #289096,%d1 46618: 2540 0038 movel %d0,%a2@(56) 4661c: 2541 002c movel %d1,%a2@(44)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
46620: 42aa 0018 clrl %a2@(24)
the_watchdog->routine = routine; the_watchdog->id = id;
46624: 2543 0030 movel %d3,%a2@(48)
the_watchdog->user_data = user_data;
46628: 42aa 0034 clrl %a2@(52)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
4662c: 2542 003c movel %d2,%a2@(60)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
46630: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
46634: 486a 0010 pea %a2@(16) 46638: 4879 0005 f210 pea 5f210 <_Watchdog_Ticks_chain> 4663e: 4eb9 0004 9d68 jsr 49d68 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
46644: 4eb9 0004 9042 jsr 49042 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
4664a: 4fef 000c lea %sp@(12),%sp 4664e: 606c bras 466bc <rtems_rate_monotonic_period+0x136>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
46650: 7202 moveq #2,%d1 46652: b280 cmpl %d0,%d1
46654: 666a bnes 466c0 <rtems_rate_monotonic_period+0x13a>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
46656: 2f0a movel %a2,%sp@- 46658: 4eb9 0004 6492 jsr 46492 <_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;
4665e: 7001 moveq #1,%d0
the_period->next_length = length;
46660: 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;
46664: 2540 0038 movel %d0,%a2@(56)
the_period->next_length = length;
_ISR_Enable( level );
46668: 46c4 movew %d4,%sr
_Thread_Executing->Wait.id = the_period->Object.id;
4666a: 2079 0005 f2ec moveal 5f2ec <_Per_CPU_Information+0xc>,%a0 46670: 216a 0008 0020 movel %a2@(8),%a0@(32)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
46676: 4878 4000 pea 4000 <D_MAX_EXP+0x3801> 4667a: 2f08 movel %a0,%sp@- 4667c: 4eb9 0004 97a8 jsr 497a8 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
46682: 203c 0000 0700 movel #1792,%d0 46688: 40c1 movew %sr,%d1 4668a: 8081 orl %d1,%d0 4668c: 46c0 movew %d0,%sr
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
4668e: 7402 moveq #2,%d2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
46690: 202a 0038 movel %a2@(56),%d0
the_period->state = RATE_MONOTONIC_ACTIVE;
46694: 2542 0038 movel %d2,%a2@(56)
_ISR_Enable( level );
46698: 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 )
4669a: 7203 moveq #3,%d1 4669c: 4fef 000c lea %sp@(12),%sp 466a0: b280 cmpl %d0,%d1
466a2: 6612 bnes 466b6 <rtems_rate_monotonic_period+0x130>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
466a4: 4878 4000 pea 4000 <D_MAX_EXP+0x3801> 466a8: 2f39 0005 f2ec movel 5f2ec <_Per_CPU_Information+0xc>,%sp@- 466ae: 4eb9 0004 8d00 jsr 48d00 <_Thread_Clear_state> 466b4: 508f addql #8,%sp
_Thread_Enable_dispatch();
466b6: 4eb9 0004 9042 jsr 49042 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
466bc: 4282 clrl %d2 466be: 603e bras 466fe <rtems_rate_monotonic_period+0x178>
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
466c0: 7204 moveq #4,%d1 466c2: b280 cmpl %d0,%d1
466c4: 6636 bnes 466fc <rtems_rate_monotonic_period+0x176><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
466c6: 2f0a movel %a2,%sp@- 466c8: 4eb9 0004 6492 jsr 46492 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
466ce: 46c4 movew %d4,%sr
the_period->state = RATE_MONOTONIC_ACTIVE;
466d0: 7002 moveq #2,%d0
the_period->next_length = length;
466d2: 2542 003c movel %d2,%a2@(60)
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
466d6: 2540 0038 movel %d0,%a2@(56)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
466da: 2542 001c movel %d2,%a2@(28)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
466de: 486a 0010 pea %a2@(16)
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
466e2: 7406 moveq #6,%d2 466e4: 4879 0005 f210 pea 5f210 <_Watchdog_Ticks_chain> 466ea: 4eb9 0004 9d68 jsr 49d68 <_Watchdog_Insert>
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
466f0: 4eb9 0004 9042 jsr 49042 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
466f6: 4fef 000c lea %sp@(12),%sp 466fa: 6002 bras 466fe <rtems_rate_monotonic_period+0x178>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
466fc: 7404 moveq #4,%d2
}
466fe: 2002 movel %d2,%d0 46700: 4cee 041c ffec moveml %fp@(-20),%d2-%d4/%a2 46706: 4e5e unlk %fp
...
00050d70 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
50d70: 4e56 fffc linkw %fp,#-4 50d74: 2f03 movel %d3,%sp@- 50d76: 262e 0010 movel %fp@(16),%d3 50d7a: 2f02 movel %d2,%sp@- 50d7c: 242e 000c movel %fp@(12),%d2
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
50d80: 6768 beqs 50dea <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
if ( !size )
50d82: 4a83 tstl %d3
50d84: 6764 beqs 50dea <rtems_region_get_segment_size+0x7a>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
50d86: 2f39 0007 5ff4 movel 75ff4 <_RTEMS_Allocator_Mutex>,%sp@- 50d8c: 4eb9 0005 2c38 jsr 52c38 <_API_Mutex_Lock> 50d92: 486e fffc pea %fp@(-4) 50d96: 2f2e 0008 movel %fp@(8),%sp@- 50d9a: 4879 0007 5e64 pea 75e64 <_Region_Information> 50da0: 4eb9 0005 4574 jsr 54574 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
50da6: 222e fffc movel %fp@(-4),%d1 50daa: 4fef 0010 lea %sp@(16),%sp
50dae: 6708 beqs 50db8 <rtems_region_get_segment_size+0x48>
50db0: 7001 moveq #1,%d0 50db2: b081 cmpl %d1,%d0
50db4: 661a bnes 50dd0 <rtems_region_get_segment_size+0x60><== NEVER TAKEN
50db6: 601c bras 50dd4 <rtems_region_get_segment_size+0x64>
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
50db8: 2f03 movel %d3,%sp@- 50dba: 2040 moveal %d0,%a0 50dbc: 2f02 movel %d2,%sp@- 50dbe: 4868 0068 pea %a0@(104) 50dc2: 4eb9 0005 3fec jsr 53fec <_Heap_Size_of_alloc_area> 50dc8: 4fef 000c lea %sp@(12),%sp 50dcc: 4a00 tstb %d0
50dce: 6708 beqs 50dd8 <rtems_region_get_segment_size+0x68><== NEVER TAKEN
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
50dd0: 4282 clrl %d2 50dd2: 6006 bras 50dda <rtems_region_get_segment_size+0x6a>
case OBJECTS_REMOTE: /* this error cannot be returned */
break;
#endif
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
50dd4: 7404 moveq #4,%d2 50dd6: 6002 bras 50dda <rtems_region_get_segment_size+0x6a>
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
return_status = RTEMS_INVALID_ADDRESS;
50dd8: 7409 moveq #9,%d2 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
50dda: 2f39 0007 5ff4 movel 75ff4 <_RTEMS_Allocator_Mutex>,%sp@- 50de0: 4eb9 0005 2c98 jsr 52c98 <_API_Mutex_Unlock>
return return_status;
50de6: 588f addql #4,%sp 50de8: 6002 bras 50dec <rtems_region_get_segment_size+0x7c>
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
50dea: 7409 moveq #9,%d2
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
50dec: 2002 movel %d2,%d0 50dee: 242e fff4 movel %fp@(-12),%d2 50df2: 262e fff8 movel %fp@(-8),%d3 50df6: 4e5e unlk %fp
...
00045e90 <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
45e90: 7003 moveq #3,%d0
*/
void rtems_shutdown_executive(
uint32_t result
)
{
45e92: 4e56 0000 linkw %fp,#0
if ( _System_state_Is_up( _System_state_Get() ) ) {
45e96: b0b9 0005 d6a0 cmpl 5d6a0 <_System_state_Current>,%d0
45e9c: 6618 bnes 45eb6 <rtems_shutdown_executive+0x26>
45e9e: 103c 0004 moveb #4,%d0
* if we were running within the same context, it would work. * * And we will not return to this thread, so there is no point of * saving the context. */ _Context_Restart_self( &_Thread_BSP_context );
45ea2: 4879 0005 d524 pea 5d524 <_Thread_BSP_context> 45ea8: 23c0 0005 d6a0 movel %d0,5d6a0 <_System_state_Current> 45eae: 4eb9 0004 896e jsr 4896e <_CPU_Context_Restart_self>
45eb4: 588f addql #4,%sp <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_SHUTDOWN );
_Thread_Stop_multitasking();
}
_Internal_error_Occurred(
45eb6: 4878 0014 pea 14 <OPER2> 45eba: 4878 0001 pea 1 <ADD> 45ebe: 42a7 clrl %sp@- 45ec0: 4eb9 0004 69b0 jsr 469b0 <_Internal_error_Occurred>
...
000513d0 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
513d0: 4e56 fffc linkw %fp,#-4 513d4: 2f03 movel %d3,%sp@- 513d6: 2f02 movel %d2,%sp@- 513d8: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
513dc: 677a beqs 51458 <rtems_signal_send+0x88> <== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
513de: 486e fffc pea %fp@(-4) 513e2: 2f2e 0008 movel %fp@(8),%sp@- 513e6: 4eb9 0005 5148 jsr 55148 <_Thread_Get>
switch ( location ) {
513ec: 508f addql #8,%sp 513ee: 4aae fffc tstl %fp@(-4)
513f2: 6668 bnes 5145c <rtems_signal_send+0x8c> <== NEVER TAKEN
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
513f4: 2240 moveal %d0,%a1 513f6: 2069 00fc moveal %a1@(252),%a0
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
513fa: 4aa8 000a tstl %a0@(10)
513fe: 674e beqs 5144e <rtems_signal_send+0x7e>
if ( asr->is_enabled ) {
51400: 4a28 0008 tstb %a0@(8)
51404: 672c beqs 51432 <rtems_signal_send+0x62>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
51406: 223c 0000 0700 movel #1792,%d1 5140c: 40c3 movew %sr,%d3 5140e: 8283 orl %d3,%d1 51410: 46c1 movew %d1,%sr
*signal_set |= signals;
51412: 85a8 0012 orl %d2,%a0@(18)
_ISR_Enable( _level );
51416: 46c3 movew %d3,%sr
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
51418: 4ab9 0007 60f4 tstl 760f4 <_Per_CPU_Information+0x8>
5141e: 6724 beqs 51444 <rtems_signal_send+0x74>
51420: b0b9 0007 60f8 cmpl 760f8 <_Per_CPU_Information+0xc>,%d0
51426: 661c bnes 51444 <rtems_signal_send+0x74> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
51428: 7001 moveq #1,%d0 5142a: 13c0 0007 6104 moveb %d0,76104 <_Per_CPU_Information+0x18> 51430: 6012 bras 51444 <rtems_signal_send+0x74>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
51432: 203c 0000 0700 movel #1792,%d0 51438: 40c1 movew %sr,%d1 5143a: 8081 orl %d1,%d0 5143c: 46c0 movew %d0,%sr
*signal_set |= signals;
5143e: 85a8 0016 orl %d2,%a0@(22)
_ISR_Enable( _level );
51442: 46c1 movew %d1,%sr
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
51444: 4eb9 0005 5122 jsr 55122 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
5144a: 4280 clrl %d0 5144c: 6010 bras 5145e <rtems_signal_send+0x8e>
}
_Thread_Enable_dispatch();
5144e: 4eb9 0005 5122 jsr 55122 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
51454: 700b moveq #11,%d0 51456: 6006 bras 5145e <rtems_signal_send+0x8e>
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
51458: 700a moveq #10,%d0 5145a: 6002 bras 5145e <rtems_signal_send+0x8e>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
5145c: 7004 moveq #4,%d0
}
5145e: 242e fff4 movel %fp@(-12),%d2 51462: 262e fff8 movel %fp@(-8),%d3 51466: 4e5e unlk %fp
...
0004b8a0 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
4b8a0: 4e56 ffe4 linkw %fp,#-28 4b8a4: 48d7 1c3c moveml %d2-%d5/%a2-%a4,%sp@ 4b8a8: 262e 0008 movel %fp@(8),%d3 4b8ac: 282e 000c movel %fp@(12),%d4 4b8b0: 286e 0010 moveal %fp@(16),%a4
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
4b8b4: 4a8c tstl %a4 4b8b6: 6700 0104 beqw 4b9bc <rtems_task_mode+0x11c>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
4b8ba: 2679 0005 d6f4 moveal 5d6f4 <_Per_CPU_Information+0xc>,%a3
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4b8c0: 4a2b 0074 tstb %a3@(116) 4b8c4: 57c2 seq %d2
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4b8c6: 246b 00fc moveal %a3@(252),%a2
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4b8ca: 49c2 extbl %d2 4b8cc: 0282 0000 0100 andil #256,%d2
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4b8d2: 4aab 007a tstl %a3@(122)
4b8d6: 6704 beqs 4b8dc <rtems_task_mode+0x3c>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
4b8d8: 08c2 0009 bset #9,%d2
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4b8dc: 4a2a 0008 tstb %a2@(8) 4b8e0: 57c5 seq %d5
old_mode |= _ISR_Get_level();
4b8e2: 4eb9 0004 8a14 jsr 48a14 <_CPU_ISR_Get_level>
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4b8e8: 49c5 extbl %d5 4b8ea: 0285 0000 0400 andil #1024,%d5 4b8f0: 8085 orl %d5,%d0
old_mode |= _ISR_Get_level();
4b8f2: 8082 orl %d2,%d0 4b8f4: 2880 movel %d0,%a4@
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
4b8f6: 0804 0008 btst #8,%d4
4b8fa: 670c beqs 4b908 <rtems_task_mode+0x68>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
4b8fc: 0803 0008 btst #8,%d3 4b900: 57c0 seq %d0 4b902: 4480 negl %d0 4b904: 1740 0074 moveb %d0,%a3@(116)
if ( mask & RTEMS_TIMESLICE_MASK ) {
4b908: 0804 0009 btst #9,%d4
4b90c: 671c beqs 4b92a <rtems_task_mode+0x8a>
if ( _Modes_Is_timeslice(mode_set) ) {
4b90e: 0803 0009 btst #9,%d3
4b912: 6712 beqs 4b926 <rtems_task_mode+0x86>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4b914: 41f9 0005 d510 lea 5d510 <_Thread_Ticks_per_timeslice>,%a0
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4b91a: 7001 moveq #1,%d0
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4b91c: 2750 0076 movel %a0@,%a3@(118)
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4b920: 2740 007a movel %d0,%a3@(122) 4b924: 6004 bras 4b92a <rtems_task_mode+0x8a>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
4b926: 42ab 007a clrl %a3@(122)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
4b92a: 7007 moveq #7,%d0 4b92c: c084 andl %d4,%d0
4b92e: 6712 beqs 4b942 <rtems_task_mode+0xa2>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
4b930: 40c0 movew %sr,%d0
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
4b932: 7207 moveq #7,%d1 4b934: c283 andl %d3,%d1
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
4b936: 0280 0000 f8ff andil #63743,%d0 4b93c: e189 lsll #8,%d1 4b93e: 8081 orl %d1,%d0 4b940: 46c0 movew %d0,%sr
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
4b942: 0804 000a btst #10,%d4
4b946: 6740 beqs 4b988 <rtems_task_mode+0xe8>
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
4b948: 4281 clrl %d1 4b94a: 122a 0008 moveb %a2@(8),%d1 4b94e: 4282 clrl %d2
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
4b950: 0803 000a btst #10,%d3 4b954: 57c0 seq %d0 4b956: 4480 negl %d0
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
4b958: 1400 moveb %d0,%d2 4b95a: b282 cmpl %d2,%d1
4b95c: 672a beqs 4b988 <rtems_task_mode+0xe8>
asr->is_enabled = is_asr_enabled;
4b95e: 1540 0008 moveb %d0,%a2@(8)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
4b962: 203c 0000 0700 movel #1792,%d0 4b968: 40c1 movew %sr,%d1 4b96a: 8081 orl %d1,%d0 4b96c: 46c0 movew %d0,%sr
_signals = information->signals_pending;
4b96e: 202a 0016 movel %a2@(22),%d0
information->signals_pending = information->signals_posted;
4b972: 256a 0012 0016 movel %a2@(18),%a2@(22)
information->signals_posted = _signals;
4b978: 2540 0012 movel %d0,%a2@(18)
_ISR_Enable( _level );
4b97c: 46c1 movew %d1,%sr
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
4b97e: 4aaa 0012 tstl %a2@(18) 4b982: 56c0 sne %d0 4b984: 4480 negl %d0 4b986: 6002 bras 4b98a <rtems_task_mode+0xea> 4b988: 4200 clrb %d0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
4b98a: 7203 moveq #3,%d1 4b98c: b2b9 0005 d6a0 cmpl 5d6a0 <_System_state_Current>,%d1
4b992: 662c bnes 4b9c0 <rtems_task_mode+0x120>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
4b994: 2079 0005 d6f4 moveal 5d6f4 <_Per_CPU_Information+0xc>,%a0
if ( are_signals_pending ||
4b99a: 4a00 tstb %d0
4b99c: 660e bnes 4b9ac <rtems_task_mode+0x10c>
4b99e: b1f9 0005 d6f8 cmpal 5d6f8 <_Per_CPU_Information+0x10>,%a0
4b9a4: 671a beqs 4b9c0 <rtems_task_mode+0x120>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
4b9a6: 4a28 0074 tstb %a0@(116)
4b9aa: 6714 beqs 4b9c0 <rtems_task_mode+0x120> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
4b9ac: 7001 moveq #1,%d0 4b9ae: 13c0 0005 d700 moveb %d0,5d700 <_Per_CPU_Information+0x18>
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
4b9b4: 4eb9 0004 78f8 jsr 478f8 <_Thread_Dispatch> 4b9ba: 6004 bras 4b9c0 <rtems_task_mode+0x120>
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
4b9bc: 7009 moveq #9,%d0 4b9be: 6002 bras 4b9c2 <rtems_task_mode+0x122>
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
4b9c0: 4280 clrl %d0
}
4b9c2: 4cee 1c3c ffe4 moveml %fp@(-28),%d2-%d5/%a2-%a4
4b9c8: 4e5e unlk %fp <== NOT EXECUTED
0004952c <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
4952c: 4e56 fffc linkw %fp,#-4 49530: 2f0a movel %a2,%sp@- 49532: 246e 0010 moveal %fp@(16),%a2 49536: 2f02 movel %d2,%sp@- 49538: 242e 000c movel %fp@(12),%d2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
4953c: 670c beqs 4954a <rtems_task_set_priority+0x1e>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
4953e: 4280 clrl %d0 49540: 1039 0005 f572 moveb 5f572 <rtems_maximum_priority>,%d0 49546: b082 cmpl %d2,%d0
49548: 654e bcss 49598 <rtems_task_set_priority+0x6c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
4954a: 4a8a tstl %a2
4954c: 674e beqs 4959c <rtems_task_set_priority+0x70>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
4954e: 486e fffc pea %fp@(-4) 49552: 2f2e 0008 movel %fp@(8),%sp@- 49556: 4eb9 0004 b4f4 jsr 4b4f4 <_Thread_Get>
switch ( location ) {
4955c: 508f addql #8,%sp
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
4955e: 2040 moveal %d0,%a0
switch ( location ) {
49560: 4aae fffc tstl %fp@(-4)
49564: 663a bnes 495a0 <rtems_task_set_priority+0x74>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
49566: 24a8 0014 movel %a0@(20),%a2@
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4956a: 4a82 tstl %d2
4956c: 6720 beqs 4958e <rtems_task_set_priority+0x62>
the_thread->real_priority = new_priority;
4956e: 2142 0018 movel %d2,%a0@(24)
if ( the_thread->resource_count == 0 ||
49572: 4aa8 001c tstl %a0@(28)
49576: 6706 beqs 4957e <rtems_task_set_priority+0x52>
49578: b4a8 0014 cmpl %a0@(20),%d2
4957c: 6410 bccs 4958e <rtems_task_set_priority+0x62> <== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
4957e: 42a7 clrl %sp@- 49580: 2f02 movel %d2,%sp@- 49582: 2f08 movel %a0,%sp@- 49584: 4eb9 0004 b0b0 jsr 4b0b0 <_Thread_Change_priority> 4958a: 4fef 000c lea %sp@(12),%sp
}
_Thread_Enable_dispatch();
4958e: 4eb9 0004 b4ce jsr 4b4ce <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
49594: 4280 clrl %d0 49596: 600a bras 495a2 <rtems_task_set_priority+0x76>
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
49598: 7013 moveq #19,%d0 4959a: 6006 bras 495a2 <rtems_task_set_priority+0x76>
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
4959c: 7009 moveq #9,%d0 4959e: 6002 bras 495a2 <rtems_task_set_priority+0x76>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
495a0: 7004 moveq #4,%d0
}
495a2: 242e fff4 movel %fp@(-12),%d2 495a6: 246e fff8 moveal %fp@(-8),%a2 495aa: 4e5e unlk %fp
...
000468d4 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
468d4: 4e56 fffc linkw %fp,#-4 468d8: 2f0a movel %a2,%sp@- 468da: 246e 0010 moveal %fp@(16),%a2 468de: 2f02 movel %d2,%sp@- 468e0: 242e 000c movel %fp@(12),%d2
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
468e4: 6742 beqs 46928 <rtems_task_variable_get+0x54>
return RTEMS_INVALID_ADDRESS;
if ( !result )
468e6: 4a8a tstl %a2
468e8: 673e beqs 46928 <rtems_task_variable_get+0x54> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
468ea: 486e fffc pea %fp@(-4) 468ee: 2f2e 0008 movel %fp@(8),%sp@- 468f2: 4eb9 0004 8634 jsr 48634 <_Thread_Get>
switch (location) {
468f8: 508f addql #8,%sp 468fa: 4aae fffc tstl %fp@(-4)
468fe: 662c bnes 4692c <rtems_task_variable_get+0x58>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
46900: 2240 moveal %d0,%a1 46902: 2069 0108 moveal %a1@(264),%a0
while (tvp) {
46906: 6016 bras 4691e <rtems_task_variable_get+0x4a>
if (tvp->ptr == ptr) {
46908: b4a8 0004 cmpl %a0@(4),%d2
4690c: 660e bnes 4691c <rtems_task_variable_get+0x48>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
4690e: 24a8 000c movel %a0@(12),%a2@
_Thread_Enable_dispatch();
46912: 4eb9 0004 860e jsr 4860e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
46918: 4280 clrl %d0 4691a: 6012 bras 4692e <rtems_task_variable_get+0x5a>
}
tvp = (rtems_task_variable_t *)tvp->next;
4691c: 2050 moveal %a0@,%a0
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
4691e: 4a88 tstl %a0
46920: 66e6 bnes 46908 <rtems_task_variable_get+0x34>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
46922: 4eb9 0004 860e jsr 4860e <_Thread_Enable_dispatch>
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
46928: 7009 moveq #9,%d0 4692a: 6002 bras 4692e <rtems_task_variable_get+0x5a>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
4692c: 7004 moveq #4,%d0
}
4692e: 242e fff4 movel %fp@(-12),%d2 46932: 246e fff8 moveal %fp@(-8),%a2 46936: 4e5e unlk %fp
...
0004692c <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
4692c: 4e56 0000 linkw %fp,#0 46930: 2f0a movel %a2,%sp@- 46932: 246e 0008 moveal %fp@(8),%a2
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
46936: 4a39 0005 eb20 tstb 5eb20 <_TOD_Is_set> 4693c: 6700 0096 beqw 469d4 <rtems_task_wake_when+0xa8>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
46940: 4a8a tstl %a2 46942: 6700 0094 beqw 469d8 <rtems_task_wake_when+0xac>
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
46946: 42aa 0018 clrl %a2@(24)
if ( !_TOD_Validate( time_buffer ) )
4694a: 2f0a movel %a2,%sp@- 4694c: 4eb9 0004 5de0 jsr 45de0 <_TOD_Validate> 46952: 588f addql #4,%sp 46954: 4a00 tstb %d0 46956: 6700 0084 beqw 469dc <rtems_task_wake_when+0xb0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
4695a: 2f0a movel %a2,%sp@- 4695c: 4eb9 0004 5d44 jsr 45d44 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
46962: 588f addql #4,%sp
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
46964: 2440 moveal %d0,%a2
if ( seconds <= _TOD_Seconds_since_epoch() )
46966: b0b9 0005 eb9a cmpl 5eb9a <_TOD_Now>,%d0
4696c: 636e blss 469dc <rtems_task_wake_when+0xb0> <== NEVER TAKEN
4696e: 2039 0005 eb10 movel 5eb10 <_Thread_Dispatch_disable_level>,%d0 46974: 5280 addql #1,%d0 46976: 23c0 0005 eb10 movel %d0,5eb10 <_Thread_Dispatch_disable_level>
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
4697c: 4878 0010 pea 10 <INVALID_OPERATION> 46980: 2f39 0005 ecac movel 5ecac <_Per_CPU_Information+0xc>,%sp@- 46986: 4eb9 0004 8dc4 jsr 48dc4 <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
4698c: 2079 0005 ecac moveal 5ecac <_Per_CPU_Information+0xc>,%a0
NULL
);
_Watchdog_Insert_seconds(
46992: 95f9 0005 eb9a subal 5eb9a <_TOD_Now>,%a2
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
46998: 223c 0004 84e4 movel #296164,%d1
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
_Watchdog_Initialize(
4699e: 2028 0008 movel %a0@(8),%d0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
469a2: 42a8 0050 clrl %a0@(80)
the_watchdog->routine = routine; the_watchdog->id = id;
469a6: 2140 0068 movel %d0,%a0@(104)
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
469aa: 2141 0064 movel %d1,%a0@(100)
the_watchdog->id = id; the_watchdog->user_data = user_data;
469ae: 42a8 006c clrl %a0@(108)
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
469b2: 214a 0054 movel %a2,%a0@(84)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
469b6: 4868 0048 pea %a0@(72) 469ba: 4879 0005 ebc4 pea 5ebc4 <_Watchdog_Seconds_chain> 469c0: 4eb9 0004 9314 jsr 49314 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
469c6: 4eb9 0004 865e jsr 4865e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
469cc: 4fef 0010 lea %sp@(16),%sp 469d0: 4280 clrl %d0 469d2: 600a bras 469de <rtems_task_wake_when+0xb2>
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
469d4: 700b moveq #11,%d0 469d6: 6006 bras 469de <rtems_task_wake_when+0xb2>
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
469d8: 7009 moveq #9,%d0 469da: 6002 bras 469de <rtems_task_wake_when+0xb2>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
469dc: 7014 moveq #20,%d0
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
469de: 246e fffc moveal %fp@(-4),%a2 469e2: 4e5e unlk %fp
...
00051c5c <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
51c5c: 4e56 fffc linkw %fp,#-4
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
51c60: 486e fffc pea %fp@(-4) 51c64: 2f2e 0008 movel %fp@(8),%sp@- 51c68: 4879 0007 6168 pea 76168 <_Timer_Information> 51c6e: 4eb9 0005 45ac jsr 545ac <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
51c74: 4fef 000c lea %sp@(12),%sp 51c78: 4aae fffc tstl %fp@(-4)
51c7c: 6620 bnes 51c9e <rtems_timer_cancel+0x42>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
51c7e: 7204 moveq #4,%d1 51c80: 2040 moveal %d0,%a0 51c82: b2a8 0038 cmpl %a0@(56),%d1
51c86: 670c beqs 51c94 <rtems_timer_cancel+0x38> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
51c88: 4868 0010 pea %a0@(16) 51c8c: 4eb9 0005 60b4 jsr 560b4 <_Watchdog_Remove> 51c92: 588f addql #4,%sp
_Thread_Enable_dispatch();
51c94: 4eb9 0005 5122 jsr 55122 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
51c9a: 4280 clrl %d0 51c9c: 6002 bras 51ca0 <rtems_timer_cancel+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
51c9e: 7004 moveq #4,%d0
}
51ca0: 4e5e unlk %fp <== NOT EXECUTED
00051f98 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
51f98: 4e56 fffc linkw %fp,#-4 51f9c: 2f0b movel %a3,%sp@- 51f9e: 2f0a movel %a2,%sp@- 51fa0: 486e fffc pea %fp@(-4) 51fa4: 2f2e 0008 movel %fp@(8),%sp@- 51fa8: 4879 0007 6168 pea 76168 <_Timer_Information> 51fae: 4eb9 0005 45ac jsr 545ac <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
51fb4: 4fef 000c lea %sp@(12),%sp 51fb8: 2440 moveal %d0,%a2 51fba: 4aae fffc tstl %fp@(-4)
51fbe: 6656 bnes 52016 <rtems_timer_reset+0x7e> <== NEVER TAKEN
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
51fc0: 202a 0038 movel %a2@(56),%d0
51fc4: 661c bnes 51fe2 <rtems_timer_reset+0x4a>
_Watchdog_Remove( &the_timer->Ticker );
51fc6: 45ea 0010 lea %a2@(16),%a2 51fca: 2f0a movel %a2,%sp@- 51fcc: 4eb9 0005 60b4 jsr 560b4 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
51fd2: 2f0a movel %a2,%sp@- 51fd4: 4879 0007 6014 pea 76014 <_Watchdog_Ticks_chain> 51fda: 4eb9 0005 5f8c jsr 55f8c <_Watchdog_Insert> 51fe0: 6020 bras 52002 <rtems_timer_reset+0x6a>
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
51fe2: 7201 moveq #1,%d1 51fe4: b280 cmpl %d0,%d1
51fe6: 6622 bnes 5200a <rtems_timer_reset+0x72> <== NEVER TAKEN
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
51fe8: 486a 0010 pea %a2@(16)
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
Timer_server_Control *timer_server = _Timer_server;
51fec: 2679 0007 61a0 moveal 761a0 <_Timer_server>,%a3
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
51ff2: 4eb9 0005 60b4 jsr 560b4 <_Watchdog_Remove>
(*timer_server->schedule_operation)( timer_server, the_timer );
51ff8: 2f0a movel %a2,%sp@- 51ffa: 2f0b movel %a3,%sp@- 51ffc: 206b 0004 moveal %a3@(4),%a0 52000: 4e90 jsr %a0@ 52002: 4fef 000c lea %sp@(12),%sp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
52006: 95ca subal %a2,%a2 52008: 6004 bras 5200e <rtems_timer_reset+0x76>
/*
* Must be dormant or time of day timer (e.g. TIMER_DORMANT,
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
5200a: 347c 000b moveaw #11,%a2
}
_Thread_Enable_dispatch();
5200e: 4eb9 0005 5122 jsr 55122 <_Thread_Enable_dispatch>
return status;
52014: 6004 bras 5201a <rtems_timer_reset+0x82>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
52016: 347c 0004 moveaw #4,%a2
}
5201a: 200a movel %a2,%d0 5201c: 246e fff4 moveal %fp@(-12),%a2 52020: 266e fff8 moveal %fp@(-8),%a3
52024: 4e5e unlk %fp <== NOT EXECUTED
000520e4 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
520e4: 4e56 ffe8 linkw %fp,#-24 520e8: 48d7 0c1c moveml %d2-%d4/%a2-%a3,%sp@ 520ec: 262e 0008 movel %fp@(8),%d3 520f0: 242e 000c movel %fp@(12),%d2 520f4: 282e 0010 movel %fp@(16),%d4
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
520f8: 2679 0007 61a0 moveal 761a0 <_Timer_server>,%a3
if ( !timer_server )
520fe: 4a8b tstl %a3 52100: 6700 0098 beqw 5219a <rtems_timer_server_fire_when+0xb6>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
52104: 4a39 0007 5f64 tstb 75f64 <_TOD_Is_set> 5210a: 6700 0092 beqw 5219e <rtems_timer_server_fire_when+0xba>
return RTEMS_NOT_DEFINED;
if ( !routine )
5210e: 4a84 tstl %d4 52110: 6700 0090 beqw 521a2 <rtems_timer_server_fire_when+0xbe>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
52114: 2f02 movel %d2,%sp@- 52116: 4eb9 0004 f5a4 jsr 4f5a4 <_TOD_Validate> 5211c: 588f addql #4,%sp 5211e: 4a00 tstb %d0 52120: 6700 0084 beqw 521a6 <rtems_timer_server_fire_when+0xc2>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
52124: 2f02 movel %d2,%sp@- 52126: 4eb9 0004 f508 jsr 4f508 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
5212c: 588f addql #4,%sp
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
5212e: 2400 movel %d0,%d2
if ( seconds <= _TOD_Seconds_since_epoch() )
52130: b0b9 0007 5fde cmpl 75fde <_TOD_Now>,%d0
52136: 636e blss 521a6 <rtems_timer_server_fire_when+0xc2>
52138: 486e fffc pea %fp@(-4) 5213c: 2f03 movel %d3,%sp@- 5213e: 4879 0007 6168 pea 76168 <_Timer_Information> 52144: 4eb9 0005 45ac jsr 545ac <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
5214a: 4fef 000c lea %sp@(12),%sp 5214e: 2440 moveal %d0,%a2 52150: 4aae fffc tstl %fp@(-4)
52154: 6654 bnes 521aa <rtems_timer_server_fire_when+0xc6>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
52156: 486a 0010 pea %a2@(16) 5215a: 4eb9 0005 60b4 jsr 560b4 <_Watchdog_Remove>
the_watchdog->user_data = user_data;
52160: 256e 0014 0034 movel %fp@(20),%a2@(52)
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
52166: 94b9 0007 5fde subl 75fde <_TOD_Now>,%d2
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
5216c: 7003 moveq #3,%d0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
5216e: 42aa 0018 clrl %a2@(24) 52172: 2540 0038 movel %d0,%a2@(56)
the_watchdog->routine = routine;
52176: 2544 002c movel %d4,%a2@(44)
the_watchdog->id = id;
5217a: 2543 0030 movel %d3,%a2@(48)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
5217e: 2542 001c movel %d2,%a2@(28)
(*timer_server->schedule_operation)( timer_server, the_timer );
52182: 2f0a movel %a2,%sp@- 52184: 2f0b movel %a3,%sp@- 52186: 206b 0004 moveal %a3@(4),%a0 5218a: 4e90 jsr %a0@
_Thread_Enable_dispatch();
5218c: 4eb9 0005 5122 jsr 55122 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
52192: 4fef 000c lea %sp@(12),%sp 52196: 4280 clrl %d0 52198: 6012 bras 521ac <rtems_timer_server_fire_when+0xc8>
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
5219a: 700e moveq #14,%d0 5219c: 600e bras 521ac <rtems_timer_server_fire_when+0xc8>
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
5219e: 700b moveq #11,%d0 <== NOT EXECUTED 521a0: 600a bras 521ac <rtems_timer_server_fire_when+0xc8><== NOT EXECUTED
if ( !routine )
return RTEMS_INVALID_ADDRESS;
521a2: 7009 moveq #9,%d0 521a4: 6006 bras 521ac <rtems_timer_server_fire_when+0xc8>
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
521a6: 7014 moveq #20,%d0 521a8: 6002 bras 521ac <rtems_timer_server_fire_when+0xc8>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
521aa: 7004 moveq #4,%d0
}
521ac: 4cee 0c1c ffe8 moveml %fp@(-24),%d2-%d4/%a2-%a3 521b2: 4e5e unlk %fp
...