RTEMS 4.11Annotated Report
Sun Dec 23 04:10:33 2012
0800473c <_API_extensions_Add_post_switch>:
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
800473c: 28 22 00 00 lw r2,(r1+0)
8004740: 44 40 00 02 be r2,r0,8004748 <_API_extensions_Add_post_switch+0xc>
8004744: c3 a0 00 00 ret
8004748: 28 23 00 04 lw r3,(r1+4)
800474c: 5c 62 ff fe bne r3,r2,8004744 <_API_extensions_Add_post_switch+0x8><== NEVER TAKEN
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
8004750: 78 02 08 02 mvhi r2,0x802
8004754: 38 42 09 c8 ori r2,r2,0x9c8
8004758: 28 44 00 08 lw r4,(r2+8)
the_node->next = tail;
800475c: 78 03 08 02 mvhi r3,0x802
8004760: 38 63 09 cc ori r3,r3,0x9cc
8004764: 58 23 00 00 sw (r1+0),r3
tail->previous = the_node;
8004768: 58 41 00 08 sw (r2+8),r1
old_last->next = the_node;
800476c: 58 81 00 00 sw (r4+0),r1
the_node->previous = old_last;
8004770: 58 24 00 04 sw (r1+4),r4
8004774: c3 a0 00 00 ret
08004778 <_API_extensions_Run_postdriver>:
}
}
#endif
void _API_extensions_Run_postdriver( void )
{
8004778: 37 9c ff f4 addi sp,sp,-12
800477c: 5b 8b 00 0c sw (sp+12),r11
8004780: 5b 8c 00 08 sw (sp+8),r12
8004784: 5b 9d 00 04 sw (sp+4),ra
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
8004788: 78 01 08 02 mvhi r1,0x802
800478c: 38 21 0a 88 ori r1,r1,0xa88
8004790: 28 2b 00 00 lw r11,(r1+0)
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
8004794: 78 0c 08 02 mvhi r12,0x802
8004798: 39 8c 0a 8c ori r12,r12,0xa8c
800479c: 45 6c 00 05 be r11,r12,80047b0 <_API_extensions_Run_postdriver+0x38><== NEVER TAKEN
* Currently all APIs configure this hook so it is always non-NULL.
*/
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
80047a0: 29 61 00 08 lw r1,(r11+8)
80047a4: d8 20 00 00 call r1
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
80047a8: 29 6b 00 00 lw r11,(r11+0)
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
80047ac: 5d 6c ff fd bne r11,r12,80047a0 <_API_extensions_Run_postdriver+0x28>
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
80047b0: 2b 9d 00 04 lw ra,(sp+4)
80047b4: 2b 8b 00 0c lw r11,(sp+12)
80047b8: 2b 8c 00 08 lw r12,(sp+8)
80047bc: 37 9c 00 0c addi sp,sp,12
80047c0: c3 a0 00 00 ret
08006fe8 <_CORE_RWLock_Release>:
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
8006fe8: 37 9c ff f4 addi sp,sp,-12
8006fec: 5b 8b 00 0c sw (sp+12),r11
8006ff0: 5b 8c 00 08 sw (sp+8),r12
8006ff4: 5b 9d 00 04 sw (sp+4),ra
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
8006ff8: 78 02 08 01 mvhi r2,0x801
8006ffc: 38 42 9d a0 ori r2,r2,0x9da0
8007000: 28 43 00 10 lw r3,(r2+16)
#include <rtems/score/watchdog.h>
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
8007004: b8 20 58 00 mv r11,r1
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
8007008: 90 00 08 00 rcsr r1,IE
800700c: 34 02 ff fe mvi r2,-2
8007010: a0 22 10 00 and r2,r1,r2
8007014: d0 02 00 00 wcsr IE,r2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
8007018: 29 62 00 44 lw r2,(r11+68)
800701c: 44 40 00 2f be r2,r0,80070d8 <_CORE_RWLock_Release+0xf0>
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
8007020: 34 04 00 01 mvi r4,1
8007024: 44 44 00 22 be r2,r4,80070ac <_CORE_RWLock_Release+0xc4>
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
8007028: 58 60 00 34 sw (r3+52),r0
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
800702c: 59 60 00 44 sw (r11+68),r0
_ISR_Enable( level );
8007030: d0 01 00 00 wcsr IE,r1
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
8007034: b9 60 08 00 mv r1,r11
8007038: f8 00 08 a5 calli 80092cc <_Thread_queue_Dequeue>
if ( next ) {
800703c: 44 20 00 16 be r1,r0,8007094 <_CORE_RWLock_Release+0xac>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
8007040: 28 22 00 30 lw r2,(r1+48)
8007044: 34 01 00 01 mvi r1,1
8007048: 44 41 00 2d be r2,r1,80070fc <_CORE_RWLock_Release+0x114>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
800704c: 29 62 00 48 lw r2,(r11+72)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
8007050: 59 61 00 44 sw (r11+68),r1
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
8007054: 34 0c 00 01 mvi r12,1
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
8007058: 34 41 00 01 addi r1,r2,1
800705c: 59 61 00 48 sw (r11+72),r1
8007060: e0 00 00 07 bi 800707c <_CORE_RWLock_Release+0x94>
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
8007064: 28 63 00 30 lw r3,(r3+48)
8007068: 44 6c 00 0b be r3,r12,8007094 <_CORE_RWLock_Release+0xac> <== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
800706c: 29 63 00 48 lw r3,(r11+72)
8007070: 34 63 00 01 addi r3,r3,1
8007074: 59 63 00 48 sw (r11+72),r3
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
8007078: f8 00 09 bd calli 800976c <_Thread_queue_Extract>
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
800707c: b9 60 08 00 mv r1,r11
8007080: f8 00 0a 09 calli 80098a4 <_Thread_queue_First>
8007084: b8 20 18 00 mv r3,r1
if ( !next ||
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
8007088: b8 20 10 00 mv r2,r1
800708c: b9 60 08 00 mv r1,r11
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
8007090: 5c 60 ff f5 bne r3,r0,8007064 <_CORE_RWLock_Release+0x7c>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
8007094: 34 01 00 00 mvi r1,0
8007098: 2b 9d 00 04 lw ra,(sp+4)
800709c: 2b 8b 00 0c lw r11,(sp+12)
80070a0: 2b 8c 00 08 lw r12,(sp+8)
80070a4: 37 9c 00 0c addi sp,sp,12
80070a8: c3 a0 00 00 ret
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
the_rwlock->number_of_readers -= 1;
80070ac: 29 62 00 48 lw r2,(r11+72)
80070b0: 34 42 ff ff addi r2,r2,-1
80070b4: 59 62 00 48 sw (r11+72),r2
if ( the_rwlock->number_of_readers != 0 ) {
80070b8: 44 40 ff dc be r2,r0,8007028 <_CORE_RWLock_Release+0x40>
/* must be unlocked again */
_ISR_Enable( level );
80070bc: d0 01 00 00 wcsr IE,r1
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
80070c0: 34 01 00 00 mvi r1,0
80070c4: 2b 9d 00 04 lw ra,(sp+4)
80070c8: 2b 8b 00 0c lw r11,(sp+12)
80070cc: 2b 8c 00 08 lw r12,(sp+8)
80070d0: 37 9c 00 0c addi sp,sp,12
80070d4: c3 a0 00 00 ret
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
80070d8: d0 01 00 00 wcsr IE,r1
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
80070dc: 34 01 00 02 mvi r1,2
80070e0: 58 61 00 34 sw (r3+52),r1
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
80070e4: 34 01 00 00 mvi r1,0
80070e8: 2b 9d 00 04 lw ra,(sp+4)
80070ec: 2b 8b 00 0c lw r11,(sp+12)
80070f0: 2b 8c 00 08 lw r12,(sp+8)
80070f4: 37 9c 00 0c addi sp,sp,12
80070f8: c3 a0 00 00 ret
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
if ( next ) {
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
80070fc: 34 01 00 02 mvi r1,2
8007100: 59 61 00 44 sw (r11+68),r1
return CORE_RWLOCK_SUCCESSFUL;
8007104: e3 ff ff e4 bi 8007094 <_CORE_RWLock_Release+0xac>
08007108 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
8007108: 37 9c ff f8 addi sp,sp,-8
800710c: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
8007110: 37 82 00 08 addi r2,sp,8
8007114: f8 00 07 6b calli 8008ec0 <_Thread_Get>
switch ( location ) {
8007118: 2b 82 00 08 lw r2,(sp+8)
800711c: 5c 40 00 07 bne r2,r0,8007138 <_CORE_RWLock_Timeout+0x30> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
8007120: f8 00 0a 1f calli 800999c <_Thread_queue_Process_timeout>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8007124: 78 01 08 01 mvhi r1,0x801
8007128: 38 21 99 08 ori r1,r1,0x9908
800712c: 28 22 00 00 lw r2,(r1+0)
--level;
8007130: 34 42 ff ff addi r2,r2,-1
_Thread_Dispatch_disable_level = level;
8007134: 58 22 00 00 sw (r1+0),r2
_Thread_Unnest_dispatch();
break;
}
}
8007138: 2b 9d 00 04 lw ra,(sp+4)
800713c: 37 9c 00 08 addi sp,sp,8
8007140: c3 a0 00 00 ret
0800f690 <_CORE_message_queue_Initialize>:
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
800f690: 37 9c ff e8 addi sp,sp,-24
800f694: 5b 8b 00 18 sw (sp+24),r11
800f698: 5b 8c 00 14 sw (sp+20),r12
800f69c: 5b 8d 00 10 sw (sp+16),r13
800f6a0: 5b 8e 00 0c sw (sp+12),r14
800f6a4: 5b 8f 00 08 sw (sp+8),r15
800f6a8: 5b 9d 00 04 sw (sp+4),ra
800f6ac: b8 20 58 00 mv r11,r1
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
800f6b0: 58 20 00 48 sw (r1+72),r0
the_message_queue->maximum_message_size = maximum_message_size;
800f6b4: 58 24 00 4c sw (r1+76),r4
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
800f6b8: 58 20 00 60 sw (r1+96),r0
the_message_queue->notify_argument = the_argument;
800f6bc: 58 20 00 64 sw (r1+100),r0
)
{
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
800f6c0: 59 63 00 44 sw (r11+68),r3
/*
* Check if allocated_message_size is aligned to uintptr-size boundary.
* If not, it will increase allocated_message_size to multiplicity of pointer
* size.
*/
if (allocated_message_size & (sizeof(uintptr_t) - 1)) {
800f6c4: 20 81 00 03 andi r1,r4,0x3
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
)
{
800f6c8: b8 60 60 00 mv r12,r3
800f6cc: b8 40 78 00 mv r15,r2
/*
* Check if allocated_message_size is aligned to uintptr-size boundary.
* If not, it will increase allocated_message_size to multiplicity of pointer
* size.
*/
if (allocated_message_size & (sizeof(uintptr_t) - 1)) {
800f6d0: b8 80 28 00 mv r5,r4
800f6d4: 44 20 00 06 be r1,r0,800f6ec <_CORE_message_queue_Initialize+0x5c>
allocated_message_size += sizeof(uintptr_t);
800f6d8: 34 85 00 04 addi r5,r4,4
allocated_message_size &= ~(sizeof(uintptr_t) - 1);
800f6dc: 34 01 ff fc mvi r1,-4
800f6e0: a0 a1 28 00 and r5,r5,r1
/*
* Check for an overflow. It can occur while increasing allocated_message_size
* to multiplicity of uintptr_t above.
*/
if (allocated_message_size < maximum_message_size)
return false;
800f6e4: 34 0d 00 00 mvi r13,0
/*
* Check for an overflow. It can occur while increasing allocated_message_size
* to multiplicity of uintptr_t above.
*/
if (allocated_message_size < maximum_message_size)
800f6e8: 54 85 00 1f bgu r4,r5,800f764 <_CORE_message_queue_Initialize+0xd4>
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
if ( !size_t_mult32_with_overflow(
800f6ec: 34 ae 00 14 addi r14,r5,20
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
800f6f0: 34 01 00 00 mvi r1,0
800f6f4: b9 c0 10 00 mv r2,r14
800f6f8: 34 03 00 00 mvi r3,0
800f6fc: b9 80 20 00 mv r4,r12
800f700: f8 00 48 05 calli 8021714 <__muldi3>
*/
if ( !size_t_mult32_with_overflow(
(size_t) maximum_pending_messages,
allocated_message_size + sizeof(CORE_message_queue_Buffer_control),
&message_buffering_required ) )
return false;
800f704: 34 0d 00 00 mvi r13,0
size_t *c
)
{
long long x = (long long)a*b;
if ( x > SIZE_MAX )
800f708: 48 20 00 17 bg r1,r0,800f764 <_CORE_message_queue_Initialize+0xd4>
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
800f70c: b8 40 08 00 mv r1,r2
800f710: f8 00 0e f4 calli 80132e0 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
800f714: 59 61 00 5c sw (r11+92),r1
_Workspace_Allocate( message_buffering_required );
800f718: b8 20 18 00 mv r3,r1
if (the_message_queue->message_buffers == 0)
800f71c: 44 20 00 12 be r1,r0,800f764 <_CORE_message_queue_Initialize+0xd4><== NEVER TAKEN
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
800f720: b8 60 10 00 mv r2,r3
800f724: 35 61 00 68 addi r1,r11,104
800f728: b9 80 18 00 mv r3,r12
800f72c: b9 c0 20 00 mv r4,r14
800f730: fb ff ff b7 calli 800f60c <_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 );
800f734: 35 62 00 54 addi r2,r11,84
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
800f738: 35 61 00 50 addi r1,r11,80
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
800f73c: 59 61 00 58 sw (r11+88),r1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
800f740: 59 62 00 50 sw (r11+80),r2
head->previous = NULL;
800f744: 59 60 00 54 sw (r11+84),r0
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
800f748: 29 e2 00 00 lw r2,(r15+0)
800f74c: b9 60 08 00 mv r1,r11
800f750: 34 03 00 80 mvi r3,128
800f754: 64 42 00 01 cmpei r2,r2,1
800f758: 34 04 00 06 mvi r4,6
800f75c: f8 00 0c 34 calli 801282c <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
800f760: 34 0d 00 01 mvi r13,1
}
800f764: b9 a0 08 00 mv r1,r13
800f768: 2b 9d 00 04 lw ra,(sp+4)
800f76c: 2b 8b 00 18 lw r11,(sp+24)
800f770: 2b 8c 00 14 lw r12,(sp+20)
800f774: 2b 8d 00 10 lw r13,(sp+16)
800f778: 2b 8e 00 0c lw r14,(sp+12)
800f77c: 2b 8f 00 08 lw r15,(sp+8)
800f780: 37 9c 00 18 addi sp,sp,24
800f784: c3 a0 00 00 ret
08004dd0 <_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
)
{
8004dd0: 37 9c ff f8 addi sp,sp,-8
8004dd4: 5b 8b 00 08 sw (sp+8),r11
8004dd8: 5b 9d 00 04 sw (sp+4),ra
8004ddc: b8 20 58 00 mv r11,r1
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
8004de0: f8 00 08 a4 calli 8007070 <_Thread_queue_Dequeue>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
8004de4: 34 02 00 00 mvi r2,0
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
8004de8: 44 20 00 06 be r1,r0,8004e00 <_CORE_semaphore_Surrender+0x30>
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
8004dec: b8 40 08 00 mv r1,r2
8004df0: 2b 9d 00 04 lw ra,(sp+4)
8004df4: 2b 8b 00 08 lw r11,(sp+8)
8004df8: 37 9c 00 08 addi sp,sp,8
8004dfc: c3 a0 00 00 ret
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
8004e00: 90 00 08 00 rcsr r1,IE
8004e04: 34 02 ff fe mvi r2,-2
8004e08: a0 22 10 00 and r2,r1,r2
8004e0c: d0 02 00 00 wcsr IE,r2
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
8004e10: 29 63 00 48 lw r3,(r11+72)
8004e14: 29 64 00 40 lw r4,(r11+64)
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
8004e18: 34 02 00 04 mvi r2,4
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
8004e1c: 50 64 00 04 bgeu r3,r4,8004e2c <_CORE_semaphore_Surrender+0x5c><== NEVER TAKEN
the_semaphore->count += 1;
8004e20: 34 63 00 01 addi r3,r3,1
8004e24: 59 63 00 48 sw (r11+72),r3
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
8004e28: 34 02 00 00 mvi r2,0
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
8004e2c: d0 01 00 00 wcsr IE,r1
}
return status;
}
8004e30: b8 40 08 00 mv r1,r2
8004e34: 2b 9d 00 04 lw ra,(sp+4)
8004e38: 2b 8b 00 08 lw r11,(sp+8)
8004e3c: 37 9c 00 08 addi sp,sp,8
8004e40: c3 a0 00 00 ret
08004970 <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
8004970: 37 9c ff f0 addi sp,sp,-16
8004974: 5b 8b 00 10 sw (sp+16),r11
8004978: 5b 8c 00 0c sw (sp+12),r12
800497c: 5b 8d 00 08 sw (sp+8),r13
8004980: 5b 9d 00 04 sw (sp+4),ra
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
8004984: 58 20 00 04 sw (r1+4),r0
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
8004988: b8 20 58 00 mv r11,r1
800498c: b8 40 60 00 mv r12,r2
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
8004990: 34 2d 00 04 addi r13,r1,4
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
8004994: 44 60 00 10 be r3,r0,80049d4 <_Chain_Initialize+0x64> <== NEVER TAKEN
8004998: 34 63 ff ff addi r3,r3,-1
800499c: b8 60 10 00 mv r2,r3
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
Chain_Node *next = starting_address;
80049a0: b9 80 28 00 mv r5,r12
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
80049a4: b9 60 30 00 mv r6,r11
80049a8: e0 00 00 04 bi 80049b8 <_Chain_Initialize+0x48>
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
80049ac: b8 a0 30 00 mv r6,r5
80049b0: 34 63 ff ff addi r3,r3,-1
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
80049b4: b8 e0 28 00 mv r5,r7
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
current->next = next;
80049b8: 58 c5 00 00 sw (r6+0),r5
next->previous = current;
80049bc: 58 a6 00 04 sw (r5+4),r6
#include <rtems/system.h>
#include <rtems/score/address.h>
#include <rtems/score/chain.h>
#include <rtems/score/isr.h>
void _Chain_Initialize(
80049c0: b4 a4 38 00 add r7,r5,r4
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
80049c4: 5c 60 ff fa bne r3,r0,80049ac <_Chain_Initialize+0x3c>
#include <rtems/system.h>
#include <rtems/score/address.h>
#include <rtems/score/chain.h>
#include <rtems/score/isr.h>
void _Chain_Initialize(
80049c8: b8 80 08 00 mv r1,r4
80049cc: f8 00 5d 2a calli 801be74 <__mulsi3>
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
80049d0: b5 81 08 00 add r1,r12,r1
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
80049d4: 58 2d 00 00 sw (r1+0),r13
tail->previous = current;
80049d8: 59 61 00 08 sw (r11+8),r1
}
80049dc: 2b 9d 00 04 lw ra,(sp+4)
80049e0: 2b 8b 00 10 lw r11,(sp+16)
80049e4: 2b 8c 00 0c lw r12,(sp+12)
80049e8: 2b 8d 00 08 lw r13,(sp+8)
80049ec: 37 9c 00 10 addi sp,sp,16
80049f0: c3 a0 00 00 ret
0800ec9c <_Event_Seize>:
Thread_Control *executing,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
800ec9c: 37 9c ff f0 addi sp,sp,-16
800eca0: 5b 8b 00 0c sw (sp+12),r11
800eca4: 5b 8c 00 08 sw (sp+8),r12
800eca8: 5b 9d 00 04 sw (sp+4),ra
rtems_event_set seized_events;
rtems_event_set pending_events;
ISR_Level level;
Thread_blocking_operation_States current_sync_state;
executing->Wait.return_code = RTEMS_SUCCESSFUL;
800ecac: 58 a0 00 34 sw (r5+52),r0
Thread_Control *executing,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
800ecb0: b8 a0 58 00 mv r11,r5
800ecb4: b8 e0 60 00 mv r12,r7
ISR_Level level;
Thread_blocking_operation_States current_sync_state;
executing->Wait.return_code = RTEMS_SUCCESSFUL;
_ISR_Disable( level );
800ecb8: 90 00 48 00 rcsr r9,IE
800ecbc: 34 05 ff fe mvi r5,-2
800ecc0: a1 25 28 00 and r5,r9,r5
800ecc4: d0 05 00 00 wcsr IE,r5
pending_events = event->pending_events;
800ecc8: 28 c7 00 00 lw r7,(r6+0)
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 );
800eccc: a0 27 28 00 and r5,r1,r7
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
800ecd0: 44 a0 00 04 be r5,r0,800ece0 <_Event_Seize+0x44>
800ecd4: 44 25 00 27 be r1,r5,800ed70 <_Event_Seize+0xd4>
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_any (
rtems_option option_set
)
{
return (option_set & RTEMS_EVENT_ANY) ? true : false;
800ecd8: 20 4a 00 02 andi r10,r2,0x2
(seized_events == event_in || _Options_Is_any( option_set )) ) {
800ecdc: 5d 40 00 25 bne r10,r0,800ed70 <_Event_Seize+0xd4>
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
800ece0: 20 46 00 01 andi r6,r2,0x1
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
800ece4: 5c c0 00 1a bne r6,r0,800ed4c <_Event_Seize+0xb0>
*
* NOTE: Since interrupts are disabled, this isn't that much of an
* issue but better safe than sorry.
*/
executing->Wait.option = option_set;
executing->Wait.count = event_in;
800ece8: 59 61 00 24 sw (r11+36),r1
* set properly when we are marked as in the event critical section.
*
* NOTE: Since interrupts are disabled, this isn't that much of an
* issue but better safe than sorry.
*/
executing->Wait.option = option_set;
800ecec: 59 62 00 30 sw (r11+48),r2
executing->Wait.count = event_in;
executing->Wait.return_argument = event_out;
800ecf0: 59 64 00 28 sw (r11+40),r4
*sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
800ecf4: 34 01 00 01 mvi r1,1
800ecf8: 59 81 00 00 sw (r12+0),r1
_ISR_Enable( level );
800ecfc: d0 09 00 00 wcsr IE,r9
if ( ticks ) {
800ed00: 5c 60 00 2c bne r3,r0,800edb0 <_Event_Seize+0x114>
sync_state
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, wait_state );
800ed04: b9 60 08 00 mv r1,r11
800ed08: b9 00 10 00 mv r2,r8
800ed0c: fb ff e6 d6 calli 8008864 <_Thread_Set_state>
_ISR_Disable( level );
800ed10: 90 00 18 00 rcsr r3,IE
800ed14: 34 01 ff fe mvi r1,-2
800ed18: a0 61 08 00 and r1,r3,r1
800ed1c: d0 01 00 00 wcsr IE,r1
current_sync_state = *sync_state;
800ed20: 29 81 00 00 lw r1,(r12+0)
*sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( current_sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
800ed24: 34 02 00 01 mvi r2,1
_Thread_Set_state( executing, wait_state );
_ISR_Disable( level );
current_sync_state = *sync_state;
*sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
800ed28: 59 80 00 00 sw (r12+0),r0
if ( current_sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
800ed2c: 44 22 00 1b be r1,r2,800ed98 <_Event_Seize+0xfc> <== ALWAYS TAKEN
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Entering with interrupts disabled and returning with interrupts
* enabled!
*/
_Thread_blocking_operation_Cancel( current_sync_state, executing, level );
800ed30: b9 60 10 00 mv r2,r11 <== NOT EXECUTED
800ed34: f8 00 05 40 calli 8010234 <_Thread_blocking_operation_Cancel><== NOT EXECUTED
}
800ed38: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
800ed3c: 2b 8b 00 0c lw r11,(sp+12) <== NOT EXECUTED
800ed40: 2b 8c 00 08 lw r12,(sp+8) <== NOT EXECUTED
800ed44: 37 9c 00 10 addi sp,sp,16 <== NOT EXECUTED
800ed48: c3 a0 00 00 ret <== NOT EXECUTED
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
800ed4c: d0 09 00 00 wcsr IE,r9
executing->Wait.return_code = RTEMS_UNSATISFIED;
800ed50: 34 01 00 0d mvi r1,13
800ed54: 59 61 00 34 sw (r11+52),r1
*event_out = seized_events;
800ed58: 58 85 00 00 sw (r4+0),r5
*
* WARNING! Entering with interrupts disabled and returning with interrupts
* enabled!
*/
_Thread_blocking_operation_Cancel( current_sync_state, executing, level );
}
800ed5c: 2b 9d 00 04 lw ra,(sp+4)
800ed60: 2b 8b 00 0c lw r11,(sp+12)
800ed64: 2b 8c 00 08 lw r12,(sp+8)
800ed68: 37 9c 00 10 addi sp,sp,16
800ed6c: c3 a0 00 00 ret
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) );
800ed70: a4 a0 08 00 not r1,r5
800ed74: a0 27 38 00 and r7,r1,r7
pending_events = event->pending_events;
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
(seized_events == event_in || _Options_Is_any( option_set )) ) {
event->pending_events =
800ed78: 58 c7 00 00 sw (r6+0),r7
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
800ed7c: d0 09 00 00 wcsr IE,r9
*event_out = seized_events;
800ed80: 58 85 00 00 sw (r4+0),r5
*
* WARNING! Entering with interrupts disabled and returning with interrupts
* enabled!
*/
_Thread_blocking_operation_Cancel( current_sync_state, executing, level );
}
800ed84: 2b 9d 00 04 lw ra,(sp+4)
800ed88: 2b 8b 00 0c lw r11,(sp+12)
800ed8c: 2b 8c 00 08 lw r12,(sp+8)
800ed90: 37 9c 00 10 addi sp,sp,16
800ed94: c3 a0 00 00 ret
_ISR_Disable( level );
current_sync_state = *sync_state;
*sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( current_sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
_ISR_Enable( level );
800ed98: d0 03 00 00 wcsr IE,r3
*
* WARNING! Entering with interrupts disabled and returning with interrupts
* enabled!
*/
_Thread_blocking_operation_Cancel( current_sync_state, executing, level );
}
800ed9c: 2b 9d 00 04 lw ra,(sp+4)
800eda0: 2b 8b 00 0c lw r11,(sp+12)
800eda4: 2b 8c 00 08 lw r12,(sp+8)
800eda8: 37 9c 00 10 addi sp,sp,16
800edac: c3 a0 00 00 ret
*sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
800edb0: 29 62 00 08 lw r2,(r11+8)
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
800edb4: 78 01 08 00 mvhi r1,0x800
800edb8: 38 21 ef 98 ori r1,r1,0xef98
800edbc: 59 61 00 64 sw (r11+100),r1
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
800edc0: 78 01 08 01 mvhi r1,0x801
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
800edc4: 59 62 00 68 sw (r11+104),r2
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
800edc8: 59 60 00 50 sw (r11+80),r0
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
800edcc: 59 6c 00 6c sw (r11+108),r12
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
800edd0: 59 63 00 54 sw (r11+84),r3
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
800edd4: 38 21 aa 10 ori r1,r1,0xaa10
800edd8: 35 62 00 48 addi r2,r11,72
800eddc: 5b 88 00 10 sw (sp+16),r8
800ede0: fb ff e7 b9 calli 8008cc4 <_Watchdog_Insert>
800ede4: 2b 88 00 10 lw r8,(sp+16)
800ede8: e3 ff ff c7 bi 800ed04 <_Event_Seize+0x68>
0800a400 <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
800a400: 37 9c ff f4 addi sp,sp,-12
800a404: 5b 8b 00 0c sw (sp+12),r11
800a408: 5b 8c 00 08 sw (sp+8),r12
800a40c: 5b 9d 00 04 sw (sp+4),ra
rtems_event_set pending_events;
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
option_set = the_thread->Wait.option;
800a410: 28 2a 00 30 lw r10,(r1+48)
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
800a414: b8 20 58 00 mv r11,r1
rtems_event_set seized_events;
rtems_option option_set;
option_set = the_thread->Wait.option;
_ISR_Disable( level );
800a418: 90 00 08 00 rcsr r1,IE
800a41c: 34 09 ff fe mvi r9,-2
800a420: a0 29 48 00 and r9,r1,r9
800a424: d0 09 00 00 wcsr IE,r9
RTEMS_INLINE_ROUTINE void _Event_sets_Post(
rtems_event_set the_new_events,
rtems_event_set *the_event_set
)
{
*the_event_set |= the_new_events;
800a428: 28 66 00 00 lw r6,(r3+0)
_Event_sets_Post( event_in, &event->pending_events );
pending_events = event->pending_events;
event_condition = the_thread->Wait.count;
800a42c: 29 68 00 24 lw r8,(r11+36)
800a430: b8 46 10 00 or r2,r2,r6
800a434: 58 62 00 00 sw (r3+0),r2
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 );
800a438: a0 48 30 00 and r6,r2,r8
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
800a43c: 44 c0 00 32 be r6,r0,800a504 <_Event_Surrender+0x104>
/*
* 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() &&
800a440: 78 07 08 02 mvhi r7,0x802
800a444: 38 e7 0d e0 ori r7,r7,0xde0
800a448: 28 ec 00 08 lw r12,(r7+8)
800a44c: 45 80 00 03 be r12,r0,800a458 <_Event_Surrender+0x58>
800a450: 28 e7 00 10 lw r7,(r7+16)
800a454: 45 67 00 1d be r11,r7,800a4c8 <_Event_Surrender+0xc8> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
800a458: 29 64 00 10 lw r4,(r11+16)
800a45c: a0 a4 28 00 and r5,r5,r4
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
800a460: 44 a0 00 29 be r5,r0,800a504 <_Event_Surrender+0x104>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
800a464: 45 06 00 03 be r8,r6,800a470 <_Event_Surrender+0x70>
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_any (
rtems_option option_set
)
{
return (option_set & RTEMS_EVENT_ANY) ? true : false;
800a468: 21 4a 00 02 andi r10,r10,0x2
800a46c: 45 40 00 26 be r10,r0,800a504 <_Event_Surrender+0x104> <== 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) );
800a470: a4 c0 20 00 not r4,r6
event->pending_events = _Event_sets_Clear(
pending_events,
seized_events
);
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800a474: 29 65 00 28 lw r5,(r11+40)
800a478: a0 82 10 00 and r2,r4,r2
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
event->pending_events = _Event_sets_Clear(
800a47c: 58 62 00 00 sw (r3+0),r2
pending_events,
seized_events
);
the_thread->Wait.count = 0;
800a480: 59 60 00 24 sw (r11+36),r0
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800a484: 58 a6 00 00 sw (r5+0),r6
_ISR_Flash( level );
800a488: d0 01 00 00 wcsr IE,r1
800a48c: d0 09 00 00 wcsr IE,r9
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
800a490: 29 63 00 50 lw r3,(r11+80)
800a494: 34 02 00 02 mvi r2,2
800a498: 44 62 00 21 be r3,r2,800a51c <_Event_Surrender+0x11c>
_ISR_Enable( level );
800a49c: d0 01 00 00 wcsr IE,r1
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
800a4a0: 78 01 08 01 mvhi r1,0x801
800a4a4: 38 21 dc 0c ori r1,r1,0xdc0c
800a4a8: 28 22 00 00 lw r2,(r1+0)
800a4ac: b9 60 08 00 mv r1,r11
800a4b0: f8 00 02 da calli 800b018 <_Thread_Clear_state>
}
return;
}
}
_ISR_Enable( level );
}
800a4b4: 2b 9d 00 04 lw ra,(sp+4)
800a4b8: 2b 8b 00 0c lw r11,(sp+12)
800a4bc: 2b 8c 00 08 lw r12,(sp+8)
800a4c0: 37 9c 00 0c addi sp,sp,12
800a4c4: c3 a0 00 00 ret
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
800a4c8: 28 8c 00 00 lw r12,(r4+0) <== NOT EXECUTED
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
800a4cc: 34 07 00 01 mvi r7,1 <== NOT EXECUTED
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
800a4d0: 35 8c ff ff addi r12,r12,-1 <== NOT EXECUTED
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
800a4d4: 55 87 ff e1 bgu r12,r7,800a458 <_Event_Surrender+0x58> <== NOT EXECUTED
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
800a4d8: 45 06 00 03 be r8,r6,800a4e4 <_Event_Surrender+0xe4> <== NOT EXECUTED
800a4dc: 21 4a 00 02 andi r10,r10,0x2 <== NOT EXECUTED
800a4e0: 45 40 00 09 be r10,r0,800a504 <_Event_Surrender+0x104> <== NOT EXECUTED
800a4e4: a4 c0 38 00 not r7,r6 <== NOT EXECUTED
event->pending_events = _Event_sets_Clear(
pending_events,
seized_events
);
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800a4e8: 29 65 00 28 lw r5,(r11+40) <== NOT EXECUTED
800a4ec: a0 e2 10 00 and r2,r7,r2 <== NOT EXECUTED
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
event->pending_events = _Event_sets_Clear(
800a4f0: 58 62 00 00 sw (r3+0),r2 <== NOT EXECUTED
pending_events,
seized_events
);
the_thread->Wait.count = 0;
800a4f4: 59 60 00 24 sw (r11+36),r0 <== NOT EXECUTED
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800a4f8: 58 a6 00 00 sw (r5+0),r6 <== NOT EXECUTED
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
800a4fc: 34 02 00 03 mvi r2,3 <== NOT EXECUTED
800a500: 58 82 00 00 sw (r4+0),r2 <== NOT EXECUTED
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
800a504: d0 01 00 00 wcsr IE,r1
}
800a508: 2b 9d 00 04 lw ra,(sp+4)
800a50c: 2b 8b 00 0c lw r11,(sp+12)
800a510: 2b 8c 00 08 lw r12,(sp+8)
800a514: 37 9c 00 0c addi sp,sp,12
800a518: c3 a0 00 00 ret
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
800a51c: 34 02 00 03 mvi r2,3
800a520: 59 62 00 50 sw (r11+80),r2
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
800a524: d0 01 00 00 wcsr IE,r1
(void) _Watchdog_Remove( &the_thread->Timer );
800a528: 35 61 00 48 addi r1,r11,72
800a52c: fb ff f5 e9 calli 8007cd0 <_Watchdog_Remove>
800a530: 78 03 08 01 mvhi r3,0x801
800a534: 38 63 dc 0c ori r3,r3,0xdc0c
800a538: 28 62 00 00 lw r2,(r3+0)
800a53c: b9 60 08 00 mv r1,r11
800a540: f8 00 02 b6 calli 800b018 <_Thread_Clear_state>
800a544: e3 ff ff f1 bi 800a508 <_Event_Surrender+0x108>
0800ef98 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *arg
)
{
800ef98: 37 9c ff f4 addi sp,sp,-12
800ef9c: 5b 8b 00 08 sw (sp+8),r11
800efa0: 5b 9d 00 04 sw (sp+4),ra
800efa4: b8 40 58 00 mv r11,r2
ISR_Level level;
Thread_blocking_operation_States *sync_state;
sync_state = arg;
the_thread = _Thread_Get( id, &location );
800efa8: 37 82 00 0c addi r2,sp,12
800efac: fb ff e3 91 calli 8007df0 <_Thread_Get>
switch ( location ) {
800efb0: 2b 82 00 0c lw r2,(sp+12)
800efb4: 44 40 00 05 be r2,r0,800efc8 <_Event_Timeout+0x30> <== ALWAYS TAKEN
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
800efb8: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
800efbc: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
800efc0: 37 9c 00 0c addi sp,sp,12 <== NOT EXECUTED
800efc4: c3 a0 00 00 ret <== NOT EXECUTED
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
800efc8: 90 00 20 00 rcsr r4,IE
800efcc: 34 03 ff fe mvi r3,-2
800efd0: a0 83 18 00 and r3,r4,r3
800efd4: d0 03 00 00 wcsr IE,r3
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
800efd8: 78 03 08 01 mvhi r3,0x801
800efdc: 38 63 ae 00 ori r3,r3,0xae00
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
800efe0: 28 63 00 10 lw r3,(r3+16)
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
800efe4: 58 20 00 24 sw (r1+36),r0
if ( _Thread_Is_executing( the_thread ) ) {
800efe8: 44 23 00 11 be r1,r3,800f02c <_Event_Timeout+0x94> <== NEVER TAKEN
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
800efec: 34 02 00 06 mvi r2,6
800eff0: 58 22 00 34 sw (r1+52),r2
_ISR_Enable( level );
800eff4: d0 04 00 00 wcsr IE,r4
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
800eff8: 78 03 08 01 mvhi r3,0x801
800effc: 38 63 96 90 ori r3,r3,0x9690
800f000: 28 62 00 00 lw r2,(r3+0)
800f004: f8 00 04 a4 calli 8010294 <_Thread_Clear_state>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
800f008: 78 01 08 01 mvhi r1,0x801
800f00c: 38 21 a9 78 ori r1,r1,0xa978
800f010: 28 22 00 00 lw r2,(r1+0)
--level;
800f014: 34 42 ff ff addi r2,r2,-1
_Thread_Dispatch_disable_level = level;
800f018: 58 22 00 00 sw (r1+0),r2
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
800f01c: 2b 9d 00 04 lw ra,(sp+4)
800f020: 2b 8b 00 08 lw r11,(sp+8)
800f024: 37 9c 00 0c addi sp,sp,12
800f028: c3 a0 00 00 ret
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
800f02c: 29 63 00 00 lw r3,(r11+0) <== NOT EXECUTED
800f030: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
800f034: 5c 62 ff ee bne r3,r2,800efec <_Event_Timeout+0x54> <== NOT EXECUTED
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
800f038: 34 02 00 02 mvi r2,2 <== NOT EXECUTED
800f03c: 59 62 00 00 sw (r11+0),r2 <== NOT EXECUTED
800f040: e3 ff ff eb bi 800efec <_Event_Timeout+0x54> <== NOT EXECUTED
0800ab2c <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
800ab2c: 37 9c ff bc addi sp,sp,-68
800ab30: 5b 8b 00 44 sw (sp+68),r11
800ab34: 5b 8c 00 40 sw (sp+64),r12
800ab38: 5b 8d 00 3c sw (sp+60),r13
800ab3c: 5b 8e 00 38 sw (sp+56),r14
800ab40: 5b 8f 00 34 sw (sp+52),r15
800ab44: 5b 90 00 30 sw (sp+48),r16
800ab48: 5b 91 00 2c sw (sp+44),r17
800ab4c: 5b 92 00 28 sw (sp+40),r18
800ab50: 5b 93 00 24 sw (sp+36),r19
800ab54: 5b 94 00 20 sw (sp+32),r20
800ab58: 5b 95 00 1c sw (sp+28),r21
800ab5c: 5b 96 00 18 sw (sp+24),r22
800ab60: 5b 97 00 14 sw (sp+20),r23
800ab64: 5b 98 00 10 sw (sp+16),r24
800ab68: 5b 99 00 0c sw (sp+12),r25
800ab6c: 5b 9b 00 08 sw (sp+8),fp
800ab70: 5b 9d 00 04 sw (sp+4),ra
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
800ab74: 34 54 00 04 addi r20,r2,4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
800ab78: b8 20 78 00 mv r15,r1
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
800ab7c: 28 37 00 10 lw r23,(r1+16)
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
800ab80: b8 40 70 00 mv r14,r2
800ab84: b8 60 80 00 mv r16,r3
800ab88: b8 80 90 00 mv r18,r4
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
/* Integer overflow occured */
return NULL;
800ab8c: 34 01 00 00 mvi r1,0
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
800ab90: 54 54 00 5b bgu r2,r20,800acfc <_Heap_Allocate_aligned_with_boundary+0x1d0>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
800ab94: 5c 80 00 6f bne r4,r0,800ad50 <_Heap_Allocate_aligned_with_boundary+0x224>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
800ab98: 29 ec 00 08 lw r12,(r15+8)
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
800ab9c: 34 01 00 00 mvi r1,0
800aba0: 45 ec 00 57 be r15,r12,800acfc <_Heap_Allocate_aligned_with_boundary+0x1d0>
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
800aba4: 34 18 00 04 mvi r24,4
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
800aba8: 34 11 00 01 mvi r17,1
- 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;
800abac: 34 1b ff fe mvi fp,-2
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
800abb0: 36 f9 00 07 addi r25,r23,7
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
800abb4: cb 0e c0 00 sub r24,r24,r14
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
800abb8: 29 81 00 04 lw r1,(r12+4)
800abbc: 52 81 00 3b bgeu r20,r1,800aca8 <_Heap_Allocate_aligned_with_boundary+0x17c>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
800abc0: 35 8b 00 08 addi r11,r12,8
if ( alignment == 0 ) {
800abc4: 46 00 00 3e be r16,r0,800acbc <_Heap_Allocate_aligned_with_boundary+0x190>
- 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;
800abc8: a0 3b 68 00 and r13,r1,fp
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
800abcc: 29 f5 00 14 lw r21,(r15+20)
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
800abd0: b5 8d 68 00 add r13,r12,r13
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
800abd4: b7 0d 58 00 add r11,r24,r13
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
800abd8: cb 35 18 00 sub r3,r25,r21
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800abdc: b9 60 08 00 mv r1,r11
800abe0: ba 00 10 00 mv r2,r16
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
800abe4: b4 6d 68 00 add r13,r3,r13
800abe8: f8 00 45 18 calli 801c048 <__umodsi3>
800abec: c9 61 58 00 sub r11,r11,r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
800abf0: 35 96 00 08 addi r22,r12,8
uintptr_t alloc_begin = alloc_end - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
800abf4: 51 ab 00 05 bgeu r13,r11,800ac08 <_Heap_Allocate_aligned_with_boundary+0xdc>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800abf8: b9 a0 08 00 mv r1,r13
800abfc: ba 00 10 00 mv r2,r16
800ac00: f8 00 45 12 calli 801c048 <__umodsi3>
800ac04: c9 a1 58 00 sub r11,r13,r1
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
800ac08: 46 40 00 1c be r18,r0,800ac78 <_Heap_Allocate_aligned_with_boundary+0x14c>
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
800ac0c: b5 6e 68 00 add r13,r11,r14
800ac10: b9 a0 08 00 mv r1,r13
800ac14: ba 40 10 00 mv r2,r18
800ac18: f8 00 45 0c calli 801c048 <__umodsi3>
800ac1c: c9 a1 28 00 sub r5,r13,r1
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
800ac20: f5 a5 68 00 cmpgu r13,r13,r5
800ac24: f4 ab 08 00 cmpgu r1,r5,r11
800ac28: a1 a1 68 00 and r13,r13,r1
800ac2c: 45 a0 00 13 be r13,r0,800ac78 <_Heap_Allocate_aligned_with_boundary+0x14c>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
800ac30: b6 ce 98 00 add r19,r22,r14
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
800ac34: 56 65 00 1d bgu r19,r5,800aca8 <_Heap_Allocate_aligned_with_boundary+0x17c>
800ac38: e0 00 00 02 bi 800ac40 <_Heap_Allocate_aligned_with_boundary+0x114>
800ac3c: 56 65 00 1b bgu r19,r5,800aca8 <_Heap_Allocate_aligned_with_boundary+0x17c><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
800ac40: c8 ae 58 00 sub r11,r5,r14
800ac44: ba 00 10 00 mv r2,r16
800ac48: b9 60 08 00 mv r1,r11
800ac4c: f8 00 44 ff calli 801c048 <__umodsi3>
800ac50: c9 61 58 00 sub r11,r11,r1
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
800ac54: b5 6e 68 00 add r13,r11,r14
800ac58: b9 a0 08 00 mv r1,r13
800ac5c: ba 40 10 00 mv r2,r18
800ac60: f8 00 44 fa calli 801c048 <__umodsi3>
800ac64: c9 a1 28 00 sub r5,r13,r1
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
800ac68: f5 a5 68 00 cmpgu r13,r13,r5
800ac6c: f4 ab 08 00 cmpgu r1,r5,r11
800ac70: a1 a1 68 00 and r13,r13,r1
800ac74: 5d a0 ff f2 bne r13,r0,800ac3c <_Heap_Allocate_aligned_with_boundary+0x110>
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
800ac78: 56 cb 00 0c bgu r22,r11,800aca8 <_Heap_Allocate_aligned_with_boundary+0x17c>
800ac7c: 34 01 ff f8 mvi r1,-8
800ac80: c8 2c 68 00 sub r13,r1,r12
800ac84: ba e0 10 00 mv r2,r23
800ac88: b9 60 08 00 mv r1,r11
800ac8c: f8 00 44 ef calli 801c048 <__umodsi3>
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
800ac90: b5 ab 68 00 add r13,r13,r11
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
800ac94: c9 a1 08 00 sub r1,r13,r1
if ( free_size >= min_block_size || free_size == 0 ) {
800ac98: 64 22 00 00 cmpei r2,r1,0
800ac9c: f0 35 a8 00 cmpgeu r21,r1,r21
800aca0: b8 55 08 00 or r1,r2,r21
800aca4: 5c 20 00 06 bne r1,r0,800acbc <_Heap_Allocate_aligned_with_boundary+0x190>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
800aca8: 29 8c 00 08 lw r12,(r12+8)
800acac: 36 21 00 01 addi r1,r17,1
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
800acb0: 45 ec 00 26 be r15,r12,800ad48 <_Heap_Allocate_aligned_with_boundary+0x21c>
800acb4: b8 20 88 00 mv r17,r1
800acb8: e3 ff ff c0 bi 800abb8 <_Heap_Allocate_aligned_with_boundary+0x8c>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
800acbc: 45 60 ff fb be r11,r0,800aca8 <_Heap_Allocate_aligned_with_boundary+0x17c><== NEVER TAKEN
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
800acc0: 29 e3 00 48 lw r3,(r15+72)
stats->searches += search_count;
800acc4: 29 e2 00 4c lw r2,(r15+76)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
800acc8: b9 e0 08 00 mv r1,r15
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
800accc: 34 63 00 01 addi r3,r3,1
stats->searches += search_count;
800acd0: b4 51 10 00 add r2,r2,r17
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
800acd4: 59 e3 00 48 sw (r15+72),r3
stats->searches += search_count;
800acd8: 59 e2 00 4c sw (r15+76),r2
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
800acdc: b9 60 18 00 mv r3,r11
800ace0: b9 80 10 00 mv r2,r12
800ace4: b9 c0 20 00 mv r4,r14
800ace8: fb ff e9 91 calli 800532c <_Heap_Block_allocate>
800acec: b9 60 08 00 mv r1,r11
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
800acf0: 29 e2 00 44 lw r2,(r15+68)
800acf4: 50 51 00 02 bgeu r2,r17,800acfc <_Heap_Allocate_aligned_with_boundary+0x1d0>
stats->max_search = search_count;
800acf8: 59 f1 00 44 sw (r15+68),r17
}
return (void *) alloc_begin;
}
800acfc: 2b 9d 00 04 lw ra,(sp+4)
800ad00: 2b 8b 00 44 lw r11,(sp+68)
800ad04: 2b 8c 00 40 lw r12,(sp+64)
800ad08: 2b 8d 00 3c lw r13,(sp+60)
800ad0c: 2b 8e 00 38 lw r14,(sp+56)
800ad10: 2b 8f 00 34 lw r15,(sp+52)
800ad14: 2b 90 00 30 lw r16,(sp+48)
800ad18: 2b 91 00 2c lw r17,(sp+44)
800ad1c: 2b 92 00 28 lw r18,(sp+40)
800ad20: 2b 93 00 24 lw r19,(sp+36)
800ad24: 2b 94 00 20 lw r20,(sp+32)
800ad28: 2b 95 00 1c lw r21,(sp+28)
800ad2c: 2b 96 00 18 lw r22,(sp+24)
800ad30: 2b 97 00 14 lw r23,(sp+20)
800ad34: 2b 98 00 10 lw r24,(sp+16)
800ad38: 2b 99 00 0c lw r25,(sp+12)
800ad3c: 2b 9b 00 08 lw fp,(sp+8)
800ad40: 37 9c 00 44 addi sp,sp,68
800ad44: c3 a0 00 00 ret
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
800ad48: 34 01 00 00 mvi r1,0
800ad4c: e3 ff ff e9 bi 800acf0 <_Heap_Allocate_aligned_with_boundary+0x1c4>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
800ad50: 54 44 ff eb bgu r2,r4,800acfc <_Heap_Allocate_aligned_with_boundary+0x1d0>
return NULL;
}
if ( alignment == 0 ) {
800ad54: 5c 60 ff 91 bne r3,r0,800ab98 <_Heap_Allocate_aligned_with_boundary+0x6c>
alignment = page_size;
800ad58: ba e0 80 00 mv r16,r23
800ad5c: e3 ff ff 8f bi 800ab98 <_Heap_Allocate_aligned_with_boundary+0x6c>
0800a7e0 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
800a7e0: 37 9c ff bc addi sp,sp,-68
800a7e4: 5b 8b 00 3c sw (sp+60),r11
800a7e8: 5b 8c 00 38 sw (sp+56),r12
800a7ec: 5b 8d 00 34 sw (sp+52),r13
800a7f0: 5b 8e 00 30 sw (sp+48),r14
800a7f4: 5b 8f 00 2c sw (sp+44),r15
800a7f8: 5b 90 00 28 sw (sp+40),r16
800a7fc: 5b 91 00 24 sw (sp+36),r17
800a800: 5b 92 00 20 sw (sp+32),r18
800a804: 5b 93 00 1c sw (sp+28),r19
800a808: 5b 94 00 18 sw (sp+24),r20
800a80c: 5b 95 00 14 sw (sp+20),r21
800a810: 5b 96 00 10 sw (sp+16),r22
800a814: 5b 97 00 0c sw (sp+12),r23
800a818: 5b 98 00 08 sw (sp+8),r24
800a81c: 5b 9d 00 04 sw (sp+4),ra
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;
800a820: 5b 80 00 44 sw (sp+68),r0
Heap_Block *extend_last_block = NULL;
800a824: 5b 80 00 40 sw (sp+64),r0
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;
800a828: b4 43 70 00 add r14,r2,r3
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
800a82c: b8 40 68 00 mv r13,r2
800a830: b8 20 58 00 mv r11,r1
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
800a834: 28 30 00 20 lw r16,(r1+32)
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;
800a838: 28 32 00 10 lw r18,(r1+16)
uintptr_t const min_block_size = heap->min_block_size;
800a83c: 28 24 00 14 lw r4,(r1+20)
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;
800a840: 28 37 00 30 lw r23,(r1+48)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
return 0;
800a844: 34 0c 00 00 mvi r12,0
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
800a848: 54 4e 00 72 bgu r2,r14,800aa10 <_Heap_Extend+0x230>
return 0;
}
extend_area_ok = _Heap_Get_first_and_last_block(
800a84c: b8 40 08 00 mv r1,r2
800a850: 37 85 00 44 addi r5,sp,68
800a854: b8 60 10 00 mv r2,r3
800a858: 37 86 00 40 addi r6,sp,64
800a85c: ba 40 18 00 mv r3,r18
800a860: fb ff e9 3c calli 8004d50 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
800a864: 44 20 00 6b be r1,r0,800aa10 <_Heap_Extend+0x230>
800a868: ba 00 60 00 mv r12,r16
800a86c: 34 16 00 00 mvi r22,0
800a870: 34 18 00 00 mvi r24,0
800a874: 34 11 00 00 mvi r17,0
800a878: 34 14 00 00 mvi r20,0
- 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;
800a87c: 34 15 ff fe mvi r21,-2
800a880: e0 00 00 0d bi 800a8b4 <_Heap_Extend+0xd4>
return 0;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
800a884: 55 ee 00 77 bgu r15,r14,800aa60 <_Heap_Extend+0x280>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a888: b9 e0 08 00 mv r1,r15
800a88c: ba 40 10 00 mv r2,r18
800a890: 35 f3 ff f8 addi r19,r15,-8
800a894: f8 00 22 23 calli 8013120 <__umodsi3>
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
800a898: ca 61 08 00 sub r1,r19,r1
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
800a89c: 45 af 00 15 be r13,r15,800a8f0 <_Heap_Extend+0x110>
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
800a8a0: 55 af 00 6e bgu r13,r15,800aa58 <_Heap_Extend+0x278>
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
800a8a4: 28 2c 00 04 lw r12,(r1+4)
800a8a8: a2 ac 60 00 and r12,r21,r12
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
800a8ac: b4 2c 60 00 add r12,r1,r12
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
800a8b0: 46 0c 00 16 be r16,r12,800a908 <_Heap_Extend+0x128>
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
800a8b4: b9 80 08 00 mv r1,r12
800a8b8: 45 90 00 6c be r12,r16,800aa68 <_Heap_Extend+0x288>
uintptr_t const sub_area_end = start_block->prev_size;
800a8bc: 29 8f 00 00 lw r15,(r12+0)
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
800a8c0: f5 c1 28 00 cmpgu r5,r14,r1
800a8c4: f5 ed 20 00 cmpgu r4,r15,r13
(uintptr_t) start_block : heap->area_begin;
uintptr_t const sub_area_end = start_block->prev_size;
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
800a8c8: a0 a4 20 00 and r4,r5,r4
800a8cc: 5c 80 00 71 bne r4,r0,800aa90 <_Heap_Extend+0x2b0>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return 0;
}
if ( extend_area_end == sub_area_begin ) {
800a8d0: 5c 2e ff ed bne r1,r14,800a884 <_Heap_Extend+0xa4>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a8d4: b9 e0 08 00 mv r1,r15
800a8d8: ba 40 10 00 mv r2,r18
800a8dc: 35 f3 ff f8 addi r19,r15,-8
800a8e0: f8 00 22 10 calli 8013120 <__umodsi3>
800a8e4: b9 80 a0 00 mv r20,r12
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
800a8e8: ca 61 08 00 sub r1,r19,r1
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
800a8ec: 5d af ff ed bne r13,r15,800a8a0 <_Heap_Extend+0xc0> <== ALWAYS TAKEN
start_block->prev_size = extend_area_end;
800a8f0: 59 8e 00 00 sw (r12+0),r14
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
800a8f4: 28 2c 00 04 lw r12,(r1+4)
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 )
800a8f8: b8 20 88 00 mv r17,r1
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
800a8fc: a2 ac 60 00 and r12,r21,r12
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
800a900: b4 2c 60 00 add r12,r1,r12
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
800a904: 5e 0c ff ec bne r16,r12,800a8b4 <_Heap_Extend+0xd4> <== NEVER TAKEN
if ( extend_area_begin < heap->area_begin ) {
800a908: 29 61 00 18 lw r1,(r11+24)
800a90c: 51 a1 00 5d bgeu r13,r1,800aa80 <_Heap_Extend+0x2a0>
heap->area_begin = extend_area_begin;
800a910: 59 6d 00 18 sw (r11+24),r13
} 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;
800a914: 2b 81 00 40 lw r1,(sp+64)
800a918: 2b 82 00 44 lw r2,(sp+68)
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
800a91c: 29 65 00 20 lw r5,(r11+32)
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
800a920: c8 22 18 00 sub r3,r1,r2
(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;
800a924: 38 64 00 01 ori r4,r3,0x1
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
800a928: 58 4e 00 00 sw (r2+0),r14
extend_first_block->size_and_flag =
800a92c: 58 44 00 04 sw (r2+4),r4
extend_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
800a930: 58 23 00 00 sw (r1+0),r3
extend_last_block->size_and_flag = 0;
800a934: 58 20 00 04 sw (r1+4),r0
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
800a938: 50 45 00 4e bgeu r2,r5,800aa70 <_Heap_Extend+0x290>
heap->first_block = extend_first_block;
800a93c: 59 62 00 20 sw (r11+32),r2
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
800a940: 46 80 00 66 be r20,r0,800aad8 <_Heap_Extend+0x2f8>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
800a944: 29 6c 00 10 lw r12,(r11+16)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
800a948: 35 ad 00 08 addi r13,r13,8
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
800a94c: b9 a0 08 00 mv r1,r13
800a950: b9 80 10 00 mv r2,r12
800a954: f8 00 21 f3 calli 8013120 <__umodsi3>
if ( remainder != 0 ) {
800a958: 44 20 00 03 be r1,r0,800a964 <_Heap_Extend+0x184>
return value - remainder + alignment;
800a95c: b5 ac 68 00 add r13,r13,r12
800a960: c9 a1 68 00 sub r13,r13,r1
uintptr_t const new_first_block_begin =
800a964: 35 a2 ff f8 addi r2,r13,-8
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;
800a968: 2a 83 00 00 lw r3,(r20+0)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
800a96c: ca 82 08 00 sub r1,r20,r2
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;
800a970: 38 21 00 01 ori r1,r1,0x1
800a974: 58 41 00 04 sw (r2+4),r1
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;
800a978: 59 a3 ff f8 sw (r13+-8),r3
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Free_block( heap, new_first_block );
800a97c: b9 60 08 00 mv r1,r11
800a980: fb ff ff 7e calli 800a778 <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
800a984: 46 20 00 45 be r17,r0,800aa98 <_Heap_Extend+0x2b8>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a988: 29 62 00 10 lw r2,(r11+16)
)
{
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,
800a98c: 35 ce ff f8 addi r14,r14,-8
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(
800a990: c9 d1 70 00 sub r14,r14,r17
800a994: b9 c0 08 00 mv r1,r14
800a998: f8 00 21 e2 calli 8013120 <__umodsi3>
);
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)
800a99c: 2a 22 00 04 lw r2,(r17+4)
800a9a0: c9 c1 70 00 sub r14,r14,r1
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
800a9a4: b5 d1 08 00 add r1,r14,r17
(last_block->size_and_flag - last_block_new_size)
800a9a8: c8 4e 10 00 sub r2,r2,r14
| HEAP_PREV_BLOCK_USED;
800a9ac: 38 42 00 01 ori r2,r2,0x1
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
800a9b0: 58 22 00 04 sw (r1+4),r2
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;
800a9b4: 2a 23 00 04 lw r3,(r17+4)
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
800a9b8: b9 60 08 00 mv r1,r11
800a9bc: ba 20 10 00 mv r2,r17
800a9c0: 20 63 00 01 andi r3,r3,0x1
block->size_and_flag = size | flag;
800a9c4: b9 c3 70 00 or r14,r14,r3
800a9c8: 5a 2e 00 04 sw (r17+4),r14
800a9cc: fb ff ff 6b calli 800a778 <_Heap_Free_block>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
800a9d0: 66 31 00 00 cmpei r17,r17,0
800a9d4: 66 94 00 00 cmpei r20,r20,0
800a9d8: a2 34 88 00 and r17,r17,r20
800a9dc: 5e 20 00 3b bne r17,r0,800aac8 <_Heap_Extend+0x2e8>
/* Statistics */
stats->size += extended_size;
return extended_size;
}
800a9e0: 29 61 00 24 lw r1,(r11+36)
* 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(
800a9e4: 29 63 00 20 lw r3,(r11+32)
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
800a9e8: 29 6c 00 30 lw r12,(r11+48)
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;
800a9ec: 28 22 00 04 lw r2,(r1+4)
/* Statistics */
stats->size += extended_size;
800a9f0: 29 64 00 2c lw r4,(r11+44)
* 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(
800a9f4: c8 61 18 00 sub r3,r3,r1
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;
800a9f8: 20 42 00 01 andi r2,r2,0x1
block->size_and_flag = size | flag;
800a9fc: b8 62 10 00 or r2,r3,r2
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
800aa00: c9 97 60 00 sub r12,r12,r23
800aa04: 58 22 00 04 sw (r1+4),r2
/* Statistics */
stats->size += extended_size;
800aa08: b4 8c 08 00 add r1,r4,r12
800aa0c: 59 61 00 2c sw (r11+44),r1
return extended_size;
}
800aa10: b9 80 08 00 mv r1,r12
800aa14: 2b 9d 00 04 lw ra,(sp+4)
800aa18: 2b 8b 00 3c lw r11,(sp+60)
800aa1c: 2b 8c 00 38 lw r12,(sp+56)
800aa20: 2b 8d 00 34 lw r13,(sp+52)
800aa24: 2b 8e 00 30 lw r14,(sp+48)
800aa28: 2b 8f 00 2c lw r15,(sp+44)
800aa2c: 2b 90 00 28 lw r16,(sp+40)
800aa30: 2b 91 00 24 lw r17,(sp+36)
800aa34: 2b 92 00 20 lw r18,(sp+32)
800aa38: 2b 93 00 1c lw r19,(sp+28)
800aa3c: 2b 94 00 18 lw r20,(sp+24)
800aa40: 2b 95 00 14 lw r21,(sp+20)
800aa44: 2b 96 00 10 lw r22,(sp+16)
800aa48: 2b 97 00 0c lw r23,(sp+12)
800aa4c: 2b 98 00 08 lw r24,(sp+8)
800aa50: 37 9c 00 44 addi sp,sp,68
800aa54: c3 a0 00 00 ret
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 )
800aa58: b8 20 b0 00 mv r22,r1
800aa5c: e3 ff ff 92 bi 800a8a4 <_Heap_Extend+0xc4>
return 0;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
800aa60: b9 80 c0 00 mv r24,r12
800aa64: e3 ff ff 89 bi 800a888 <_Heap_Extend+0xa8>
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
800aa68: 29 61 00 18 lw r1,(r11+24)
800aa6c: e3 ff ff 94 bi 800a8bc <_Heap_Extend+0xdc>
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
800aa70: 29 62 00 24 lw r2,(r11+36)
800aa74: 50 41 ff b3 bgeu r2,r1,800a940 <_Heap_Extend+0x160>
heap->last_block = extend_last_block;
800aa78: 59 61 00 24 sw (r11+36),r1
800aa7c: e3 ff ff b1 bi 800a940 <_Heap_Extend+0x160>
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
800aa80: 29 61 00 1c lw r1,(r11+28)
800aa84: 50 2e ff a4 bgeu r1,r14,800a914 <_Heap_Extend+0x134> <== NEVER TAKEN
heap->area_end = extend_area_end;
800aa88: 59 6e 00 1c sw (r11+28),r14
800aa8c: e3 ff ff a2 bi 800a914 <_Heap_Extend+0x134>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return 0;
800aa90: 34 0c 00 00 mvi r12,0
800aa94: e3 ff ff df bi 800aa10 <_Heap_Extend+0x230>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
800aa98: 46 d1 ff ce be r22,r17,800a9d0 <_Heap_Extend+0x1f0>
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;
800aa9c: 2a c3 00 04 lw r3,(r22+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 );
800aaa0: 2b 82 00 44 lw r2,(sp+68)
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
800aaa4: 2b 81 00 40 lw r1,(sp+64)
800aaa8: 20 63 00 01 andi r3,r3,0x1
)
{
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 );
800aaac: c8 56 10 00 sub r2,r2,r22
block->size_and_flag = size | flag;
800aab0: b8 43 10 00 or r2,r2,r3
800aab4: 5a c2 00 04 sw (r22+4),r2
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
800aab8: 28 22 00 04 lw r2,(r1+4)
800aabc: 38 42 00 01 ori r2,r2,0x1
800aac0: 58 22 00 04 sw (r1+4),r2
800aac4: e3 ff ff c3 bi 800a9d0 <_Heap_Extend+0x1f0>
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
_Heap_Free_block( heap, extend_first_block );
800aac8: 2b 82 00 44 lw r2,(sp+68)
800aacc: b9 60 08 00 mv r1,r11
800aad0: fb ff ff 2a calli 800a778 <_Heap_Free_block>
800aad4: e3 ff ff c3 bi 800a9e0 <_Heap_Extend+0x200>
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 ) {
800aad8: 47 14 ff ab be r24,r20,800a984 <_Heap_Extend+0x1a4>
{
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;
800aadc: cb 01 c0 00 sub r24,r24,r1
800aae0: 3b 18 00 01 ori r24,r24,0x1
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
800aae4: 58 38 00 04 sw (r1+4),r24
800aae8: e3 ff ff a7 bi 800a984 <_Heap_Extend+0x1a4>
0800ad60 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
800ad60: 37 9c ff f4 addi sp,sp,-12
800ad64: 5b 8b 00 0c sw (sp+12),r11
800ad68: 5b 8c 00 08 sw (sp+8),r12
800ad6c: 5b 9d 00 04 sw (sp+4),ra
800ad70: b8 20 58 00 mv r11,r1
800ad74: b8 40 18 00 mv r3,r2
* 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;
800ad78: 34 01 00 01 mvi r1,1
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
800ad7c: 44 40 00 4b be r2,r0,800aea8 <_Heap_Free+0x148>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800ad80: 29 62 00 10 lw r2,(r11+16)
800ad84: b8 60 08 00 mv r1,r3
800ad88: 34 6c ff f8 addi r12,r3,-8
800ad8c: f8 00 44 af calli 801c048 <__umodsi3>
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
800ad90: 29 64 00 20 lw r4,(r11+32)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
800ad94: c9 81 10 00 sub r2,r12,r1
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 ) ) {
return false;
800ad98: 34 01 00 00 mvi r1,0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
800ad9c: 54 82 00 43 bgu r4,r2,800aea8 <_Heap_Free+0x148>
800ada0: 29 65 00 24 lw r5,(r11+36)
800ada4: 54 45 00 41 bgu r2,r5,800aea8 <_Heap_Free+0x148>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800ada8: 28 48 00 04 lw r8,(r2+4)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
800adac: 34 07 ff fe mvi r7,-2
800adb0: a1 07 30 00 and r6,r8,r7
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
800adb4: b4 46 18 00 add r3,r2,r6
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
800adb8: 54 83 00 3c bgu r4,r3,800aea8 <_Heap_Free+0x148> <== NEVER TAKEN
800adbc: 54 65 00 3b bgu r3,r5,800aea8 <_Heap_Free+0x148> <== NEVER TAKEN
800adc0: 28 69 00 04 lw r9,(r3+4)
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;
800adc4: 21 2a 00 01 andi r10,r9,0x1
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
800adc8: 45 40 00 38 be r10,r0,800aea8 <_Heap_Free+0x148>
- 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;
800adcc: a1 27 48 00 and r9,r9,r7
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 ));
800add0: 34 07 00 00 mvi r7,0
800add4: 44 a3 00 05 be r5,r3,800ade8 <_Heap_Free+0x88>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800add8: b4 69 08 00 add r1,r3,r9
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;
800addc: 28 27 00 04 lw r7,(r1+4)
800ade0: 20 e7 00 01 andi r7,r7,0x1
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
800ade4: 18 e7 00 01 xori r7,r7,0x1
800ade8: 21 08 00 01 andi r8,r8,0x1
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
800adec: 5d 00 00 19 bne r8,r0,800ae50 <_Heap_Free+0xf0>
uintptr_t const prev_size = block->prev_size;
800adf0: 28 4a 00 00 lw r10,(r2+0)
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
_HAssert( false );
return( false );
800adf4: 34 01 00 00 mvi r1,0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
800adf8: c8 4a 10 00 sub r2,r2,r10
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;
800adfc: 54 82 00 2b bgu r4,r2,800aea8 <_Heap_Free+0x148> <== NEVER TAKEN
800ae00: b9 00 08 00 mv r1,r8
800ae04: 54 45 00 29 bgu r2,r5,800aea8 <_Heap_Free+0x148> <== 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;
800ae08: 28 44 00 04 lw r4,(r2+4)
800ae0c: 20 84 00 01 andi r4,r4,0x1
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
800ae10: 44 80 00 26 be r4,r0,800aea8 <_Heap_Free+0x148> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
800ae14: 44 e0 00 3d be r7,r0,800af08 <_Heap_Free+0x1a8>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
800ae18: 29 64 00 38 lw r4,(r11+56)
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800ae1c: 28 61 00 08 lw r1,(r3+8)
800ae20: 28 63 00 0c lw r3,(r3+12)
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
800ae24: b4 c9 48 00 add r9,r6,r9
800ae28: b5 2a 50 00 add r10,r9,r10
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
800ae2c: 58 61 00 08 sw (r3+8),r1
next->prev = prev;
800ae30: 58 23 00 0c sw (r1+12),r3
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
800ae34: 34 81 ff ff addi r1,r4,-1
800ae38: 59 61 00 38 sw (r11+56),r1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
800ae3c: 39 43 00 01 ori r3,r10,0x1
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
800ae40: b4 4a 08 00 add r1,r2,r10
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;
800ae44: 58 43 00 04 sw (r2+4),r3
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
800ae48: 58 2a 00 00 sw (r1+0),r10
800ae4c: e0 00 00 0d bi 800ae80 <_Heap_Free+0x120>
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
800ae50: 44 e0 00 1b be r7,r0,800aebc <_Heap_Free+0x15c>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800ae54: 28 64 00 08 lw r4,(r3+8)
800ae58: 28 61 00 0c lw r1,(r3+12)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
800ae5c: b5 26 48 00 add r9,r9,r6
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
800ae60: 58 44 00 08 sw (r2+8),r4
new_block->prev = prev;
800ae64: 58 41 00 0c sw (r2+12),r1
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
800ae68: 39 25 00 01 ori r5,r9,0x1
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
800ae6c: b4 49 18 00 add r3,r2,r9
next->prev = new_block;
800ae70: 58 82 00 0c sw (r4+12),r2
prev->next = new_block;
800ae74: 58 22 00 08 sw (r1+8),r2
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;
800ae78: 58 45 00 04 sw (r2+4),r5
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
800ae7c: 58 69 00 00 sw (r3+0),r9
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
800ae80: 29 62 00 40 lw r2,(r11+64)
++stats->frees;
800ae84: 29 61 00 50 lw r1,(r11+80)
stats->free_size += block_size;
800ae88: 29 63 00 30 lw r3,(r11+48)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
800ae8c: 34 42 ff ff addi r2,r2,-1
++stats->frees;
800ae90: 34 21 00 01 addi r1,r1,1
stats->free_size += block_size;
800ae94: b4 66 30 00 add r6,r3,r6
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
800ae98: 59 61 00 50 sw (r11+80),r1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
800ae9c: 59 62 00 40 sw (r11+64),r2
++stats->frees;
stats->free_size += block_size;
800aea0: 59 66 00 30 sw (r11+48),r6
return( true );
800aea4: 34 01 00 01 mvi r1,1
}
800aea8: 2b 9d 00 04 lw ra,(sp+4)
800aeac: 2b 8b 00 0c lw r11,(sp+12)
800aeb0: 2b 8c 00 08 lw r12,(sp+8)
800aeb4: 37 9c 00 0c addi sp,sp,12
800aeb8: c3 a0 00 00 ret
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;
800aebc: 38 c1 00 01 ori r1,r6,0x1
800aec0: 58 41 00 04 sw (r2+4),r1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
800aec4: 28 67 00 04 lw r7,(r3+4)
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
800aec8: 29 61 00 38 lw r1,(r11+56)
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
800aecc: 29 64 00 08 lw r4,(r11+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;
800aed0: 34 05 ff fe mvi r5,-2
new_block->next = next;
new_block->prev = block_before;
800aed4: 58 4b 00 0c sw (r2+12),r11
800aed8: a0 e5 28 00 and r5,r7,r5
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
800aedc: 29 67 00 3c lw r7,(r11+60)
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
800aee0: 34 21 00 01 addi r1,r1,1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
800aee4: 58 44 00 08 sw (r2+8),r4
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
800aee8: 58 82 00 0c sw (r4+12),r2
} 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;
800aeec: 58 65 00 04 sw (r3+4),r5
next_block->prev_size = block_size;
800aef0: 58 66 00 00 sw (r3+0),r6
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
800aef4: 59 62 00 08 sw (r11+8),r2
/* Statistics */
++stats->free_blocks;
800aef8: 59 61 00 38 sw (r11+56),r1
if ( stats->max_free_blocks < stats->free_blocks ) {
800aefc: 50 e1 ff e1 bgeu r7,r1,800ae80 <_Heap_Free+0x120>
stats->max_free_blocks = stats->free_blocks;
800af00: 59 61 00 3c sw (r11+60),r1
800af04: e3 ff ff df bi 800ae80 <_Heap_Free+0x120>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
800af08: b4 ca 50 00 add r10,r6,r10
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
800af0c: 39 41 00 01 ori r1,r10,0x1
800af10: 58 41 00 04 sw (r2+4),r1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
800af14: 28 62 00 04 lw r2,(r3+4)
800af18: 34 01 ff fe mvi r1,-2
next_block->prev_size = size;
800af1c: 58 6a 00 00 sw (r3+0),r10
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
800af20: a0 41 08 00 and r1,r2,r1
800af24: 58 61 00 04 sw (r3+4),r1
800af28: e3 ff ff d6 bi 800ae80 <_Heap_Free+0x120>
080111cc <_Heap_Get_free_information>:
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
80111cc: 28 23 00 08 lw r3,(r1+8)
)
{
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
80111d0: 58 40 00 00 sw (r2+0),r0
info->largest = 0;
80111d4: 58 40 00 04 sw (r2+4),r0
info->total = 0;
80111d8: 58 40 00 08 sw (r2+8),r0
for(the_block = _Heap_Free_list_first(the_heap);
80111dc: 44 23 00 12 be r1,r3,8011224 <_Heap_Get_free_information+0x58><== NEVER TAKEN
80111e0: 34 06 00 01 mvi r6,1
80111e4: 34 07 00 00 mvi r7,0
80111e8: 34 05 00 00 mvi r5,0
- 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;
80111ec: 34 09 ff fe mvi r9,-2
80111f0: e0 00 00 03 bi 80111fc <_Heap_Get_free_information+0x30>
80111f4: 28 47 00 04 lw r7,(r2+4)
80111f8: b9 00 30 00 mv r6,r8
80111fc: 28 64 00 04 lw r4,(r3+4)
the_block != tail;
the_block = the_block->next)
8011200: 34 c8 00 01 addi r8,r6,1
8011204: a1 24 20 00 and r4,r9,r4
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
info->total += the_size;
8011208: b4 a4 28 00 add r5,r5,r4
if ( info->largest < the_size )
801120c: 50 e4 00 02 bgeu r7,r4,8011214 <_Heap_Get_free_information+0x48>
info->largest = the_size;
8011210: 58 44 00 04 sw (r2+4),r4
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
the_block != tail;
the_block = the_block->next)
8011214: 28 63 00 08 lw r3,(r3+8)
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
8011218: 5c 23 ff f7 bne r1,r3,80111f4 <_Heap_Get_free_information+0x28>
801121c: 58 46 00 00 sw (r2+0),r6
8011220: 58 45 00 08 sw (r2+8),r5
8011224: c3 a0 00 00 ret
08007228 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
8007228: 37 9c ff e4 addi sp,sp,-28
800722c: 5b 8b 00 1c sw (sp+28),r11
8007230: 5b 8c 00 18 sw (sp+24),r12
8007234: 5b 8d 00 14 sw (sp+20),r13
8007238: 5b 8e 00 10 sw (sp+16),r14
800723c: 5b 8f 00 0c sw (sp+12),r15
8007240: 5b 90 00 08 sw (sp+8),r16
8007244: 5b 9d 00 04 sw (sp+4),ra
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *allocated_blocks = NULL;
8007248: 34 0d 00 00 mvi r13,0
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
800724c: b8 60 80 00 mv r16,r3
8007250: b8 20 60 00 mv r12,r1
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
8007254: 44 60 00 12 be r3,r0,800729c <_Heap_Greedy_allocate+0x74>
8007258: b8 40 70 00 mv r14,r2
800725c: 34 0b 00 00 mvi r11,0
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
8007260: 29 c2 00 00 lw r2,(r14+0)
8007264: 34 03 00 00 mvi r3,0
8007268: 34 04 00 00 mvi r4,0
800726c: b9 80 08 00 mv r1,r12
8007270: f8 00 24 5e calli 80103e8 <_Heap_Allocate_aligned_with_boundary>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
8007274: 34 2f ff f8 addi r15,r1,-8
8007278: 35 6b 00 01 addi r11,r11,1
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
800727c: 44 20 00 06 be r1,r0,8007294 <_Heap_Greedy_allocate+0x6c> <== NEVER TAKEN
8007280: 29 82 00 10 lw r2,(r12+16)
8007284: f8 00 47 74 calli 8019054 <__umodsi3>
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
8007288: c9 e1 08 00 sub r1,r15,r1
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
800728c: 58 2d 00 08 sw (r1+8),r13
8007290: b8 20 68 00 mv r13,r1
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
8007294: 35 ce 00 04 addi r14,r14,4
8007298: 56 0b ff f2 bgu r16,r11,8007260 <_Heap_Greedy_allocate+0x38>
Heap_Block *current = blocks;
blocks = blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
}
800729c: 29 8b 00 08 lw r11,(r12+8)
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
80072a0: 34 0e 00 00 mvi r14,0
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
80072a4: 34 0f ff fe mvi r15,-2
80072a8: 5d 8b 00 03 bne r12,r11,80072b4 <_Heap_Greedy_allocate+0x8c><== ALWAYS TAKEN
80072ac: e0 00 00 0d bi 80072e0 <_Heap_Greedy_allocate+0xb8> <== NOT EXECUTED
Heap_Block *current = blocks;
blocks = blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
}
80072b0: b8 20 58 00 mv r11,r1
80072b4: 29 64 00 04 lw r4,(r11+4)
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
_Heap_Block_allocate(
80072b8: b9 60 10 00 mv r2,r11
80072bc: 35 63 00 08 addi r3,r11,8
80072c0: a1 e4 20 00 and r4,r15,r4
80072c4: b9 80 08 00 mv r1,r12
80072c8: 34 84 ff f8 addi r4,r4,-8
80072cc: f8 00 01 0b calli 80076f8 <_Heap_Block_allocate>
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
80072d0: 59 6e 00 08 sw (r11+8),r14
Heap_Block *current = blocks;
blocks = blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
}
80072d4: 29 81 00 08 lw r1,(r12+8)
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
80072d8: b9 60 70 00 mv r14,r11
80072dc: 5d 81 ff f5 bne r12,r1,80072b0 <_Heap_Greedy_allocate+0x88>
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
80072e0: 5d a0 00 03 bne r13,r0,80072ec <_Heap_Greedy_allocate+0xc4>
80072e4: e0 00 00 07 bi 8007300 <_Heap_Greedy_allocate+0xd8>
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
80072e8: b9 60 68 00 mv r13,r11
80072ec: 29 ab 00 08 lw r11,(r13+8)
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
80072f0: 35 a2 00 08 addi r2,r13,8
80072f4: b9 80 08 00 mv r1,r12
80072f8: f8 00 24 c9 calli 801061c <_Heap_Free>
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
80072fc: 5d 60 ff fb bne r11,r0,80072e8 <_Heap_Greedy_allocate+0xc0>
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
return blocks;
}
8007300: b9 c0 08 00 mv r1,r14
8007304: 2b 9d 00 04 lw ra,(sp+4)
8007308: 2b 8b 00 1c lw r11,(sp+28)
800730c: 2b 8c 00 18 lw r12,(sp+24)
8007310: 2b 8d 00 14 lw r13,(sp+20)
8007314: 2b 8e 00 10 lw r14,(sp+16)
8007318: 2b 8f 00 0c lw r15,(sp+12)
800731c: 2b 90 00 08 lw r16,(sp+8)
8007320: 37 9c 00 1c addi sp,sp,28
8007324: c3 a0 00 00 ret
08007328 <_Heap_Greedy_free>:
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
8007328: 37 9c ff f4 addi sp,sp,-12
800732c: 5b 8b 00 0c sw (sp+12),r11
8007330: 5b 8c 00 08 sw (sp+8),r12
8007334: 5b 9d 00 04 sw (sp+4),ra
8007338: b8 20 60 00 mv r12,r1
while ( blocks != NULL ) {
800733c: 5c 40 00 03 bne r2,r0,8007348 <_Heap_Greedy_free+0x20> <== ALWAYS TAKEN
8007340: e0 00 00 07 bi 800735c <_Heap_Greedy_free+0x34> <== NOT EXECUTED
Heap_Block *current = blocks;
blocks = blocks->next;
8007344: b9 60 10 00 mv r2,r11
8007348: 28 4b 00 08 lw r11,(r2+8)
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
800734c: b9 80 08 00 mv r1,r12
8007350: 34 42 00 08 addi r2,r2,8
8007354: f8 00 24 b2 calli 801061c <_Heap_Free>
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
while ( blocks != NULL ) {
8007358: 5d 60 ff fb bne r11,r0,8007344 <_Heap_Greedy_free+0x1c>
Heap_Block *current = blocks;
blocks = blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
}
800735c: 2b 9d 00 04 lw ra,(sp+4)
8007360: 2b 8b 00 0c lw r11,(sp+12)
8007364: 2b 8c 00 08 lw r12,(sp+8)
8007368: 37 9c 00 0c addi sp,sp,12
800736c: c3 a0 00 00 ret
0801129c <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
801129c: 37 9c ff e8 addi sp,sp,-24
80112a0: 5b 8b 00 18 sw (sp+24),r11
80112a4: 5b 8c 00 14 sw (sp+20),r12
80112a8: 5b 8d 00 10 sw (sp+16),r13
80112ac: 5b 8e 00 0c sw (sp+12),r14
80112b0: 5b 8f 00 08 sw (sp+8),r15
80112b4: 5b 9d 00 04 sw (sp+4),ra
Heap_Block *current = heap->first_block;
80112b8: 28 25 00 20 lw r5,(r1+32)
Heap_Block *end = heap->last_block;
80112bc: 28 2c 00 24 lw r12,(r1+36)
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
80112c0: b8 40 68 00 mv r13,r2
80112c4: b8 60 70 00 mv r14,r3
80112c8: 34 0f ff fe mvi r15,-2
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
80112cc: 5c ac 00 04 bne r5,r12,80112dc <_Heap_Iterate+0x40> <== ALWAYS TAKEN
80112d0: e0 00 00 0c bi 8011300 <_Heap_Iterate+0x64> <== NOT EXECUTED
80112d4: 45 8b 00 0b be r12,r11,8011300 <_Heap_Iterate+0x64>
80112d8: b9 60 28 00 mv r5,r11
80112dc: 28 a2 00 04 lw r2,(r5+4)
uintptr_t size = _Heap_Block_size( current );
Heap_Block *next = _Heap_Block_at( current, size );
bool used = _Heap_Is_prev_used( next );
stop = (*visitor)( current, size, used, visitor_arg );
80112e0: b8 a0 08 00 mv r1,r5
80112e4: b9 c0 20 00 mv r4,r14
80112e8: a1 e2 10 00 and r2,r15,r2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
80112ec: b4 a2 58 00 add r11,r5,r2
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;
80112f0: 29 63 00 04 lw r3,(r11+4)
80112f4: 20 63 00 01 andi r3,r3,0x1
80112f8: d9 a0 00 00 call r13
{
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
80112fc: 44 20 ff f6 be r1,r0,80112d4 <_Heap_Iterate+0x38> <== ALWAYS TAKEN
stop = (*visitor)( current, size, used, visitor_arg );
current = next;
}
}
8011300: 2b 9d 00 04 lw ra,(sp+4)
8011304: 2b 8b 00 18 lw r11,(sp+24)
8011308: 2b 8c 00 14 lw r12,(sp+20)
801130c: 2b 8d 00 10 lw r13,(sp+16)
8011310: 2b 8e 00 0c lw r14,(sp+12)
8011314: 2b 8f 00 08 lw r15,(sp+8)
8011318: 37 9c 00 18 addi sp,sp,24
801131c: c3 a0 00 00 ret
0801cf7c <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
801cf7c: 37 9c ff f0 addi sp,sp,-16
801cf80: 5b 8b 00 10 sw (sp+16),r11
801cf84: 5b 8c 00 0c sw (sp+12),r12
801cf88: 5b 8d 00 08 sw (sp+8),r13
801cf8c: 5b 9d 00 04 sw (sp+4),ra
801cf90: b8 40 60 00 mv r12,r2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
801cf94: 28 22 00 10 lw r2,(r1+16)
801cf98: b8 20 58 00 mv r11,r1
801cf9c: b9 80 08 00 mv r1,r12
801cfa0: b8 60 68 00 mv r13,r3
801cfa4: fb ff fc 29 calli 801c048 <__umodsi3>
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
801cfa8: 29 62 00 20 lw r2,(r11+32)
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
801cfac: 35 84 ff f8 addi r4,r12,-8
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
801cfb0: c8 81 20 00 sub r4,r4,r1
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 ) ) {
return false;
801cfb4: 34 01 00 00 mvi r1,0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
801cfb8: 54 44 00 10 bgu r2,r4,801cff8 <_Heap_Size_of_alloc_area+0x7c>
801cfbc: 29 65 00 24 lw r5,(r11+36)
801cfc0: 54 85 00 0e bgu r4,r5,801cff8 <_Heap_Size_of_alloc_area+0x7c><== NEVER TAKEN
- 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;
801cfc4: 28 86 00 04 lw r6,(r4+4)
801cfc8: 34 03 ff fe mvi r3,-2
801cfcc: a0 66 18 00 and r3,r3,r6
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
801cfd0: b4 83 20 00 add r4,r4,r3
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;
801cfd4: 54 44 00 09 bgu r2,r4,801cff8 <_Heap_Size_of_alloc_area+0x7c><== NEVER TAKEN
801cfd8: 54 85 00 08 bgu r4,r5,801cff8 <_Heap_Size_of_alloc_area+0x7c><== 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;
801cfdc: 28 82 00 04 lw r2,(r4+4)
801cfe0: 20 42 00 01 andi r2,r2,0x1
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
801cfe4: 44 40 00 05 be r2,r0,801cff8 <_Heap_Size_of_alloc_area+0x7c><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
801cfe8: c8 8c 20 00 sub r4,r4,r12
801cfec: 34 84 00 04 addi r4,r4,4
801cff0: 59 a4 00 00 sw (r13+0),r4
return true;
801cff4: 34 01 00 01 mvi r1,1
}
801cff8: 2b 9d 00 04 lw ra,(sp+4)
801cffc: 2b 8b 00 10 lw r11,(sp+16)
801d000: 2b 8c 00 0c lw r12,(sp+12)
801d004: 2b 8d 00 08 lw r13,(sp+8)
801d008: 37 9c 00 10 addi sp,sp,16
801d00c: c3 a0 00 00 ret
08005918 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
8005918: 37 9c ff 9c addi sp,sp,-100
800591c: 5b 8b 00 50 sw (sp+80),r11
8005920: 5b 8c 00 4c sw (sp+76),r12
8005924: 5b 8d 00 48 sw (sp+72),r13
8005928: 5b 8e 00 44 sw (sp+68),r14
800592c: 5b 8f 00 40 sw (sp+64),r15
8005930: 5b 90 00 3c sw (sp+60),r16
8005934: 5b 91 00 38 sw (sp+56),r17
8005938: 5b 92 00 34 sw (sp+52),r18
800593c: 5b 93 00 30 sw (sp+48),r19
8005940: 5b 94 00 2c sw (sp+44),r20
8005944: 5b 95 00 28 sw (sp+40),r21
8005948: 5b 96 00 24 sw (sp+36),r22
800594c: 5b 97 00 20 sw (sp+32),r23
8005950: 5b 98 00 1c sw (sp+28),r24
8005954: 5b 99 00 18 sw (sp+24),r25
8005958: 5b 9b 00 14 sw (sp+20),fp
800595c: 5b 9d 00 10 sw (sp+16),ra
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;
8005960: 78 0f 08 00 mvhi r15,0x800
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
8005964: 20 63 00 ff andi r3,r3,0xff
8005968: b8 20 68 00 mv r13,r1
800596c: b8 40 98 00 mv r19,r2
uintptr_t const page_size = heap->page_size;
8005970: 28 35 00 10 lw r21,(r1+16)
uintptr_t const min_block_size = heap->min_block_size;
8005974: 28 36 00 14 lw r22,(r1+20)
Heap_Block *const first_block = heap->first_block;
8005978: 28 34 00 20 lw r20,(r1+32)
Heap_Block *const last_block = heap->last_block;
800597c: 28 37 00 24 lw r23,(r1+36)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
8005980: 39 ef 58 70 ori r15,r15,0x5870
8005984: 44 60 00 03 be r3,r0,8005990 <_Heap_Walk+0x78>
8005988: 78 0f 08 00 mvhi r15,0x800
800598c: 39 ef 58 94 ori r15,r15,0x5894
if ( !_System_state_Is_up( _System_state_Get() ) ) {
8005990: 78 03 08 01 mvhi r3,0x801
8005994: 38 63 7e 00 ori r3,r3,0x7e00
8005998: 28 69 00 00 lw r9,(r3+0)
800599c: 34 07 00 03 mvi r7,3
return true;
80059a0: 34 03 00 01 mvi r3,1
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
80059a4: 45 27 00 15 be r9,r7,80059f8 <_Heap_Walk+0xe0>
block = next_block;
} while ( block != first_block );
return true;
}
80059a8: b8 60 08 00 mv r1,r3
80059ac: 2b 9d 00 10 lw ra,(sp+16)
80059b0: 2b 8b 00 50 lw r11,(sp+80)
80059b4: 2b 8c 00 4c lw r12,(sp+76)
80059b8: 2b 8d 00 48 lw r13,(sp+72)
80059bc: 2b 8e 00 44 lw r14,(sp+68)
80059c0: 2b 8f 00 40 lw r15,(sp+64)
80059c4: 2b 90 00 3c lw r16,(sp+60)
80059c8: 2b 91 00 38 lw r17,(sp+56)
80059cc: 2b 92 00 34 lw r18,(sp+52)
80059d0: 2b 93 00 30 lw r19,(sp+48)
80059d4: 2b 94 00 2c lw r20,(sp+44)
80059d8: 2b 95 00 28 lw r21,(sp+40)
80059dc: 2b 96 00 24 lw r22,(sp+36)
80059e0: 2b 97 00 20 lw r23,(sp+32)
80059e4: 2b 98 00 1c lw r24,(sp+28)
80059e8: 2b 99 00 18 lw r25,(sp+24)
80059ec: 2b 9b 00 14 lw fp,(sp+20)
80059f0: 37 9c 00 64 addi sp,sp,100
80059f4: c3 a0 00 00 ret
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)(
80059f8: 29 a2 00 08 lw r2,(r13+8)
80059fc: 29 a1 00 0c lw r1,(r13+12)
8005a00: 29 a6 00 18 lw r6,(r13+24)
8005a04: 29 a7 00 1c lw r7,(r13+28)
8005a08: 78 03 08 01 mvhi r3,0x801
8005a0c: 5b 82 00 08 sw (sp+8),r2
8005a10: 5b 81 00 0c sw (sp+12),r1
8005a14: 5b 97 00 04 sw (sp+4),r23
8005a18: ba 60 08 00 mv r1,r19
8005a1c: 34 02 00 00 mvi r2,0
8005a20: 38 63 50 d8 ori r3,r3,0x50d8
8005a24: ba a0 20 00 mv r4,r21
8005a28: ba c0 28 00 mv r5,r22
8005a2c: ba 80 40 00 mv r8,r20
8005a30: d9 e0 00 00 call r15
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
8005a34: 46 a0 00 26 be r21,r0,8005acc <_Heap_Walk+0x1b4>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
8005a38: 22 ab 00 03 andi r11,r21,0x3
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
8005a3c: 5d 60 00 2b bne r11,r0,8005ae8 <_Heap_Walk+0x1d0>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8005a40: ba c0 08 00 mv r1,r22
8005a44: ba a0 10 00 mv r2,r21
8005a48: fb ff eb f6 calli 8000a20 <__umodsi3>
8005a4c: b8 20 60 00 mv r12,r1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
8005a50: 5c 2b 00 2e bne r1,r11,8005b08 <_Heap_Walk+0x1f0>
8005a54: 36 81 00 08 addi r1,r20,8
8005a58: ba a0 10 00 mv r2,r21
8005a5c: fb ff eb f1 calli 8000a20 <__umodsi3>
8005a60: b8 20 18 00 mv r3,r1
);
return false;
}
if (
8005a64: 5c 2c 00 31 bne r1,r12,8005b28 <_Heap_Walk+0x210>
block = next_block;
} while ( block != first_block );
return true;
}
8005a68: 2a 8c 00 04 lw r12,(r20+4)
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;
8005a6c: 21 81 00 01 andi r1,r12,0x1
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
8005a70: 44 23 00 fe be r1,r3,8005e68 <_Heap_Walk+0x550>
- 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;
8005a74: 2a e2 00 04 lw r2,(r23+4)
8005a78: 34 01 ff fe mvi r1,-2
8005a7c: a0 22 08 00 and r1,r1,r2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
8005a80: b6 e1 08 00 add r1,r23,r1
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
8005a84: 28 22 00 04 lw r2,(r1+4)
8005a88: 20 42 00 01 andi r2,r2,0x1
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
8005a8c: 44 43 00 09 be r2,r3,8005ab0 <_Heap_Walk+0x198>
);
return false;
}
if (
8005a90: 46 81 00 2e be r20,r1,8005b48 <_Heap_Walk+0x230>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
8005a94: 78 03 08 01 mvhi r3,0x801
8005a98: 38 63 52 40 ori r3,r3,0x5240
8005a9c: ba 60 08 00 mv r1,r19
8005aa0: 34 02 00 01 mvi r2,1
8005aa4: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005aa8: 34 03 00 00 mvi r3,0
8005aac: e3 ff ff bf bi 80059a8 <_Heap_Walk+0x90>
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
8005ab0: 78 03 08 01 mvhi r3,0x801
8005ab4: 38 63 52 28 ori r3,r3,0x5228
8005ab8: ba 60 08 00 mv r1,r19
8005abc: 34 02 00 01 mvi r2,1
8005ac0: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005ac4: 34 03 00 00 mvi r3,0
8005ac8: e3 ff ff b8 bi 80059a8 <_Heap_Walk+0x90>
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
8005acc: 78 03 08 01 mvhi r3,0x801
8005ad0: 38 63 51 6c ori r3,r3,0x516c
8005ad4: ba 60 08 00 mv r1,r19
8005ad8: 34 02 00 01 mvi r2,1
8005adc: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005ae0: 34 03 00 00 mvi r3,0
8005ae4: e3 ff ff b1 bi 80059a8 <_Heap_Walk+0x90>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
8005ae8: 78 03 08 01 mvhi r3,0x801
8005aec: 38 63 51 80 ori r3,r3,0x5180
8005af0: ba 60 08 00 mv r1,r19
8005af4: 34 02 00 01 mvi r2,1
8005af8: ba a0 20 00 mv r4,r21
8005afc: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005b00: 34 03 00 00 mvi r3,0
8005b04: e3 ff ff a9 bi 80059a8 <_Heap_Walk+0x90>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
8005b08: 78 03 08 01 mvhi r3,0x801
8005b0c: 38 63 51 a0 ori r3,r3,0x51a0
8005b10: ba 60 08 00 mv r1,r19
8005b14: 34 02 00 01 mvi r2,1
8005b18: ba c0 20 00 mv r4,r22
8005b1c: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005b20: 34 03 00 00 mvi r3,0
8005b24: e3 ff ff a1 bi 80059a8 <_Heap_Walk+0x90>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
8005b28: 78 03 08 01 mvhi r3,0x801
8005b2c: 38 63 51 c4 ori r3,r3,0x51c4
8005b30: ba 60 08 00 mv r1,r19
8005b34: 34 02 00 01 mvi r2,1
8005b38: ba 80 20 00 mv r4,r20
8005b3c: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005b40: 34 03 00 00 mvi r3,0
8005b44: e3 ff ff 99 bi 80059a8 <_Heap_Walk+0x90>
block = next_block;
} while ( block != first_block );
return true;
}
8005b48: 29 ab 00 08 lw r11,(r13+8)
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
8005b4c: 29 b2 00 10 lw r18,(r13+16)
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 ) {
8005b50: 45 ab 00 2f be r13,r11,8005c0c <_Heap_Walk+0x2f4>
block = next_block;
} while ( block != first_block );
return true;
}
8005b54: 29 ae 00 20 lw r14,(r13+32)
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;
8005b58: 55 cb 00 dd bgu r14,r11,8005ecc <_Heap_Walk+0x5b4> <== NEVER TAKEN
8005b5c: 29 b8 00 24 lw r24,(r13+36)
8005b60: 55 78 00 db bgu r11,r24,8005ecc <_Heap_Walk+0x5b4> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8005b64: 35 61 00 08 addi r1,r11,8
8005b68: ba 40 10 00 mv r2,r18
8005b6c: fb ff eb ad calli 8000a20 <__umodsi3>
);
return false;
}
if (
8005b70: 5c 20 00 df bne r1,r0,8005eec <_Heap_Walk+0x5d4> <== NEVER TAKEN
- 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;
8005b74: 29 63 00 04 lw r3,(r11+4)
8005b78: 34 02 ff fe mvi r2,-2
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
8005b7c: b9 60 80 00 mv r16,r11
8005b80: a0 43 10 00 and r2,r2,r3
block = next_block;
} while ( block != first_block );
return true;
}
8005b84: b5 62 10 00 add r2,r11,r2
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;
8005b88: 28 42 00 04 lw r2,(r2+4)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
8005b8c: b9 a0 18 00 mv r3,r13
- 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;
8005b90: 34 11 ff fe mvi r17,-2
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;
8005b94: 20 42 00 01 andi r2,r2,0x1
8005b98: 44 41 00 12 be r2,r1,8005be0 <_Heap_Walk+0x2c8> <== ALWAYS TAKEN
8005b9c: e0 00 00 dc bi 8005f0c <_Heap_Walk+0x5f4> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
8005ba0: 29 6b 00 08 lw r11,(r11+8)
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 ) {
8005ba4: 45 ab 00 1b be r13,r11,8005c10 <_Heap_Walk+0x2f8>
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;
8005ba8: 55 cb 00 c9 bgu r14,r11,8005ecc <_Heap_Walk+0x5b4>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8005bac: 35 61 00 08 addi r1,r11,8
8005bb0: ba 40 10 00 mv r2,r18
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;
8005bb4: 55 78 00 c6 bgu r11,r24,8005ecc <_Heap_Walk+0x5b4> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8005bb8: fb ff eb 9a calli 8000a20 <__umodsi3>
);
return false;
}
if (
8005bbc: 5c 20 00 cc bne r1,r0,8005eec <_Heap_Walk+0x5d4>
- 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;
8005bc0: 29 64 00 04 lw r4,(r11+4)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
8005bc4: ba 00 18 00 mv r3,r16
8005bc8: b9 60 80 00 mv r16,r11
8005bcc: a2 24 20 00 and r4,r17,r4
block = next_block;
} while ( block != first_block );
return true;
}
8005bd0: b4 8b 20 00 add r4,r4,r11
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;
8005bd4: 28 84 00 04 lw r4,(r4+4)
8005bd8: 20 84 00 01 andi r4,r4,0x1
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
8005bdc: 5c 81 00 cc bne r4,r1,8005f0c <_Heap_Walk+0x5f4>
);
return false;
}
if ( free_block->prev != prev_block ) {
8005be0: 29 67 00 0c lw r7,(r11+12)
8005be4: 44 e3 ff ef be r7,r3,8005ba0 <_Heap_Walk+0x288>
(*printer)(
8005be8: 78 03 08 01 mvhi r3,0x801
8005bec: 38 63 52 dc ori r3,r3,0x52dc
8005bf0: ba 60 08 00 mv r1,r19
8005bf4: 34 02 00 01 mvi r2,1
8005bf8: b9 60 20 00 mv r4,r11
8005bfc: b8 e0 28 00 mv r5,r7
8005c00: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005c04: 34 03 00 00 mvi r3,0
8005c08: e3 ff ff 68 bi 80059a8 <_Heap_Walk+0x90>
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 ) {
8005c0c: 29 ae 00 20 lw r14,(r13+32)
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)(
8005c10: 78 01 08 01 mvhi r1,0x801
8005c14: 5b 81 00 54 sw (sp+84),r1
8005c18: 78 01 08 01 mvhi r1,0x801
8005c1c: 5b 81 00 58 sw (sp+88),r1
8005c20: 78 01 08 01 mvhi r1,0x801
8005c24: 5b 81 00 5c sw (sp+92),r1
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
8005c28: 78 01 08 01 mvhi r1,0x801
8005c2c: 5b 81 00 60 sw (sp+96),r1
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
8005c30: 78 01 08 01 mvhi r1,0x801
8005c34: 5b 81 00 64 sw (sp+100),r1
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)(
8005c38: 2b 81 00 54 lw r1,(sp+84)
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
8005c3c: 78 1b 08 01 mvhi fp,0x801
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
8005c40: 78 19 08 01 mvhi r25,0x801
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)(
8005c44: 38 21 50 a0 ori r1,r1,0x50a0
8005c48: 5b 81 00 54 sw (sp+84),r1
8005c4c: 2b 81 00 58 lw r1,(sp+88)
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
8005c50: 78 18 08 01 mvhi r24,0x801
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
8005c54: ba 80 88 00 mv r17,r20
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)(
8005c58: 38 21 50 bc ori r1,r1,0x50bc
8005c5c: 5b 81 00 58 sw (sp+88),r1
8005c60: 2b 81 00 5c lw r1,(sp+92)
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
8005c64: 3b 7b 54 8c ori fp,fp,0x548c
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
8005c68: 3b 39 54 74 ori r25,r25,0x5474
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)(
8005c6c: 38 21 53 d0 ori r1,r1,0x53d0
8005c70: 5b 81 00 5c sw (sp+92),r1
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
8005c74: 2b 81 00 60 lw r1,(sp+96)
8005c78: 3b 18 54 40 ori r24,r24,0x5440
8005c7c: 38 21 50 cc ori r1,r1,0x50cc
8005c80: 5b 81 00 60 sw (sp+96),r1
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
8005c84: 2b 81 00 64 lw r1,(sp+100)
8005c88: 38 21 50 b0 ori r1,r1,0x50b0
8005c8c: 5b 81 00 64 sw (sp+100),r1
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
8005c90: 34 01 ff fe mvi r1,-2
8005c94: a1 81 90 00 and r18,r12,r1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
8005c98: b6 51 80 00 add r16,r18,r17
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;
8005c9c: 55 d0 00 7a bgu r14,r16,8005e84 <_Heap_Walk+0x56c> <== NEVER TAKEN
8005ca0: 29 a4 00 24 lw r4,(r13+36)
8005ca4: 56 04 00 78 bgu r16,r4,8005e84 <_Heap_Walk+0x56c>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8005ca8: ba 40 08 00 mv r1,r18
8005cac: ba a0 10 00 mv r2,r21
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;
8005cb0: fe 37 58 00 cmpne r11,r17,r23
8005cb4: fb ff eb 5b calli 8000a20 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
8005cb8: 44 20 00 02 be r1,r0,8005cc0 <_Heap_Walk+0x3a8>
8005cbc: 5d 60 00 15 bne r11,r0,8005d10 <_Heap_Walk+0x3f8>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
8005cc0: 52 56 00 02 bgeu r18,r22,8005cc8 <_Heap_Walk+0x3b0>
8005cc4: 5d 60 00 1c bne r11,r0,8005d34 <_Heap_Walk+0x41c> <== ALWAYS TAKEN
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
8005cc8: 56 11 00 02 bgu r16,r17,8005cd0 <_Heap_Walk+0x3b8>
8005ccc: 5d 60 00 77 bne r11,r0,8005ea8 <_Heap_Walk+0x590>
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;
8005cd0: 2a 06 00 04 lw r6,(r16+4)
8005cd4: 21 8c 00 01 andi r12,r12,0x1
8005cd8: 20 c6 00 01 andi r6,r6,0x1
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
8005cdc: 44 c0 00 28 be r6,r0,8005d7c <_Heap_Walk+0x464>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
8005ce0: 45 80 00 1f be r12,r0,8005d5c <_Heap_Walk+0x444>
(*printer)(
8005ce4: ba 60 08 00 mv r1,r19
8005ce8: 34 02 00 00 mvi r2,0
8005cec: bb 20 18 00 mv r3,r25
8005cf0: ba 20 20 00 mv r4,r17
8005cf4: ba 40 28 00 mv r5,r18
8005cf8: d9 e0 00 00 call r15
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
8005cfc: 46 90 00 43 be r20,r16,8005e08 <_Heap_Walk+0x4f0>
8005d00: 2a 0c 00 04 lw r12,(r16+4)
8005d04: 29 ae 00 20 lw r14,(r13+32)
8005d08: ba 00 88 00 mv r17,r16
8005d0c: e3 ff ff e1 bi 8005c90 <_Heap_Walk+0x378>
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
8005d10: 78 03 08 01 mvhi r3,0x801
8005d14: 38 63 53 40 ori r3,r3,0x5340
8005d18: ba 60 08 00 mv r1,r19
8005d1c: 34 02 00 01 mvi r2,1
8005d20: ba 20 20 00 mv r4,r17
8005d24: ba 40 28 00 mv r5,r18
8005d28: d9 e0 00 00 call r15
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
8005d2c: 34 03 00 00 mvi r3,0
8005d30: e3 ff ff 1e bi 80059a8 <_Heap_Walk+0x90>
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
8005d34: 78 03 08 01 mvhi r3,0x801
8005d38: 38 63 53 70 ori r3,r3,0x5370
8005d3c: ba 60 08 00 mv r1,r19
8005d40: 34 02 00 01 mvi r2,1
8005d44: ba 20 20 00 mv r4,r17
8005d48: ba 40 28 00 mv r5,r18
8005d4c: ba c0 30 00 mv r6,r22
8005d50: d9 e0 00 00 call r15
block,
block_size,
min_block_size
);
return false;
8005d54: 34 03 00 00 mvi r3,0
8005d58: e3 ff ff 14 bi 80059a8 <_Heap_Walk+0x90>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
8005d5c: 2a 26 00 00 lw r6,(r17+0)
8005d60: ba 20 20 00 mv r4,r17
8005d64: ba 60 08 00 mv r1,r19
8005d68: 34 02 00 00 mvi r2,0
8005d6c: bb 60 18 00 mv r3,fp
8005d70: ba 40 28 00 mv r5,r18
8005d74: d9 e0 00 00 call r15
8005d78: e3 ff ff e1 bi 8005cfc <_Heap_Walk+0x3e4>
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 ?
8005d7c: 2a 26 00 0c lw r6,(r17+12)
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)(
8005d80: 29 a4 00 08 lw r4,(r13+8)
block = next_block;
} while ( block != first_block );
return true;
}
8005d84: 29 a5 00 0c lw r5,(r13+12)
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)(
8005d88: 2b 87 00 54 lw r7,(sp+84)
8005d8c: 44 86 00 03 be r4,r6,8005d98 <_Heap_Walk+0x480>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
8005d90: bb 00 38 00 mv r7,r24
8005d94: 45 a6 00 29 be r13,r6,8005e38 <_Heap_Walk+0x520>
block->next,
block->next == last_free_block ?
8005d98: 2a 28 00 08 lw r8,(r17+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)(
8005d9c: 2b 84 00 58 lw r4,(sp+88)
8005da0: 44 a8 00 03 be r5,r8,8005dac <_Heap_Walk+0x494>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
8005da4: bb 00 20 00 mv r4,r24
8005da8: 45 a8 00 26 be r13,r8,8005e40 <_Heap_Walk+0x528>
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)(
8005dac: 2b 83 00 5c lw r3,(sp+92)
8005db0: 5b 84 00 04 sw (sp+4),r4
8005db4: ba 60 08 00 mv r1,r19
8005db8: 34 02 00 00 mvi r2,0
8005dbc: ba 20 20 00 mv r4,r17
8005dc0: ba 40 28 00 mv r5,r18
8005dc4: d9 e0 00 00 call r15
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
8005dc8: 2a 06 00 00 lw r6,(r16+0)
8005dcc: 5e 46 00 11 bne r18,r6,8005e10 <_Heap_Walk+0x4f8>
);
return false;
}
if ( !prev_used ) {
8005dd0: 45 80 00 1e be r12,r0,8005e48 <_Heap_Walk+0x530>
block = next_block;
} while ( block != first_block );
return true;
}
8005dd4: 29 a5 00 08 lw r5,(r13+8)
)
{
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 ) {
8005dd8: 45 a5 00 04 be r13,r5,8005de8 <_Heap_Walk+0x4d0> <== NEVER TAKEN
if ( free_block == block ) {
8005ddc: 46 25 ff c8 be r17,r5,8005cfc <_Heap_Walk+0x3e4>
return true;
}
free_block = free_block->next;
8005de0: 28 a5 00 08 lw r5,(r5+8)
)
{
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 ) {
8005de4: 5d a5 ff fe bne r13,r5,8005ddc <_Heap_Walk+0x4c4>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
8005de8: 78 03 08 01 mvhi r3,0x801
8005dec: 38 63 54 b4 ori r3,r3,0x54b4
8005df0: ba 60 08 00 mv r1,r19
8005df4: 34 02 00 01 mvi r2,1
8005df8: ba 20 20 00 mv r4,r17
8005dfc: d9 e0 00 00 call r15
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
8005e00: 34 03 00 00 mvi r3,0
8005e04: e3 ff fe e9 bi 80059a8 <_Heap_Walk+0x90>
}
block = next_block;
} while ( block != first_block );
return true;
8005e08: 34 03 00 01 mvi r3,1
8005e0c: e3 ff fe e7 bi 80059a8 <_Heap_Walk+0x90>
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
8005e10: 78 03 08 01 mvhi r3,0x801
8005e14: 38 63 54 08 ori r3,r3,0x5408
8005e18: ba 60 08 00 mv r1,r19
8005e1c: 34 02 00 01 mvi r2,1
8005e20: ba 20 20 00 mv r4,r17
8005e24: ba 40 28 00 mv r5,r18
8005e28: ba 00 38 00 mv r7,r16
8005e2c: d9 e0 00 00 call r15
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
8005e30: 34 03 00 00 mvi r3,0
8005e34: e3 ff fe dd bi 80059a8 <_Heap_Walk+0x90>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
8005e38: 2b 87 00 64 lw r7,(sp+100)
8005e3c: e3 ff ff d7 bi 8005d98 <_Heap_Walk+0x480>
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
8005e40: 2b 84 00 60 lw r4,(sp+96)
8005e44: e3 ff ff da bi 8005dac <_Heap_Walk+0x494>
return false;
}
if ( !prev_used ) {
(*printer)(
8005e48: 78 03 08 01 mvhi r3,0x801
8005e4c: 38 63 54 44 ori r3,r3,0x5444
8005e50: ba 60 08 00 mv r1,r19
8005e54: 34 02 00 01 mvi r2,1
8005e58: ba 20 20 00 mv r4,r17
8005e5c: d9 e0 00 00 call r15
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
8005e60: 34 03 00 00 mvi r3,0
8005e64: e3 ff fe d1 bi 80059a8 <_Heap_Walk+0x90>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
8005e68: 78 03 08 01 mvhi r3,0x801
8005e6c: 38 63 51 f8 ori r3,r3,0x51f8
8005e70: ba 60 08 00 mv r1,r19
8005e74: 34 02 00 01 mvi r2,1
8005e78: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005e7c: 34 03 00 00 mvi r3,0
8005e80: e3 ff fe ca bi 80059a8 <_Heap_Walk+0x90>
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
(*printer)(
8005e84: 78 03 08 01 mvhi r3,0x801
8005e88: 38 63 53 10 ori r3,r3,0x5310
8005e8c: ba 60 08 00 mv r1,r19
8005e90: 34 02 00 01 mvi r2,1
8005e94: ba 20 20 00 mv r4,r17
8005e98: ba 00 28 00 mv r5,r16
8005e9c: d9 e0 00 00 call r15
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
8005ea0: 34 03 00 00 mvi r3,0
8005ea4: e3 ff fe c1 bi 80059a8 <_Heap_Walk+0x90>
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
8005ea8: 78 03 08 01 mvhi r3,0x801
8005eac: 38 63 53 9c ori r3,r3,0x539c
8005eb0: ba 60 08 00 mv r1,r19
8005eb4: 34 02 00 01 mvi r2,1
8005eb8: ba 20 20 00 mv r4,r17
8005ebc: ba 00 28 00 mv r5,r16
8005ec0: d9 e0 00 00 call r15
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
8005ec4: 34 03 00 00 mvi r3,0
8005ec8: e3 ff fe b8 bi 80059a8 <_Heap_Walk+0x90>
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 ) ) {
(*printer)(
8005ecc: 78 03 08 01 mvhi r3,0x801
8005ed0: 38 63 52 70 ori r3,r3,0x5270
8005ed4: ba 60 08 00 mv r1,r19
8005ed8: 34 02 00 01 mvi r2,1
8005edc: b9 60 20 00 mv r4,r11
8005ee0: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005ee4: 34 03 00 00 mvi r3,0
8005ee8: e3 ff fe b0 bi 80059a8 <_Heap_Walk+0x90>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
8005eec: 78 03 08 01 mvhi r3,0x801
8005ef0: 38 63 52 90 ori r3,r3,0x5290
8005ef4: ba 60 08 00 mv r1,r19
8005ef8: 34 02 00 01 mvi r2,1
8005efc: b9 60 20 00 mv r4,r11
8005f00: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005f04: 34 03 00 00 mvi r3,0
8005f08: e3 ff fe a8 bi 80059a8 <_Heap_Walk+0x90>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
8005f0c: 78 03 08 01 mvhi r3,0x801
8005f10: 38 63 52 c0 ori r3,r3,0x52c0
8005f14: ba 60 08 00 mv r1,r19
8005f18: 34 02 00 01 mvi r2,1
8005f1c: b9 60 20 00 mv r4,r11
8005f20: d9 e0 00 00 call r15
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005f24: 34 03 00 00 mvi r3,0
8005f28: e3 ff fe a0 bi 80059a8 <_Heap_Walk+0x90>
080045e0 <_IO_Initialize_all_drivers>:
void _IO_Initialize_all_drivers( void )
{
80045e0: 37 9c ff f4 addi sp,sp,-12
80045e4: 5b 8b 00 0c sw (sp+12),r11
80045e8: 5b 8c 00 08 sw (sp+8),r12
80045ec: 5b 9d 00 04 sw (sp+4),ra
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
80045f0: 78 0c 08 02 mvhi r12,0x802
80045f4: 39 8c 12 50 ori r12,r12,0x1250
80045f8: 29 81 00 00 lw r1,(r12+0)
80045fc: 44 20 00 09 be r1,r0,8004620 <_IO_Initialize_all_drivers+0x40><== NEVER TAKEN
8004600: 34 0b 00 00 mvi r11,0
(void) rtems_io_initialize( major, 0, NULL );
8004604: b9 60 08 00 mv r1,r11
8004608: 34 02 00 00 mvi r2,0
800460c: 34 03 00 00 mvi r3,0
8004610: f8 00 18 d6 calli 800a968 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
8004614: 29 81 00 00 lw r1,(r12+0)
8004618: 35 6b 00 01 addi r11,r11,1
800461c: 54 2b ff fa bgu r1,r11,8004604 <_IO_Initialize_all_drivers+0x24>
(void) rtems_io_initialize( major, 0, NULL );
}
8004620: 2b 9d 00 04 lw ra,(sp+4)
8004624: 2b 8b 00 0c lw r11,(sp+12)
8004628: 2b 8c 00 08 lw r12,(sp+8)
800462c: 37 9c 00 0c addi sp,sp,12
8004630: c3 a0 00 00 ret
080044c0 <_IO_Manager_initialization>:
#include <rtems/score/wkspace.h>
#include <string.h>
void _IO_Manager_initialization(void)
{
80044c0: 37 9c ff e8 addi sp,sp,-24
80044c4: 5b 8b 00 18 sw (sp+24),r11
80044c8: 5b 8c 00 14 sw (sp+20),r12
80044cc: 5b 8d 00 10 sw (sp+16),r13
80044d0: 5b 8e 00 0c sw (sp+12),r14
80044d4: 5b 8f 00 08 sw (sp+8),r15
80044d8: 5b 9d 00 04 sw (sp+4),ra
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = rtems_configuration_get_device_driver_table();
80044dc: 78 01 08 01 mvhi r1,0x801
80044e0: 38 21 d2 6c ori r1,r1,0xd26c
drivers_in_table = rtems_configuration_get_number_of_device_drivers();
80044e4: 28 2b 00 38 lw r11,(r1+56)
number_of_drivers = rtems_configuration_get_maximum_drivers();
80044e8: 28 2e 00 34 lw r14,(r1+52)
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = rtems_configuration_get_device_driver_table();
80044ec: 28 2d 00 3c lw r13,(r1+60)
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
80044f0: 51 6e 00 2e bgeu r11,r14,80045a8 <_IO_Manager_initialization+0xe8>
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
80044f4: b5 ce 60 00 add r12,r14,r14
80044f8: b5 8e 60 00 add r12,r12,r14
80044fc: b5 8c 60 00 add r12,r12,r12
8004500: b5 8c 60 00 add r12,r12,r12
8004504: b5 8c 60 00 add r12,r12,r12
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
8004508: b9 80 08 00 mv r1,r12
800450c: f8 00 0e d2 calli 8008054 <_Workspace_Allocate_or_fatal_error>
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
8004510: 78 04 08 02 mvhi r4,0x802
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
8004514: 78 0f 08 02 mvhi r15,0x802
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
8004518: 38 84 12 50 ori r4,r4,0x1250
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
800451c: 39 ef 12 54 ori r15,r15,0x1254
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
8004520: 34 02 00 00 mvi r2,0
8004524: b9 80 18 00 mv r3,r12
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
8004528: 58 8e 00 00 sw (r4+0),r14
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
800452c: 59 e1 00 00 sw (r15+0),r1
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
8004530: f8 00 26 8c calli 800df60 <memset>
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
8004534: 45 60 00 15 be r11,r0,8004588 <_IO_Manager_initialization+0xc8><== NEVER TAKEN
8004538: 29 e5 00 00 lw r5,(r15+0)
800453c: 34 03 00 00 mvi r3,0
8004540: 34 04 00 00 mvi r4,0
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _IO_Manager_initialization(void)
8004544: b5 a3 08 00 add r1,r13,r3
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
8004548: 28 26 00 00 lw r6,(r1+0)
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _IO_Manager_initialization(void)
800454c: b4 a3 10 00 add r2,r5,r3
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
8004550: 34 84 00 01 addi r4,r4,1
_IO_Driver_address_table[index] = driver_table[index];
8004554: 58 46 00 00 sw (r2+0),r6
8004558: 28 26 00 04 lw r6,(r1+4)
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
800455c: 34 63 00 18 addi r3,r3,24
_IO_Driver_address_table[index] = driver_table[index];
8004560: 58 46 00 04 sw (r2+4),r6
8004564: 28 26 00 08 lw r6,(r1+8)
8004568: 58 46 00 08 sw (r2+8),r6
800456c: 28 26 00 0c lw r6,(r1+12)
8004570: 58 46 00 0c sw (r2+12),r6
8004574: 28 26 00 10 lw r6,(r1+16)
8004578: 58 46 00 10 sw (r2+16),r6
800457c: 28 21 00 14 lw r1,(r1+20)
8004580: 58 41 00 14 sw (r2+20),r1
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
8004584: 55 64 ff f0 bgu r11,r4,8004544 <_IO_Manager_initialization+0x84>
_IO_Driver_address_table[index] = driver_table[index];
}
8004588: 2b 9d 00 04 lw ra,(sp+4)
800458c: 2b 8b 00 18 lw r11,(sp+24)
8004590: 2b 8c 00 14 lw r12,(sp+20)
8004594: 2b 8d 00 10 lw r13,(sp+16)
8004598: 2b 8e 00 0c lw r14,(sp+12)
800459c: 2b 8f 00 08 lw r15,(sp+8)
80045a0: 37 9c 00 18 addi sp,sp,24
80045a4: c3 a0 00 00 ret
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
80045a8: 78 02 08 02 mvhi r2,0x802
_IO_Number_of_drivers = number_of_drivers;
80045ac: 78 01 08 02 mvhi r1,0x802
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
80045b0: 38 42 12 54 ori r2,r2,0x1254
_IO_Number_of_drivers = number_of_drivers;
80045b4: 38 21 12 50 ori r1,r1,0x1250
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
80045b8: 58 4d 00 00 sw (r2+0),r13
_IO_Number_of_drivers = number_of_drivers;
80045bc: 58 2b 00 00 sw (r1+0),r11
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
80045c0: 2b 9d 00 04 lw ra,(sp+4)
80045c4: 2b 8b 00 18 lw r11,(sp+24)
80045c8: 2b 8c 00 14 lw r12,(sp+20)
80045cc: 2b 8d 00 10 lw r13,(sp+16)
80045d0: 2b 8e 00 0c lw r14,(sp+12)
80045d4: 2b 8f 00 08 lw r15,(sp+8)
80045d8: 37 9c 00 18 addi sp,sp,24
80045dc: c3 a0 00 00 ret
0800558c <_Objects_Allocate>:
#endif
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
800558c: 37 9c ff ec addi sp,sp,-20
8005590: 5b 8b 00 14 sw (sp+20),r11
8005594: 5b 8c 00 10 sw (sp+16),r12
8005598: 5b 8d 00 0c sw (sp+12),r13
800559c: 5b 8e 00 08 sw (sp+8),r14
80055a0: 5b 9d 00 04 sw (sp+4),ra
80055a4: b8 20 58 00 mv r11,r1
* 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 )
80055a8: 28 21 00 18 lw r1,(r1+24)
return NULL;
80055ac: 34 0c 00 00 mvi r12,0
* 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 )
80055b0: 5c 20 00 09 bne r1,r0,80055d4 <_Objects_Allocate+0x48> <== ALWAYS TAKEN
);
}
#endif
return the_object;
}
80055b4: b9 80 08 00 mv r1,r12
80055b8: 2b 9d 00 04 lw ra,(sp+4)
80055bc: 2b 8b 00 14 lw r11,(sp+20)
80055c0: 2b 8c 00 10 lw r12,(sp+16)
80055c4: 2b 8d 00 0c lw r13,(sp+12)
80055c8: 2b 8e 00 08 lw r14,(sp+8)
80055cc: 37 9c 00 14 addi sp,sp,20
80055d0: c3 a0 00 00 ret
/*
* 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 );
80055d4: 35 6d 00 20 addi r13,r11,32
80055d8: b9 a0 08 00 mv r1,r13
80055dc: fb ff fc d4 calli 800492c <_Chain_Get>
80055e0: b8 20 60 00 mv r12,r1
if ( information->auto_extend ) {
80055e4: 41 61 00 12 lbu r1,(r11+18)
/*
* 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 );
80055e8: b9 80 70 00 mv r14,r12
if ( information->auto_extend ) {
80055ec: 44 20 ff f2 be r1,r0,80055b4 <_Objects_Allocate+0x28>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
80055f0: 45 80 00 18 be r12,r0,8005650 <_Objects_Allocate+0xc4>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
80055f4: 2d 83 00 0a lhu r3,(r12+10)
80055f8: 2d 61 00 0a lhu r1,(r11+10)
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
80055fc: 2d 62 00 14 lhu r2,(r11+20)
8005600: c8 61 08 00 sub r1,r3,r1
8005604: f8 00 5a 81 calli 801c008 <__udivsi3>
information->inactive_per_block[ block ]--;
8005608: 29 62 00 30 lw r2,(r11+48)
800560c: b4 21 08 00 add r1,r1,r1
8005610: b4 21 08 00 add r1,r1,r1
8005614: b4 41 08 00 add r1,r2,r1
8005618: 28 22 00 00 lw r2,(r1+0)
information->inactive--;
800561c: 2d 63 00 2c lhu r3,(r11+44)
block = (uint32_t) _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
8005620: 34 42 ff ff addi r2,r2,-1
8005624: 58 22 00 00 sw (r1+0),r2
information->inactive--;
8005628: 34 61 ff ff addi r1,r3,-1
800562c: 0d 61 00 2c sh (r11+44),r1
);
}
#endif
return the_object;
}
8005630: b9 80 08 00 mv r1,r12
8005634: 2b 9d 00 04 lw ra,(sp+4)
8005638: 2b 8b 00 14 lw r11,(sp+20)
800563c: 2b 8c 00 10 lw r12,(sp+16)
8005640: 2b 8d 00 0c lw r13,(sp+12)
8005644: 2b 8e 00 08 lw r14,(sp+8)
8005648: 37 9c 00 14 addi sp,sp,20
800564c: c3 a0 00 00 ret
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
_Objects_Extend_information( information );
8005650: b9 60 08 00 mv r1,r11
8005654: f8 00 00 06 calli 800566c <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
8005658: b9 a0 08 00 mv r1,r13
800565c: fb ff fc b4 calli 800492c <_Chain_Get>
8005660: b8 20 60 00 mv r12,r1
}
if ( the_object ) {
8005664: 44 2e ff d4 be r1,r14,80055b4 <_Objects_Allocate+0x28>
8005668: e3 ff ff e3 bi 80055f4 <_Objects_Allocate+0x68>
0800566c <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
800566c: 37 9c ff c8 addi sp,sp,-56
8005670: 5b 8b 00 2c sw (sp+44),r11
8005674: 5b 8c 00 28 sw (sp+40),r12
8005678: 5b 8d 00 24 sw (sp+36),r13
800567c: 5b 8e 00 20 sw (sp+32),r14
8005680: 5b 8f 00 1c sw (sp+28),r15
8005684: 5b 90 00 18 sw (sp+24),r16
8005688: 5b 91 00 14 sw (sp+20),r17
800568c: 5b 92 00 10 sw (sp+16),r18
8005690: 5b 93 00 0c sw (sp+12),r19
8005694: 5b 94 00 08 sw (sp+8),r20
8005698: 5b 9d 00 04 sw (sp+4),ra
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
800569c: 28 2c 00 34 lw r12,(r1+52)
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
80056a0: b8 20 58 00 mv r11,r1
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
80056a4: 2c 30 00 0a lhu r16,(r1+10)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
80056a8: 45 80 00 9f be r12,r0,8005924 <_Objects_Extend_information+0x2b8>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
80056ac: 2c 2f 00 14 lhu r15,(r1+20)
80056b0: 2c 31 00 10 lhu r17,(r1+16)
80056b4: b9 e0 10 00 mv r2,r15
80056b8: ba 20 08 00 mv r1,r17
80056bc: f8 00 5a 53 calli 801c008 <__udivsi3>
80056c0: 20 2e ff ff andi r14,r1,0xffff
for ( ; block < block_count; block++ ) {
80056c4: 45 c0 00 b3 be r14,r0,8005990 <_Objects_Extend_information+0x324><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
80056c8: 29 81 00 00 lw r1,(r12+0)
80056cc: 44 20 00 b6 be r1,r0,80059a4 <_Objects_Extend_information+0x338><== NEVER TAKEN
80056d0: b9 80 18 00 mv r3,r12
80056d4: b9 e0 08 00 mv r1,r15
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
80056d8: ba 00 68 00 mv r13,r16
index_base = minimum_index;
block = 0;
80056dc: 34 0c 00 00 mvi r12,0
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
80056e0: 35 8c 00 01 addi r12,r12,1
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
80056e4: b5 af 68 00 add r13,r13,r15
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
80056e8: 55 cc 00 83 bgu r14,r12,80058f4 <_Objects_Extend_information+0x288>
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
80056ec: 34 0f 00 01 mvi r15,1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
80056f0: b6 21 88 00 add r17,r17,r1
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
80056f4: 38 02 ff ff mvu r2,0xffff
80056f8: 56 22 00 72 bgu r17,r2,80058c0 <_Objects_Extend_information+0x254><== NEVER TAKEN
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
80056fc: 29 62 00 18 lw r2,(r11+24)
8005700: f8 00 59 dd calli 801be74 <__mulsi3>
if ( information->auto_extend ) {
8005704: 41 62 00 12 lbu r2,(r11+18)
8005708: 44 40 00 80 be r2,r0,8005908 <_Objects_Extend_information+0x29c>
new_object_block = _Workspace_Allocate( block_size );
800570c: f8 00 0a 3e calli 8008004 <_Workspace_Allocate>
8005710: b8 20 90 00 mv r18,r1
if ( !new_object_block )
8005714: 44 20 00 6b be r1,r0,80058c0 <_Objects_Extend_information+0x254>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
8005718: 45 e0 00 43 be r15,r0,8005824 <_Objects_Extend_information+0x1b8>
*/
/*
* Up the block count and maximum
*/
block_count++;
800571c: 35 c1 00 01 addi r1,r14,1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
8005720: b4 21 98 00 add r19,r1,r1
8005724: b6 61 18 00 add r3,r19,r1
((maximum + minimum_index) * sizeof(Objects_Control *));
8005728: b6 23 18 00 add r3,r17,r3
if ( information->auto_extend ) {
800572c: 41 62 00 12 lbu r2,(r11+18)
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
8005730: b4 70 18 00 add r3,r3,r16
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
8005734: b4 63 18 00 add r3,r3,r3
8005738: b4 63 18 00 add r3,r3,r3
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
800573c: 44 40 00 76 be r2,r0,8005914 <_Objects_Extend_information+0x2a8>
object_blocks = _Workspace_Allocate( block_size );
8005740: b8 60 08 00 mv r1,r3
8005744: f8 00 0a 30 calli 8008004 <_Workspace_Allocate>
8005748: b8 20 78 00 mv r15,r1
if ( !object_blocks ) {
800574c: 44 20 00 8e be r1,r0,8005984 <_Objects_Extend_information+0x318>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
8005750: 2d 61 00 10 lhu r1,(r11+16)
/*
* Break the block into the various sections.
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
object_blocks, block_count * sizeof(void*) );
8005754: b6 73 a0 00 add r20,r19,r19
8005758: b5 f4 98 00 add r19,r15,r20
800575c: b6 74 a0 00 add r20,r19,r20
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
8005760: 54 30 00 77 bgu r1,r16,800593c <_Objects_Extend_information+0x2d0>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
8005764: ba 80 20 00 mv r4,r20
8005768: 34 03 00 00 mvi r3,0
800576c: 46 00 00 05 be r16,r0,8005780 <_Objects_Extend_information+0x114><== NEVER TAKEN
local_table[ index ] = NULL;
8005770: 58 80 00 00 sw (r4+0),r0
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
8005774: 34 63 00 01 addi r3,r3,1
8005778: 34 84 00 04 addi r4,r4,4
800577c: 56 03 ff fd bgu r16,r3,8005770 <_Objects_Extend_information+0x104><== NEVER TAKEN
8005780: b5 ce 70 00 add r14,r14,r14
8005784: b5 ce 70 00 add r14,r14,r14
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
8005788: 2d 65 00 14 lhu r5,(r11+20)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
800578c: b5 ee 08 00 add r1,r15,r14
8005790: 58 20 00 00 sw (r1+0),r0
inactive_per_block[block_count] = 0;
8005794: b6 6e 70 00 add r14,r19,r14
8005798: 59 c0 00 00 sw (r14+0),r0
for ( index=index_base ;
index < ( information->allocation_size + index_base );
800579c: b5 a5 28 00 add r5,r13,r5
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
80057a0: 51 a5 00 09 bgeu r13,r5,80057c4 <_Objects_Extend_information+0x158><== NEVER TAKEN
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
80057a4: b5 ad 20 00 add r4,r13,r13
80057a8: b4 84 20 00 add r4,r4,r4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
80057ac: b6 84 20 00 add r4,r20,r4
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
80057b0: b9 a0 18 00 mv r3,r13
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
80057b4: 58 80 00 00 sw (r4+0),r0
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
80057b8: 34 63 00 01 addi r3,r3,1
80057bc: 34 84 00 04 addi r4,r4,4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
80057c0: 54 a3 ff fd bgu r5,r3,80057b4 <_Objects_Extend_information+0x148>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
80057c4: 90 00 70 00 rcsr r14,IE
80057c8: 34 01 ff fe mvi r1,-2
80057cc: a1 c1 08 00 and r1,r14,r1
80057d0: d0 01 00 00 wcsr IE,r1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
80057d4: 29 61 00 00 lw r1,(r11+0)
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
80057d8: 22 31 ff ff andi r17,r17,0xffff
80057dc: 0d 71 00 10 sh (r11+16),r17
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
80057e0: 29 70 00 34 lw r16,(r11+52)
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
80057e4: 59 73 00 30 sw (r11+48),r19
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
80057e8: 59 6f 00 34 sw (r11+52),r15
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
80057ec: 59 74 00 1c sw (r11+28),r20
80057f0: 34 02 00 18 mvi r2,24
80057f4: f8 00 59 2b calli 801bca0 <__ashlsi3>
80057f8: 78 0f 00 01 mvhi r15,0x1
80057fc: b8 2f 78 00 or r15,r1,r15
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
8005800: 2d 61 00 04 lhu r1,(r11+4)
8005804: 34 02 00 1b mvi r2,27
8005808: f8 00 59 26 calli 801bca0 <__ashlsi3>
800580c: b9 e1 10 00 or r2,r15,r1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
8005810: b8 51 88 00 or r17,r2,r17
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
8005814: 59 71 00 0c sw (r11+12),r17
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
8005818: d0 0e 00 00 wcsr IE,r14
_Workspace_Free( old_tables );
800581c: ba 00 08 00 mv r1,r16
8005820: f8 00 0a 04 calli 8008030 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
8005824: 29 61 00 34 lw r1,(r11+52)
8005828: b5 8c 60 00 add r12,r12,r12
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
800582c: 2d 63 00 14 lhu r3,(r11+20)
8005830: 29 64 00 18 lw r4,(r11+24)
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
8005834: b5 8c 60 00 add r12,r12,r12
8005838: b4 2c 08 00 add r1,r1,r12
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
800583c: 37 90 00 30 addi r16,sp,48
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
8005840: 58 32 00 00 sw (r1+0),r18
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
8005844: ba 40 10 00 mv r2,r18
8005848: ba 00 08 00 mv r1,r16
800584c: fb ff fc 49 calli 8004970 <_Chain_Initialize>
8005850: 78 12 00 01 mvhi r18,0x1
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
8005854: 35 71 00 20 addi r17,r11,32
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
8005858: e0 00 00 0e bi 8005890 <_Objects_Extend_information+0x224>
800585c: 29 61 00 00 lw r1,(r11+0)
8005860: f8 00 59 10 calli 801bca0 <__ashlsi3>
8005864: b8 32 78 00 or r15,r1,r18
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
8005868: 2d 61 00 04 lhu r1,(r11+4)
800586c: 34 02 00 1b mvi r2,27
8005870: f8 00 59 0c calli 801bca0 <__ashlsi3>
8005874: b9 e1 10 00 or r2,r15,r1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
8005878: b8 4d 10 00 or r2,r2,r13
the_object->id = _Objects_Build_id(
800587c: 59 c2 00 08 sw (r14+8),r2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
8005880: ba 20 08 00 mv r1,r17
8005884: b9 c0 10 00 mv r2,r14
8005888: fb ff fc 1d calli 80048fc <_Chain_Append>
index++;
800588c: 35 ad 00 01 addi r13,r13,1
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
8005890: ba 00 08 00 mv r1,r16
8005894: fb ff fc 26 calli 800492c <_Chain_Get>
8005898: b8 20 70 00 mv r14,r1
800589c: 34 02 00 18 mvi r2,24
80058a0: 5c 20 ff ef bne r1,r0,800585c <_Objects_Extend_information+0x1f0>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
80058a4: 29 63 00 30 lw r3,(r11+48)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
80058a8: 2d 62 00 2c lhu r2,(r11+44)
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
80058ac: 2d 61 00 14 lhu r1,(r11+20)
80058b0: b4 6c 60 00 add r12,r3,r12
80058b4: 59 81 00 00 sw (r12+0),r1
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
80058b8: b4 22 08 00 add r1,r1,r2
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
80058bc: 0d 61 00 2c sh (r11+44),r1
(Objects_Maximum)(information->inactive + information->allocation_size);
}
80058c0: 2b 9d 00 04 lw ra,(sp+4)
80058c4: 2b 8b 00 2c lw r11,(sp+44)
80058c8: 2b 8c 00 28 lw r12,(sp+40)
80058cc: 2b 8d 00 24 lw r13,(sp+36)
80058d0: 2b 8e 00 20 lw r14,(sp+32)
80058d4: 2b 8f 00 1c lw r15,(sp+28)
80058d8: 2b 90 00 18 lw r16,(sp+24)
80058dc: 2b 91 00 14 lw r17,(sp+20)
80058e0: 2b 92 00 10 lw r18,(sp+16)
80058e4: 2b 93 00 0c lw r19,(sp+12)
80058e8: 2b 94 00 08 lw r20,(sp+8)
80058ec: 37 9c 00 38 addi sp,sp,56
80058f0: c3 a0 00 00 ret
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
80058f4: 28 62 00 04 lw r2,(r3+4)
80058f8: 34 63 00 04 addi r3,r3,4
80058fc: 5c 40 ff 79 bne r2,r0,80056e0 <_Objects_Extend_information+0x74>
do_extend = false;
8005900: 34 0f 00 00 mvi r15,0
8005904: e3 ff ff 7b bi 80056f0 <_Objects_Extend_information+0x84>
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
8005908: f8 00 09 d3 calli 8008054 <_Workspace_Allocate_or_fatal_error>
800590c: b8 20 90 00 mv r18,r1
8005910: e3 ff ff 82 bi 8005718 <_Objects_Extend_information+0xac>
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
return;
}
} else {
object_blocks = _Workspace_Allocate_or_fatal_error( block_size );
8005914: b8 60 08 00 mv r1,r3
8005918: f8 00 09 cf calli 8008054 <_Workspace_Allocate_or_fatal_error>
800591c: b8 20 78 00 mv r15,r1
8005920: e3 ff ff 8c bi 8005750 <_Objects_Extend_information+0xe4>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
8005924: 2c 31 00 10 lhu r17,(r1+16)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
8005928: ba 00 68 00 mv r13,r16
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
800592c: 2c 21 00 14 lhu r1,(r1+20)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
8005930: 34 0f 00 01 mvi r15,1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
8005934: 34 0e 00 00 mvi r14,0
8005938: e3 ff ff 6e bi 80056f0 <_Objects_Extend_information+0x84>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
800593c: 29 62 00 34 lw r2,(r11+52)
information->object_blocks,
block_count * sizeof(void*) );
8005940: b5 ce 70 00 add r14,r14,r14
8005944: b5 ce 70 00 add r14,r14,r14
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
8005948: b9 c0 18 00 mv r3,r14
800594c: b9 e0 08 00 mv r1,r15
8005950: f8 00 21 43 calli 800de5c <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
8005954: 29 62 00 30 lw r2,(r11+48)
8005958: b9 c0 18 00 mv r3,r14
800595c: ba 60 08 00 mv r1,r19
8005960: f8 00 21 3f calli 800de5c <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
8005964: 2d 63 00 10 lhu r3,(r11+16)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
8005968: 29 62 00 1c lw r2,(r11+28)
800596c: ba 80 08 00 mv r1,r20
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
8005970: b6 03 18 00 add r3,r16,r3
8005974: b4 63 18 00 add r3,r3,r3
8005978: b4 63 18 00 add r3,r3,r3
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
800597c: f8 00 21 38 calli 800de5c <memcpy>
8005980: e3 ff ff 82 bi 8005788 <_Objects_Extend_information+0x11c>
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
object_blocks = _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
8005984: ba 40 08 00 mv r1,r18
8005988: f8 00 09 aa calli 8008030 <_Workspace_Free>
return;
800598c: e3 ff ff cd bi 80058c0 <_Objects_Extend_information+0x254>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
8005990: b9 e0 08 00 mv r1,r15 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
8005994: ba 00 68 00 mv r13,r16 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
8005998: 34 0f 00 01 mvi r15,1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
800599c: 34 0c 00 00 mvi r12,0 <== NOT EXECUTED
80059a0: e3 ff ff 54 bi 80056f0 <_Objects_Extend_information+0x84> <== NOT EXECUTED
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
80059a4: b9 e0 08 00 mv r1,r15 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
80059a8: ba 00 68 00 mv r13,r16 <== NOT EXECUTED
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
80059ac: 34 0f 00 00 mvi r15,0 <== NOT EXECUTED
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
80059b0: 34 0c 00 00 mvi r12,0 <== NOT EXECUTED
80059b4: e3 ff ff 4f bi 80056f0 <_Objects_Extend_information+0x84> <== NOT EXECUTED
08005aa0 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
8005aa0: 37 9c ff f0 addi sp,sp,-16
8005aa4: 5b 8b 00 10 sw (sp+16),r11
8005aa8: 5b 8c 00 0c sw (sp+12),r12
8005aac: 5b 8d 00 08 sw (sp+8),r13
8005ab0: 5b 9d 00 04 sw (sp+4),ra
8005ab4: 20 4c ff ff andi r12,r2,0xffff
8005ab8: b8 20 68 00 mv r13,r1
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
8005abc: 34 0b 00 00 mvi r11,0
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
8005ac0: 5d 80 00 08 bne r12,r0,8005ae0 <_Objects_Get_information+0x40>
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
8005ac4: b9 60 08 00 mv r1,r11
8005ac8: 2b 9d 00 04 lw ra,(sp+4)
8005acc: 2b 8b 00 10 lw r11,(sp+16)
8005ad0: 2b 8c 00 0c lw r12,(sp+12)
8005ad4: 2b 8d 00 08 lw r13,(sp+8)
8005ad8: 37 9c 00 10 addi sp,sp,16
8005adc: c3 a0 00 00 ret
/*
* 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 );
8005ae0: f8 00 15 13 calli 800af2c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
8005ae4: 44 20 ff f8 be r1,r0,8005ac4 <_Objects_Get_information+0x24>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
8005ae8: 55 81 ff f7 bgu r12,r1,8005ac4 <_Objects_Get_information+0x24>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
8005aec: 78 01 08 02 mvhi r1,0x802
8005af0: b5 ad 68 00 add r13,r13,r13
8005af4: 38 21 08 f4 ori r1,r1,0x8f4
8005af8: b5 ad 68 00 add r13,r13,r13
8005afc: b4 2d 08 00 add r1,r1,r13
8005b00: 28 21 00 00 lw r1,(r1+0)
8005b04: 44 20 ff f0 be r1,r0,8005ac4 <_Objects_Get_information+0x24><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
8005b08: b5 8c 60 00 add r12,r12,r12
8005b0c: b5 8c 60 00 add r12,r12,r12
8005b10: b4 2c 08 00 add r1,r1,r12
8005b14: 28 2b 00 00 lw r11,(r1+0)
if ( !info )
8005b18: 45 60 ff eb be r11,r0,8005ac4 <_Objects_Get_information+0x24><== NEVER TAKEN
* In a multprocessing configuration, we may access remote objects.
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
8005b1c: 2d 61 00 10 lhu r1,(r11+16)
return NULL;
8005b20: 7c 21 00 00 cmpnei r1,r1,0
8005b24: c8 01 08 00 sub r1,r0,r1
8005b28: a1 61 58 00 and r11,r11,r1
8005b2c: e3 ff ff e6 bi 8005ac4 <_Objects_Get_information+0x24>
0801624c <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
801624c: 37 9c ff e0 addi sp,sp,-32
8016250: 5b 8b 00 14 sw (sp+20),r11
8016254: 5b 8c 00 10 sw (sp+16),r12
8016258: 5b 8d 00 0c sw (sp+12),r13
801625c: 5b 8e 00 08 sw (sp+8),r14
8016260: 5b 9d 00 04 sw (sp+4),ra
8016264: b8 40 60 00 mv r12,r2
8016268: b8 60 58 00 mv r11,r3
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
801626c: 5c 40 00 0a bne r2,r0,8016294 <_Objects_Get_name_as_string+0x48>
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
8016270: 34 0b 00 00 mvi r11,0
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
8016274: b9 60 08 00 mv r1,r11
8016278: 2b 9d 00 04 lw ra,(sp+4)
801627c: 2b 8b 00 14 lw r11,(sp+20)
8016280: 2b 8c 00 10 lw r12,(sp+16)
8016284: 2b 8d 00 0c lw r13,(sp+12)
8016288: 2b 8e 00 08 lw r14,(sp+8)
801628c: 37 9c 00 20 addi sp,sp,32
8016290: c3 a0 00 00 ret
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
8016294: 44 60 ff f8 be r3,r0,8016274 <_Objects_Get_name_as_string+0x28>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
8016298: b8 20 68 00 mv r13,r1
801629c: 5c 20 00 05 bne r1,r0,80162b0 <_Objects_Get_name_as_string+0x64>
80162a0: 78 01 08 03 mvhi r1,0x803
80162a4: 38 21 57 00 ori r1,r1,0x5700
80162a8: 28 21 00 10 lw r1,(r1+16)
80162ac: 28 2d 00 08 lw r13,(r1+8)
information = _Objects_Get_information_id( tmpId );
80162b0: b9 a0 08 00 mv r1,r13
80162b4: fb ff db 1c calli 800cf24 <_Objects_Get_information_id>
80162b8: b8 20 70 00 mv r14,r1
if ( !information )
80162bc: 44 20 ff ed be r1,r0,8016270 <_Objects_Get_name_as_string+0x24>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
80162c0: b9 a0 10 00 mv r2,r13
80162c4: 37 83 00 20 addi r3,sp,32
80162c8: fb ff db 69 calli 800d06c <_Objects_Get>
switch ( location ) {
80162cc: 2b 82 00 20 lw r2,(sp+32)
80162d0: 5c 40 ff e8 bne r2,r0,8016270 <_Objects_Get_name_as_string+0x24>
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
80162d4: 41 c3 00 38 lbu r3,(r14+56)
80162d8: 44 62 00 1c be r3,r2,8016348 <_Objects_Get_name_as_string+0xfc>
s = the_object->name.name_p;
80162dc: 28 27 00 0c lw r7,(r1+12)
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
80162e0: b9 60 10 00 mv r2,r11
80162e4: 44 e0 00 16 be r7,r0,801633c <_Objects_Get_name_as_string+0xf0>
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
80162e8: 35 8c ff ff addi r12,r12,-1
80162ec: b9 60 10 00 mv r2,r11
80162f0: 45 80 00 13 be r12,r0,801633c <_Objects_Get_name_as_string+0xf0><== NEVER TAKEN
80162f4: 40 e1 00 00 lbu r1,(r7+0)
80162f8: 44 20 00 11 be r1,r0,801633c <_Objects_Get_name_as_string+0xf0>
80162fc: 78 04 08 03 mvhi r4,0x803
8016300: 34 03 00 00 mvi r3,0
8016304: 38 84 44 48 ori r4,r4,0x4448
*d = (isprint((unsigned char)*s)) ? *s : '*';
8016308: 28 85 00 00 lw r5,(r4+0)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
801630c: 34 63 00 01 addi r3,r3,1
* This method objects the name of an object and returns its name
* in the form of a C string. It attempts to be careful about
* overflowing the user's string and about returning unprintable characters.
*/
char *_Objects_Get_name_as_string(
8016310: b4 e3 30 00 add r6,r7,r3
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint((unsigned char)*s)) ? *s : '*';
8016314: b4 a1 28 00 add r5,r5,r1
8016318: 40 a5 00 01 lbu r5,(r5+1)
801631c: 20 a5 00 97 andi r5,r5,0x97
8016320: 5c a0 00 02 bne r5,r0,8016328 <_Objects_Get_name_as_string+0xdc>
8016324: 34 01 00 2a mvi r1,42
8016328: 30 41 00 00 sb (r2+0),r1
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
801632c: 34 42 00 01 addi r2,r2,1
8016330: 50 6c 00 03 bgeu r3,r12,801633c <_Objects_Get_name_as_string+0xf0>
8016334: 40 c1 00 00 lbu r1,(r6+0)
8016338: 5c 20 ff f4 bne r1,r0,8016308 <_Objects_Get_name_as_string+0xbc>
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
801633c: 30 40 00 00 sb (r2+0),r0
_Thread_Enable_dispatch();
8016340: fb ff e0 02 calli 800e348 <_Thread_Enable_dispatch>
return name;
8016344: e3 ff ff cc bi 8016274 <_Objects_Get_name_as_string+0x28>
if ( information->is_string ) {
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
8016348: 28 2d 00 0c lw r13,(r1+12)
lname[ 0 ] = (u32_name >> 24) & 0xff;
801634c: 34 02 00 18 mvi r2,24
8016350: b9 a0 08 00 mv r1,r13
8016354: f8 00 5e ed calli 802df08 <__lshrsi3>
8016358: 33 81 00 18 sb (sp+24),r1
lname[ 1 ] = (u32_name >> 16) & 0xff;
801635c: 34 02 00 10 mvi r2,16
8016360: b9 a0 08 00 mv r1,r13
8016364: f8 00 5e e9 calli 802df08 <__lshrsi3>
lname[ 2 ] = (u32_name >> 8) & 0xff;
8016368: 01 a2 00 01 srui r2,r13,1
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
801636c: 33 81 00 19 sb (sp+25),r1
lname[ 2 ] = (u32_name >> 8) & 0xff;
8016370: 00 42 00 01 srui r2,r2,1
lname[ 3 ] = (u32_name >> 0) & 0xff;
8016374: 33 8d 00 1b sb (sp+27),r13
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
8016378: 00 42 00 01 srui r2,r2,1
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
801637c: 33 80 00 1c sb (sp+28),r0
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
8016380: 00 42 00 01 srui r2,r2,1
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
s = lname;
8016384: 37 87 00 18 addi r7,sp,24
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
8016388: 00 42 00 01 srui r2,r2,1
801638c: 00 42 00 01 srui r2,r2,1
8016390: 00 42 00 01 srui r2,r2,1
8016394: 00 42 00 01 srui r2,r2,1
8016398: 33 82 00 1a sb (sp+26),r2
801639c: e3 ff ff d3 bi 80162e8 <_Objects_Get_name_as_string+0x9c>
08018ca4 <_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;
8018ca4: 28 25 00 08 lw r5,(r1+8)
if ( information->maximum >= index ) {
8018ca8: 2c 24 00 10 lhu r4,(r1+16)
/*
* 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;
8018cac: c8 45 10 00 sub r2,r2,r5
8018cb0: 34 42 00 01 addi r2,r2,1
if ( information->maximum >= index ) {
8018cb4: 54 44 00 09 bgu r2,r4,8018cd8 <_Objects_Get_no_protection+0x34>
if ( (the_object = information->local_table[ index ]) != NULL ) {
8018cb8: 28 24 00 1c lw r4,(r1+28)
8018cbc: b4 42 08 00 add r1,r2,r2
8018cc0: b4 21 08 00 add r1,r1,r1
8018cc4: b4 81 08 00 add r1,r4,r1
8018cc8: 28 21 00 00 lw r1,(r1+0)
8018ccc: 44 20 00 03 be r1,r0,8018cd8 <_Objects_Get_no_protection+0x34><== NEVER TAKEN
*location = OBJECTS_LOCAL;
8018cd0: 58 60 00 00 sw (r3+0),r0
return the_object;
8018cd4: c3 a0 00 00 ret
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
8018cd8: 34 01 00 01 mvi r1,1
8018cdc: 58 61 00 00 sw (r3+0),r1
return NULL;
8018ce0: 34 01 00 00 mvi r1,0
}
8018ce4: c3 a0 00 00 ret
0800d104 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
800d104: 37 9c ff e8 addi sp,sp,-24
800d108: 5b 8b 00 14 sw (sp+20),r11
800d10c: 5b 8c 00 10 sw (sp+16),r12
800d110: 5b 8d 00 0c sw (sp+12),r13
800d114: 5b 8e 00 08 sw (sp+8),r14
800d118: 5b 9d 00 04 sw (sp+4),ra
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
800d11c: b8 20 58 00 mv r11,r1
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
800d120: b8 40 70 00 mv r14,r2
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
800d124: 5c 20 00 05 bne r1,r0,800d138 <_Objects_Id_to_name+0x34>
800d128: 78 01 08 03 mvhi r1,0x803
800d12c: 38 21 57 00 ori r1,r1,0x5700
800d130: 28 21 00 10 lw r1,(r1+16)
800d134: 28 2b 00 08 lw r11,(r1+8)
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
800d138: b9 60 08 00 mv r1,r11
800d13c: 34 02 00 18 mvi r2,24
800d140: f8 00 83 72 calli 802df08 <__lshrsi3>
800d144: 20 23 00 07 andi r3,r1,0x7
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
800d148: 34 64 ff ff addi r4,r3,-1
800d14c: 34 01 00 02 mvi r1,2
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
800d150: 34 0c 00 03 mvi r12,3
800d154: 54 81 00 12 bgu r4,r1,800d19c <_Objects_Id_to_name+0x98>
if ( !_Objects_Information_table[ the_api ] )
800d158: 78 04 08 03 mvhi r4,0x803
800d15c: b4 63 18 00 add r3,r3,r3
800d160: 38 84 51 d4 ori r4,r4,0x51d4
800d164: b4 63 18 00 add r3,r3,r3
800d168: b4 83 18 00 add r3,r4,r3
800d16c: 28 6d 00 00 lw r13,(r3+0)
800d170: 45 a0 00 0b be r13,r0,800d19c <_Objects_Id_to_name+0x98>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
800d174: b9 60 08 00 mv r1,r11
800d178: 34 02 00 1b mvi r2,27
800d17c: f8 00 83 63 calli 802df08 <__lshrsi3>
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
800d180: b4 21 18 00 add r3,r1,r1
800d184: b4 63 18 00 add r3,r3,r3
800d188: b5 a3 18 00 add r3,r13,r3
800d18c: 28 63 00 00 lw r3,(r3+0)
if ( !information )
800d190: 44 60 00 03 be r3,r0,800d19c <_Objects_Id_to_name+0x98> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
800d194: 40 6d 00 38 lbu r13,(r3+56)
800d198: 45 a0 00 09 be r13,r0,800d1bc <_Objects_Id_to_name+0xb8> <== ALWAYS TAKEN
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
800d19c: b9 80 08 00 mv r1,r12
800d1a0: 2b 9d 00 04 lw ra,(sp+4)
800d1a4: 2b 8b 00 14 lw r11,(sp+20)
800d1a8: 2b 8c 00 10 lw r12,(sp+16)
800d1ac: 2b 8d 00 0c lw r13,(sp+12)
800d1b0: 2b 8e 00 08 lw r14,(sp+8)
800d1b4: 37 9c 00 18 addi sp,sp,24
800d1b8: c3 a0 00 00 ret
#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 );
800d1bc: b8 60 08 00 mv r1,r3
800d1c0: b9 60 10 00 mv r2,r11
800d1c4: 37 83 00 18 addi r3,sp,24
800d1c8: fb ff ff a9 calli 800d06c <_Objects_Get>
if ( !the_object )
800d1cc: 44 2d ff f4 be r1,r13,800d19c <_Objects_Id_to_name+0x98>
return OBJECTS_INVALID_ID;
*name = the_object->name;
800d1d0: 28 21 00 0c lw r1,(r1+12)
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
800d1d4: 34 0c 00 00 mvi r12,0
the_object = _Objects_Get( information, tmpId, &ignored_location );
if ( !the_object )
return OBJECTS_INVALID_ID;
*name = the_object->name;
800d1d8: 59 c1 00 00 sw (r14+0),r1
_Thread_Enable_dispatch();
800d1dc: f8 00 04 5b calli 800e348 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
800d1e0: b9 80 08 00 mv r1,r12
800d1e4: 2b 9d 00 04 lw ra,(sp+4)
800d1e8: 2b 8b 00 14 lw r11,(sp+20)
800d1ec: 2b 8c 00 10 lw r12,(sp+16)
800d1f0: 2b 8d 00 0c lw r13,(sp+12)
800d1f4: 2b 8e 00 08 lw r14,(sp+8)
800d1f8: 37 9c 00 18 addi sp,sp,24
800d1fc: c3 a0 00 00 ret
08005de4 <_Objects_Shrink_information>:
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
8005de4: 37 9c ff ec addi sp,sp,-20
8005de8: 5b 8b 00 14 sw (sp+20),r11
8005dec: 5b 8c 00 10 sw (sp+16),r12
8005df0: 5b 8d 00 0c sw (sp+12),r13
8005df4: 5b 8e 00 08 sw (sp+8),r14
8005df8: 5b 9d 00 04 sw (sp+4),ra
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
8005dfc: 2c 2c 00 0a lhu r12,(r1+10)
block_count = (information->maximum - index_base) /
8005e00: 2c 2d 00 14 lhu r13,(r1+20)
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
8005e04: b8 20 70 00 mv r14,r1
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
8005e08: 2c 21 00 10 lhu r1,(r1+16)
8005e0c: b9 a0 10 00 mv r2,r13
8005e10: c8 2c 08 00 sub r1,r1,r12
8005e14: f8 00 58 7d calli 801c008 <__udivsi3>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
8005e18: 44 20 00 09 be r1,r0,8005e3c <_Objects_Shrink_information+0x58><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
8005e1c: 29 c5 00 30 lw r5,(r14+48)
8005e20: 34 0b 00 04 mvi r11,4
8005e24: 34 03 00 00 mvi r3,0
8005e28: 28 a2 00 00 lw r2,(r5+0)
8005e2c: 45 a2 00 11 be r13,r2,8005e70 <_Objects_Shrink_information+0x8c><== NEVER TAKEN
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
8005e30: 34 63 00 01 addi r3,r3,1
#include <rtems/score/thread.h>
#include <rtems/score/wkspace.h>
#include <rtems/score/sysstate.h>
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
8005e34: b4 ab 10 00 add r2,r5,r11
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
8005e38: 54 23 00 08 bgu r1,r3,8005e58 <_Objects_Shrink_information+0x74>
return;
}
index_base += information->allocation_size;
}
}
8005e3c: 2b 9d 00 04 lw ra,(sp+4)
8005e40: 2b 8b 00 14 lw r11,(sp+20)
8005e44: 2b 8c 00 10 lw r12,(sp+16)
8005e48: 2b 8d 00 0c lw r13,(sp+12)
8005e4c: 2b 8e 00 08 lw r14,(sp+8)
8005e50: 37 9c 00 14 addi sp,sp,20
8005e54: c3 a0 00 00 ret
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
8005e58: 28 42 00 00 lw r2,(r2+0)
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
8005e5c: 35 64 00 04 addi r4,r11,4
8005e60: b5 8d 60 00 add r12,r12,r13
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
8005e64: 45 a2 00 04 be r13,r2,8005e74 <_Objects_Shrink_information+0x90>
8005e68: b8 80 58 00 mv r11,r4
8005e6c: e3 ff ff f1 bi 8005e30 <_Objects_Shrink_information+0x4c>
8005e70: 34 0b 00 00 mvi r11,0 <== NOT EXECUTED
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
8005e74: 29 c1 00 20 lw r1,(r14+32)
do {
index = _Objects_Get_index( the_object->id );
8005e78: 2c 22 00 0a lhu r2,(r1+10)
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
8005e7c: 28 2d 00 00 lw r13,(r1+0)
if ((index >= index_base) &&
8005e80: 55 82 00 05 bgu r12,r2,8005e94 <_Objects_Shrink_information+0xb0>
(index < (index_base + information->allocation_size))) {
8005e84: 2d c3 00 14 lhu r3,(r14+20)
8005e88: b5 83 18 00 add r3,r12,r3
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
8005e8c: 50 43 00 02 bgeu r2,r3,8005e94 <_Objects_Shrink_information+0xb0>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
8005e90: f8 00 12 cf calli 800a9cc <_Chain_Extract>
}
}
while ( the_object );
8005e94: 45 a0 00 03 be r13,r0,8005ea0 <_Objects_Shrink_information+0xbc>
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
8005e98: b9 a0 08 00 mv r1,r13
8005e9c: e3 ff ff f7 bi 8005e78 <_Objects_Shrink_information+0x94>
while ( the_object );
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
8005ea0: 29 c1 00 34 lw r1,(r14+52)
8005ea4: b4 2b 08 00 add r1,r1,r11
8005ea8: 28 21 00 00 lw r1,(r1+0)
8005eac: f8 00 08 61 calli 8008030 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
8005eb0: 29 c2 00 34 lw r2,(r14+52)
information->inactive_per_block[ block ] = 0;
8005eb4: 29 c4 00 30 lw r4,(r14+48)
information->inactive -= information->allocation_size;
8005eb8: 2d c3 00 2c lhu r3,(r14+44)
8005ebc: 2d c1 00 14 lhu r1,(r14+20)
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
8005ec0: b4 4b 10 00 add r2,r2,r11
8005ec4: 58 40 00 00 sw (r2+0),r0
information->inactive_per_block[ block ] = 0;
8005ec8: b4 8b 58 00 add r11,r4,r11
8005ecc: 59 60 00 00 sw (r11+0),r0
information->inactive -= information->allocation_size;
8005ed0: c8 61 08 00 sub r1,r3,r1
8005ed4: 0d c1 00 2c sh (r14+44),r1
return;
}
index_base += information->allocation_size;
}
}
8005ed8: 2b 9d 00 04 lw ra,(sp+4)
8005edc: 2b 8b 00 14 lw r11,(sp+20)
8005ee0: 2b 8c 00 10 lw r12,(sp+16)
8005ee4: 2b 8d 00 0c lw r13,(sp+12)
8005ee8: 2b 8e 00 08 lw r14,(sp+8)
8005eec: 37 9c 00 14 addi sp,sp,20
8005ef0: c3 a0 00 00 ret
0800c854 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
800c854: 37 9c ff e8 addi sp,sp,-24
800c858: 5b 8b 00 18 sw (sp+24),r11
800c85c: 5b 8c 00 14 sw (sp+20),r12
800c860: 5b 8d 00 10 sw (sp+16),r13
800c864: 5b 8e 00 0c sw (sp+12),r14
800c868: 5b 8f 00 08 sw (sp+8),r15
800c86c: 5b 9d 00 04 sw (sp+4),ra
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
800c870: 28 2e 00 08 lw r14,(r1+8)
800c874: 34 02 00 18 mvi r2,24
800c878: 78 0b 08 02 mvhi r11,0x802
800c87c: b9 c0 08 00 mv r1,r14
800c880: f8 00 3d 56 calli 801bdd8 <__lshrsi3>
800c884: 20 21 00 07 andi r1,r1,0x7
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
800c888: 21 ce ff ff andi r14,r14,0xffff
800c88c: 34 21 00 04 addi r1,r1,4
800c890: b5 ce 70 00 add r14,r14,r14
800c894: b4 21 08 00 add r1,r1,r1
800c898: b5 ce 70 00 add r14,r14,r14
800c89c: 39 6b 0c ac ori r11,r11,0xcac
800c8a0: b4 21 78 00 add r15,r1,r1
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
800c8a4: 2d 6c 00 10 lhu r12,(r11+16)
done = true;
for ( index = 1 ; index <= max ; ++index ) {
800c8a8: 5d 80 00 09 bne r12,r0,800c8cc <_POSIX_Keys_Run_destructors+0x78>
done = false;
}
}
}
}
}
800c8ac: 2b 9d 00 04 lw ra,(sp+4)
800c8b0: 2b 8b 00 18 lw r11,(sp+24)
800c8b4: 2b 8c 00 14 lw r12,(sp+20)
800c8b8: 2b 8d 00 10 lw r13,(sp+16)
800c8bc: 2b 8e 00 0c lw r14,(sp+12)
800c8c0: 2b 8f 00 08 lw r15,(sp+8)
800c8c4: 37 9c 00 18 addi sp,sp,24
800c8c8: c3 a0 00 00 ret
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
800c8cc: 34 0d 00 01 mvi r13,1
800c8d0: 34 03 00 01 mvi r3,1
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
800c8d4: 29 62 00 1c lw r2,(r11+28)
800c8d8: b5 ad 08 00 add r1,r13,r13
800c8dc: b4 21 08 00 add r1,r1,r1
800c8e0: b4 41 08 00 add r1,r2,r1
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
800c8e4: 28 21 00 00 lw r1,(r1+0)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
800c8e8: b4 2f 10 00 add r2,r1,r15
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
800c8ec: 44 20 00 0b be r1,r0,800c918 <_POSIX_Keys_Run_destructors+0xc4>
800c8f0: 28 24 00 10 lw r4,(r1+16)
800c8f4: 44 80 00 09 be r4,r0,800c918 <_POSIX_Keys_Run_destructors+0xc4>
void *value = key->Values [ thread_api ][ thread_index ];
800c8f8: 28 42 00 04 lw r2,(r2+4)
800c8fc: b4 4e 10 00 add r2,r2,r14
800c900: 28 45 00 00 lw r5,(r2+0)
if ( value != NULL ) {
key->Values [ thread_api ][ thread_index ] = NULL;
(*key->destructor)( value );
800c904: b8 a0 08 00 mv r1,r5
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
if ( value != NULL ) {
800c908: 44 a0 00 04 be r5,r0,800c918 <_POSIX_Keys_Run_destructors+0xc4><== ALWAYS TAKEN
key->Values [ thread_api ][ thread_index ] = NULL;
800c90c: 58 40 00 00 sw (r2+0),r0 <== NOT EXECUTED
(*key->destructor)( value );
800c910: d8 80 00 00 call r4 <== NOT EXECUTED
done = false;
800c914: 34 03 00 00 mvi r3,0 <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
800c918: 35 ad 00 01 addi r13,r13,1
800c91c: 21 ad ff ff andi r13,r13,0xffff
800c920: 51 8d ff ed bgeu r12,r13,800c8d4 <_POSIX_Keys_Run_destructors+0x80>
* number of iterations. An infinite loop may happen if destructors set
* thread specific data. This can be considered dubious.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
800c924: 44 60 ff e0 be r3,r0,800c8a4 <_POSIX_Keys_Run_destructors+0x50><== NEVER TAKEN
800c928: e3 ff ff e1 bi 800c8ac <_POSIX_Keys_Run_destructors+0x58>
0800bd9c <_POSIX_Message_queue_Create_support>:
size_t name_len,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
800bd9c: 37 9c ff dc addi sp,sp,-36
800bda0: 5b 8b 00 20 sw (sp+32),r11
800bda4: 5b 8c 00 1c sw (sp+28),r12
800bda8: 5b 8d 00 18 sw (sp+24),r13
800bdac: 5b 8e 00 14 sw (sp+20),r14
800bdb0: 5b 8f 00 10 sw (sp+16),r15
800bdb4: 5b 90 00 0c sw (sp+12),r16
800bdb8: 5b 91 00 08 sw (sp+8),r17
800bdbc: 5b 9d 00 04 sw (sp+4),ra
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
800bdc0: 78 06 08 02 mvhi r6,0x802
800bdc4: 38 c6 53 28 ori r6,r6,0x5328
800bdc8: 28 c7 00 00 lw r7,(r6+0)
800bdcc: b8 20 68 00 mv r13,r1
800bdd0: b8 60 80 00 mv r16,r3
++level;
800bdd4: 34 e7 00 01 addi r7,r7,1
_Thread_Dispatch_disable_level = level;
800bdd8: 58 c7 00 00 sw (r6+0),r7
800bddc: b8 a0 88 00 mv r17,r5
* There is no real basis for the default values. They will work
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
800bde0: 44 80 00 0c be r4,r0,800be10 <_POSIX_Message_queue_Create_support+0x74>
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
800bde4: 28 8e 00 04 lw r14,(r4+4)
800bde8: 49 c0 00 07 bg r14,r0,800be04 <_POSIX_Message_queue_Create_support+0x68>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
_Thread_Enable_dispatch();
800bdec: fb ff f3 f8 calli 8008dcc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
800bdf0: f8 00 0e 72 calli 800f7b8 <__errno>
800bdf4: 34 02 00 16 mvi r2,22
800bdf8: 58 22 00 00 sw (r1+0),r2
800bdfc: 34 01 ff ff mvi r1,-1
800be00: e0 00 00 29 bi 800bea4 <_POSIX_Message_queue_Create_support+0x108>
if ( attr_ptr->mq_maxmsg <= 0 ){
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
800be04: 28 8f 00 08 lw r15,(r4+8)
800be08: 49 e0 00 04 bg r15,r0,800be18 <_POSIX_Message_queue_Create_support+0x7c>
800be0c: e3 ff ff f8 bi 800bdec <_POSIX_Message_queue_Create_support+0x50>
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
800be10: 34 0f 00 10 mvi r15,16
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
800be14: 34 0e 00 0a mvi r14,10
RTEMS_INLINE_ROUTINE
POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void )
{
return (POSIX_Message_queue_Control *)
_Objects_Allocate( &_POSIX_Message_queue_Information );
800be18: 78 0c 08 02 mvhi r12,0x802
800be1c: 39 8c 55 e4 ori r12,r12,0x55e4
800be20: b9 80 08 00 mv r1,r12
800be24: 5b 82 00 24 sw (sp+36),r2
800be28: fb ff ee 50 calli 8007768 <_Objects_Allocate>
800be2c: b8 20 58 00 mv r11,r1
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
800be30: 2b 82 00 24 lw r2,(sp+36)
800be34: 44 20 00 3a be r1,r0,800bf1c <_POSIX_Message_queue_Create_support+0x180><== NEVER TAKEN
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
name = _Workspace_String_duplicate( name_arg, name_len );
800be38: b9 a0 08 00 mv r1,r13
800be3c: f8 00 07 66 calli 800dbd4 <_Workspace_String_duplicate>
800be40: b8 20 68 00 mv r13,r1
if ( !name ) {
800be44: 44 20 00 2d be r1,r0,800bef8 <_POSIX_Message_queue_Create_support+0x15c>
rtems_set_errno_and_return_minus_one( ENOMEM );
}
the_mq->process_shared = pshared;
the_mq->named = true;
the_mq->open_count = 1;
800be48: 34 01 00 01 mvi r1,1
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
the_mq->process_shared = pshared;
the_mq->named = true;
800be4c: 34 02 00 01 mvi r2,1
800be50: 31 62 00 14 sb (r11+20),r2
the_mq->open_count = 1;
800be54: 59 61 00 18 sw (r11+24),r1
the_mq->linked = true;
800be58: 31 61 00 15 sb (r11+21),r1
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
the_mq->process_shared = pshared;
800be5c: 59 70 00 10 sw (r11+16),r16
*
* Joel: Cite POSIX or OpenGroup on above statement so we can determine
* if it is a real requirement.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
800be60: 59 60 00 5c sw (r11+92),r0
if ( !_CORE_message_queue_Initialize(
800be64: 35 61 00 1c addi r1,r11,28
800be68: 35 62 00 5c addi r2,r11,92
800be6c: b9 c0 18 00 mv r3,r14
800be70: b9 e0 20 00 mv r4,r15
800be74: f8 00 04 35 calli 800cf48 <_CORE_message_queue_Initialize>
800be78: 44 20 00 15 be r1,r0,800becc <_POSIX_Message_queue_Create_support+0x130><== NEVER TAKEN
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
800be7c: 2d 62 00 0a lhu r2,(r11+10)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
800be80: 29 81 00 1c lw r1,(r12+28)
800be84: b4 42 10 00 add r2,r2,r2
800be88: b4 42 10 00 add r2,r2,r2
800be8c: b4 22 10 00 add r2,r1,r2
800be90: 58 4b 00 00 sw (r2+0),r11
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
800be94: 59 6d 00 0c sw (r11+12),r13
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
800be98: 5a 2b 00 00 sw (r17+0),r11
_Thread_Enable_dispatch();
800be9c: fb ff f3 cc calli 8008dcc <_Thread_Enable_dispatch>
return 0;
800bea0: 34 01 00 00 mvi r1,0
}
800bea4: 2b 9d 00 04 lw ra,(sp+4)
800bea8: 2b 8b 00 20 lw r11,(sp+32)
800beac: 2b 8c 00 1c lw r12,(sp+28)
800beb0: 2b 8d 00 18 lw r13,(sp+24)
800beb4: 2b 8e 00 14 lw r14,(sp+20)
800beb8: 2b 8f 00 10 lw r15,(sp+16)
800bebc: 2b 90 00 0c lw r16,(sp+12)
800bec0: 2b 91 00 08 lw r17,(sp+8)
800bec4: 37 9c 00 24 addi sp,sp,36
800bec8: c3 a0 00 00 ret
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
800becc: b9 60 10 00 mv r2,r11 <== NOT EXECUTED
800bed0: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
800bed4: fb ff ef 30 calli 8007b94 <_Objects_Free> <== NOT EXECUTED
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
800bed8: b9 a0 08 00 mv r1,r13 <== NOT EXECUTED
800bedc: fb ff f8 e1 calli 800a260 <_Workspace_Free> <== NOT EXECUTED
_Thread_Enable_dispatch();
800bee0: fb ff f3 bb calli 8008dcc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
800bee4: f8 00 0e 35 calli 800f7b8 <__errno> <== NOT EXECUTED
800bee8: 34 02 00 1c mvi r2,28 <== NOT EXECUTED
800beec: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
800bef0: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
800bef4: e3 ff ff ec bi 800bea4 <_POSIX_Message_queue_Create_support+0x108><== NOT EXECUTED
800bef8: b9 60 10 00 mv r2,r11
800befc: b9 80 08 00 mv r1,r12
800bf00: fb ff ef 25 calli 8007b94 <_Objects_Free>
* dynamically constructed.
*/
name = _Workspace_String_duplicate( name_arg, name_len );
if ( !name ) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
800bf04: fb ff f3 b2 calli 8008dcc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOMEM );
800bf08: f8 00 0e 2c calli 800f7b8 <__errno>
800bf0c: 34 02 00 0c mvi r2,12
800bf10: 58 22 00 00 sw (r1+0),r2
800bf14: 34 01 ff ff mvi r1,-1
800bf18: e3 ff ff e3 bi 800bea4 <_POSIX_Message_queue_Create_support+0x108>
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
_Thread_Enable_dispatch();
800bf1c: fb ff f3 ac calli 8008dcc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
800bf20: f8 00 0e 26 calli 800f7b8 <__errno> <== NOT EXECUTED
800bf24: 34 02 00 17 mvi r2,23 <== NOT EXECUTED
800bf28: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
800bf2c: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
800bf30: e3 ff ff dd bi 800bea4 <_POSIX_Message_queue_Create_support+0x108><== NOT EXECUTED
08009a70 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
8009a70: 37 9c ff dc addi sp,sp,-36
8009a74: 5b 8b 00 1c sw (sp+28),r11
8009a78: 5b 8c 00 18 sw (sp+24),r12
8009a7c: 5b 8d 00 14 sw (sp+20),r13
8009a80: 5b 8e 00 10 sw (sp+16),r14
8009a84: 5b 8f 00 0c sw (sp+12),r15
8009a88: 5b 90 00 08 sw (sp+8),r16
8009a8c: 5b 9d 00 04 sw (sp+4),ra
8009a90: b8 20 58 00 mv r11,r1
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
8009a94: 78 01 08 02 mvhi r1,0x802
8009a98: b8 40 78 00 mv r15,r2
8009a9c: b8 60 60 00 mv r12,r3
8009aa0: b9 60 10 00 mv r2,r11
8009aa4: 38 21 b2 40 ori r1,r1,0xb240
8009aa8: 37 83 00 24 addi r3,sp,36
8009aac: b8 80 68 00 mv r13,r4
8009ab0: b8 c0 70 00 mv r14,r6
8009ab4: 20 b0 00 ff andi r16,r5,0xff
8009ab8: f8 00 0d bb calli 800d1a4 <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
8009abc: 2b 82 00 24 lw r2,(sp+36)
8009ac0: 44 40 00 0e be r2,r0,8009af8 <_POSIX_Message_queue_Receive_support+0x88>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
8009ac4: f8 00 2d 56 calli 801501c <__errno>
8009ac8: 34 02 00 09 mvi r2,9
8009acc: 58 22 00 00 sw (r1+0),r2
8009ad0: 34 01 ff ff mvi r1,-1
}
8009ad4: 2b 9d 00 04 lw ra,(sp+4)
8009ad8: 2b 8b 00 1c lw r11,(sp+28)
8009adc: 2b 8c 00 18 lw r12,(sp+24)
8009ae0: 2b 8d 00 14 lw r13,(sp+20)
8009ae4: 2b 8e 00 10 lw r14,(sp+16)
8009ae8: 2b 8f 00 0c lw r15,(sp+12)
8009aec: 2b 90 00 08 lw r16,(sp+8)
8009af0: 37 9c 00 24 addi sp,sp,36
8009af4: c3 a0 00 00 ret
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
8009af8: 28 24 00 14 lw r4,(r1+20)
8009afc: 34 07 00 01 mvi r7,1
8009b00: 20 88 00 03 andi r8,r4,0x3
8009b04: 45 07 00 3a be r8,r7,8009bec <_POSIX_Message_queue_Receive_support+0x17c>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
8009b08: 28 27 00 10 lw r7,(r1+16)
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
8009b0c: 28 e1 00 68 lw r1,(r7+104)
8009b10: 51 81 00 07 bgeu r12,r1,8009b2c <_POSIX_Message_queue_Receive_support+0xbc>
_Thread_Enable_dispatch();
8009b14: f8 00 11 e5 calli 800e2a8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
8009b18: f8 00 2d 41 calli 801501c <__errno>
8009b1c: 34 02 00 7a mvi r2,122
8009b20: 58 22 00 00 sw (r1+0),r2
8009b24: 34 01 ff ff mvi r1,-1
8009b28: e3 ff ff eb bi 8009ad4 <_POSIX_Message_queue_Receive_support+0x64>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
8009b2c: 34 01 ff ff mvi r1,-1
8009b30: 5b 81 00 20 sw (sp+32),r1
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
8009b34: 34 05 00 00 mvi r5,0
8009b38: 5e 00 00 17 bne r16,r0,8009b94 <_POSIX_Message_queue_Receive_support+0x124>
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
8009b3c: 34 e1 00 1c addi r1,r7,28
8009b40: b9 60 10 00 mv r2,r11
8009b44: b9 e0 18 00 mv r3,r15
8009b48: 37 84 00 20 addi r4,sp,32
8009b4c: b9 c0 30 00 mv r6,r14
8009b50: f8 00 08 45 calli 800bc64 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
8009b54: f8 00 11 d5 calli 800e2a8 <_Thread_Enable_dispatch>
if (msg_prio) {
8009b58: 45 a0 00 19 be r13,r0,8009bbc <_POSIX_Message_queue_Receive_support+0x14c><== NEVER TAKEN
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
8009b5c: 78 0b 08 02 mvhi r11,0x802
8009b60: 39 6b b2 c0 ori r11,r11,0xb2c0
8009b64: 29 6c 00 10 lw r12,(r11+16)
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return (unsigned int) ((priority >= 0) ? priority : -priority);
8009b68: 34 02 00 1f mvi r2,31
8009b6c: 29 81 00 24 lw r1,(r12+36)
8009b70: f8 00 6f 36 calli 8025848 <__ashrsi3>
8009b74: 29 82 00 24 lw r2,(r12+36)
8009b78: 98 22 10 00 xor r2,r1,r2
8009b7c: c8 41 08 00 sub r1,r2,r1
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
8009b80: 59 a1 00 00 sw (r13+0),r1
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
8009b84: 29 81 00 34 lw r1,(r12+52)
8009b88: 5c 20 00 11 bne r1,r0,8009bcc <_POSIX_Message_queue_Receive_support+0x15c>
return length_out;
8009b8c: 2b 81 00 20 lw r1,(sp+32)
8009b90: e3 ff ff d1 bi 8009ad4 <_POSIX_Message_queue_Receive_support+0x64>
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
8009b94: 20 85 40 00 andi r5,r4,0x4000
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
8009b98: 64 a5 00 00 cmpei r5,r5,0
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
8009b9c: 34 e1 00 1c addi r1,r7,28
8009ba0: b9 60 10 00 mv r2,r11
8009ba4: b9 e0 18 00 mv r3,r15
8009ba8: 37 84 00 20 addi r4,sp,32
8009bac: b9 c0 30 00 mv r6,r14
8009bb0: f8 00 08 2d calli 800bc64 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
8009bb4: f8 00 11 bd calli 800e2a8 <_Thread_Enable_dispatch>
if (msg_prio) {
8009bb8: 5d a0 ff e9 bne r13,r0,8009b5c <_POSIX_Message_queue_Receive_support+0xec><== ALWAYS TAKEN
8009bbc: 78 0b 08 02 mvhi r11,0x802 <== NOT EXECUTED
8009bc0: 39 6b b2 c0 ori r11,r11,0xb2c0 <== NOT EXECUTED
8009bc4: 29 6c 00 10 lw r12,(r11+16) <== NOT EXECUTED
8009bc8: e3 ff ff ef bi 8009b84 <_POSIX_Message_queue_Receive_support+0x114><== NOT EXECUTED
}
if ( !_Thread_Executing->Wait.return_code )
return length_out;
rtems_set_errno_and_return_minus_one(
8009bcc: f8 00 2d 14 calli 801501c <__errno>
8009bd0: b8 20 60 00 mv r12,r1
8009bd4: 29 61 00 10 lw r1,(r11+16)
8009bd8: 28 21 00 34 lw r1,(r1+52)
8009bdc: f8 00 00 c2 calli 8009ee4 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
8009be0: 59 81 00 00 sw (r12+0),r1
8009be4: 34 01 ff ff mvi r1,-1
8009be8: e3 ff ff bb bi 8009ad4 <_POSIX_Message_queue_Receive_support+0x64>
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
_Thread_Enable_dispatch();
8009bec: f8 00 11 af calli 800e2a8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
8009bf0: f8 00 2d 0b calli 801501c <__errno>
8009bf4: 34 02 00 09 mvi r2,9
8009bf8: 58 22 00 00 sw (r1+0),r2
8009bfc: 34 01 ff ff mvi r1,-1
8009c00: e3 ff ff b5 bi 8009ad4 <_POSIX_Message_queue_Receive_support+0x64>
0800c6d8 <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
800c6d8: 37 9c ff e0 addi sp,sp,-32
800c6dc: 5b 8b 00 20 sw (sp+32),r11
800c6e0: 5b 8c 00 1c sw (sp+28),r12
800c6e4: 5b 8d 00 18 sw (sp+24),r13
800c6e8: 5b 8e 00 14 sw (sp+20),r14
800c6ec: 5b 8f 00 10 sw (sp+16),r15
800c6f0: 5b 90 00 0c sw (sp+12),r16
800c6f4: 5b 91 00 08 sw (sp+8),r17
800c6f8: 5b 9d 00 04 sw (sp+4),ra
800c6fc: b8 60 68 00 mv r13,r3
800c700: b8 20 70 00 mv r14,r1
800c704: b8 40 88 00 mv r17,r2
800c708: b8 80 78 00 mv r15,r4
800c70c: b8 a0 80 00 mv r16,r5
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
800c710: 5c 60 00 39 bne r3,r0,800c7f4 <_POSIX_Semaphore_Create_support+0x11c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
800c714: 78 06 08 02 mvhi r6,0x802
800c718: 38 c6 53 28 ori r6,r6,0x5328
800c71c: 28 c1 00 00 lw r1,(r6+0)
++level;
800c720: 34 21 00 01 addi r1,r1,1
_Thread_Dispatch_disable_level = level;
800c724: 58 c1 00 00 sw (r6+0),r1
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
_Objects_Allocate( &_POSIX_Semaphore_Information );
800c728: 78 0c 08 02 mvhi r12,0x802
800c72c: 39 8c 55 64 ori r12,r12,0x5564
800c730: b9 80 08 00 mv r1,r12
800c734: fb ff ec 0d calli 8007768 <_Objects_Allocate>
800c738: b8 20 58 00 mv r11,r1
rtems_set_errno_and_return_minus_one( ENOSYS );
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
800c73c: 44 2d 00 33 be r1,r13,800c808 <_POSIX_Semaphore_Create_support+0x130>
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
800c740: 45 c0 00 27 be r14,r0,800c7dc <_POSIX_Semaphore_Create_support+0x104>
name = _Workspace_String_duplicate( name_arg, name_len );
800c744: b9 c0 08 00 mv r1,r14
800c748: ba 20 10 00 mv r2,r17
800c74c: f8 00 05 22 calli 800dbd4 <_Workspace_String_duplicate>
800c750: b8 20 68 00 mv r13,r1
if ( !name ) {
800c754: 44 20 00 33 be r1,r0,800c820 <_POSIX_Semaphore_Create_support+0x148><== NEVER TAKEN
the_semaphore->process_shared = pshared;
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
800c758: 34 01 00 01 mvi r1,1
}
the_semaphore->process_shared = pshared;
if ( name ) {
the_semaphore->named = true;
800c75c: 34 02 00 01 mvi r2,1
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
800c760: 59 60 00 10 sw (r11+16),r0
if ( name ) {
the_semaphore->named = true;
800c764: 31 62 00 14 sb (r11+20),r2
the_semaphore->open_count = 1;
800c768: 59 61 00 18 sw (r11+24),r1
the_semaphore->linked = true;
800c76c: 31 61 00 15 sb (r11+21),r1
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
800c770: 34 04 ff ff mvi r4,-1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
800c774: 35 61 00 1c addi r1,r11,28
800c778: 35 62 00 5c addi r2,r11,92
800c77c: b9 e0 18 00 mv r3,r15
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
800c780: 59 64 00 5c sw (r11+92),r4
* blocking tasks on this semaphore should be. It could somehow
* be derived from the current scheduling policy. One
* thing is certain, no matter what we decide, it won't be
* the same as all other POSIX implementations. :)
*/
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
800c784: 59 60 00 60 sw (r11+96),r0
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
800c788: fb ff e9 f4 calli 8006f58 <_CORE_semaphore_Initialize>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
800c78c: 2d 62 00 0a lhu r2,(r11+10)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
800c790: 29 81 00 1c lw r1,(r12+28)
800c794: b4 42 10 00 add r2,r2,r2
800c798: b4 42 10 00 add r2,r2,r2
800c79c: b4 22 10 00 add r2,r1,r2
800c7a0: 58 4b 00 00 sw (r2+0),r11
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
800c7a4: 59 6d 00 0c sw (r11+12),r13
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
800c7a8: 5a 0b 00 00 sw (r16+0),r11
_Thread_Enable_dispatch();
800c7ac: fb ff f1 88 calli 8008dcc <_Thread_Enable_dispatch>
return 0;
800c7b0: 34 01 00 00 mvi r1,0
}
800c7b4: 2b 9d 00 04 lw ra,(sp+4)
800c7b8: 2b 8b 00 20 lw r11,(sp+32)
800c7bc: 2b 8c 00 1c lw r12,(sp+28)
800c7c0: 2b 8d 00 18 lw r13,(sp+24)
800c7c4: 2b 8e 00 14 lw r14,(sp+20)
800c7c8: 2b 8f 00 10 lw r15,(sp+16)
800c7cc: 2b 90 00 0c lw r16,(sp+12)
800c7d0: 2b 91 00 08 lw r17,(sp+8)
800c7d4: 37 9c 00 20 addi sp,sp,32
800c7d8: c3 a0 00 00 ret
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
800c7dc: 58 20 00 10 sw (r1+16),r0
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
the_semaphore->linked = true;
} else {
the_semaphore->named = false;
800c7e0: 30 20 00 14 sb (r1+20),r0
the_semaphore->open_count = 0;
800c7e4: 58 20 00 18 sw (r1+24),r0
the_semaphore->linked = false;
800c7e8: 30 20 00 15 sb (r1+21),r0
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
} else {
name = NULL;
800c7ec: 34 0d 00 00 mvi r13,0
800c7f0: e3 ff ff e0 bi 800c770 <_POSIX_Semaphore_Create_support+0x98>
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
rtems_set_errno_and_return_minus_one( ENOSYS );
800c7f4: f8 00 0b f1 calli 800f7b8 <__errno>
800c7f8: 34 02 00 58 mvi r2,88
800c7fc: 58 22 00 00 sw (r1+0),r2
800c800: 34 01 ff ff mvi r1,-1
800c804: e3 ff ff ec bi 800c7b4 <_POSIX_Semaphore_Create_support+0xdc>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
800c808: fb ff f1 71 calli 8008dcc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
800c80c: f8 00 0b eb calli 800f7b8 <__errno>
800c810: 34 02 00 1c mvi r2,28
800c814: 58 22 00 00 sw (r1+0),r2
800c818: 34 01 ff ff mvi r1,-1
800c81c: e3 ff ff e6 bi 800c7b4 <_POSIX_Semaphore_Create_support+0xdc>
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
800c820: b9 60 10 00 mv r2,r11 <== NOT EXECUTED
800c824: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
800c828: fb ff ec db calli 8007b94 <_Objects_Free> <== NOT EXECUTED
*/
if ( name_arg != NULL ) {
name = _Workspace_String_duplicate( name_arg, name_len );
if ( !name ) {
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
800c82c: fb ff f1 68 calli 8008dcc <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
800c830: f8 00 0b e2 calli 800f7b8 <__errno> <== NOT EXECUTED
800c834: 34 02 00 0c mvi r2,12 <== NOT EXECUTED
800c838: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
800c83c: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
800c840: e3 ff ff dd bi 800c7b4 <_POSIX_Semaphore_Create_support+0xdc><== NOT EXECUTED
080091a4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
80091a4: 37 9c ff fc addi sp,sp,-4
80091a8: 5b 9d 00 04 sw (sp+4),ra
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
80091ac: 28 22 01 1c lw r2,(r1+284)
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
80091b0: 28 43 00 d8 lw r3,(r2+216)
80091b4: 5c 60 00 04 bne r3,r0,80091c4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x20><== NEVER TAKEN
80091b8: 28 44 00 dc lw r4,(r2+220)
80091bc: 34 03 00 01 mvi r3,1
80091c0: 44 83 00 05 be r4,r3,80091d4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x30>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
80091c4: fb ff f4 fa calli 80065ac <_Thread_Enable_dispatch>
}
80091c8: 2b 9d 00 04 lw ra,(sp+4)
80091cc: 37 9c 00 04 addi sp,sp,4
80091d0: c3 a0 00 00 ret
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
80091d4: 28 42 00 e0 lw r2,(r2+224)
80091d8: 44 40 ff fb be r2,r0,80091c4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x20>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
80091dc: 78 03 08 01 mvhi r3,0x801
80091e0: 38 63 68 e8 ori r3,r3,0x68e8
80091e4: 28 64 00 00 lw r4,(r3+0)
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
80091e8: 34 02 ff ff mvi r2,-1
--level;
80091ec: 34 84 ff ff addi r4,r4,-1
_Thread_Dispatch_disable_level = level;
80091f0: 58 64 00 00 sw (r3+0),r4
80091f4: f8 00 02 93 calli 8009c40 <_POSIX_Thread_Exit>
80091f8: e3 ff ff f4 bi 80091c8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24>
0800ad10 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
800ad10: 37 9c ff e8 addi sp,sp,-24
800ad14: 5b 8b 00 18 sw (sp+24),r11
800ad18: 5b 8c 00 14 sw (sp+20),r12
800ad1c: 5b 8d 00 10 sw (sp+16),r13
800ad20: 5b 8e 00 0c sw (sp+12),r14
800ad24: 5b 8f 00 08 sw (sp+8),r15
800ad28: 5b 9d 00 04 sw (sp+4),ra
800ad2c: b8 20 68 00 mv r13,r1
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
800ad30: 28 41 00 00 lw r1,(r2+0)
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
800ad34: b8 40 60 00 mv r12,r2
800ad38: b8 60 70 00 mv r14,r3
800ad3c: b8 80 78 00 mv r15,r4
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
800ad40: fb ff ff ec calli 800acf0 <_POSIX_Priority_Is_valid>
return EINVAL;
800ad44: 34 0b 00 16 mvi r11,22
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
800ad48: 44 20 00 0c be r1,r0,800ad78 <_POSIX_Thread_Translate_sched_param+0x68><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
800ad4c: 59 c0 00 00 sw (r14+0),r0
*budget_callout = NULL;
800ad50: 59 e0 00 00 sw (r15+0),r0
if ( policy == SCHED_OTHER ) {
800ad54: 45 a0 00 12 be r13,r0,800ad9c <_POSIX_Thread_Translate_sched_param+0x8c>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
800ad58: 34 01 00 01 mvi r1,1
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
800ad5c: 34 0b 00 00 mvi r11,0
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
800ad60: 45 a1 00 06 be r13,r1,800ad78 <_POSIX_Thread_Translate_sched_param+0x68>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
800ad64: 34 01 00 02 mvi r1,2
800ad68: 45 a1 00 2b be r13,r1,800ae14 <_POSIX_Thread_Translate_sched_param+0x104>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
800ad6c: 34 01 00 04 mvi r1,4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
800ad70: 34 0b 00 16 mvi r11,22
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
800ad74: 45 a1 00 0e be r13,r1,800adac <_POSIX_Thread_Translate_sched_param+0x9c>
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
800ad78: b9 60 08 00 mv r1,r11
800ad7c: 2b 9d 00 04 lw ra,(sp+4)
800ad80: 2b 8b 00 18 lw r11,(sp+24)
800ad84: 2b 8c 00 14 lw r12,(sp+20)
800ad88: 2b 8d 00 10 lw r13,(sp+16)
800ad8c: 2b 8e 00 0c lw r14,(sp+12)
800ad90: 2b 8f 00 08 lw r15,(sp+8)
800ad94: 37 9c 00 18 addi sp,sp,24
800ad98: c3 a0 00 00 ret
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
800ad9c: 34 01 00 01 mvi r1,1
800ada0: 59 c1 00 00 sw (r14+0),r1
return 0;
800ada4: 34 0b 00 00 mvi r11,0
800ada8: e3 ff ff f4 bi 800ad78 <_POSIX_Thread_Translate_sched_param+0x68>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
800adac: 29 81 00 08 lw r1,(r12+8)
800adb0: 5c 20 00 03 bne r1,r0,800adbc <_POSIX_Thread_Translate_sched_param+0xac>
800adb4: 29 82 00 0c lw r2,(r12+12)
800adb8: 44 41 ff f0 be r2,r1,800ad78 <_POSIX_Thread_Translate_sched_param+0x68>
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
800adbc: 29 81 00 10 lw r1,(r12+16)
800adc0: 5c 20 00 04 bne r1,r0,800add0 <_POSIX_Thread_Translate_sched_param+0xc0>
800adc4: 29 82 00 14 lw r2,(r12+20)
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
800adc8: 34 0b 00 16 mvi r11,22
if ( policy == SCHED_SPORADIC ) {
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
800adcc: 44 41 ff eb be r2,r1,800ad78 <_POSIX_Thread_Translate_sched_param+0x68>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
800add0: 35 81 00 08 addi r1,r12,8
800add4: fb ff f5 ea calli 800857c <_Timespec_To_ticks>
800add8: b8 20 68 00 mv r13,r1
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
800addc: 35 81 00 10 addi r1,r12,16
800ade0: fb ff f5 e7 calli 800857c <_Timespec_To_ticks>
return EINVAL;
800ade4: 34 0b 00 16 mvi r11,22
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
800ade8: 54 2d ff e4 bgu r1,r13,800ad78 <_POSIX_Thread_Translate_sched_param+0x68>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
800adec: 29 81 00 04 lw r1,(r12+4)
800adf0: fb ff ff c0 calli 800acf0 <_POSIX_Priority_Is_valid>
800adf4: 44 20 ff e1 be r1,r0,800ad78 <_POSIX_Thread_Translate_sched_param+0x68>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
800adf8: 78 01 08 00 mvhi r1,0x800
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
800adfc: 34 02 00 03 mvi r2,3
800ae00: 59 c2 00 00 sw (r14+0),r2
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
800ae04: 38 21 45 f0 ori r1,r1,0x45f0
800ae08: 59 e1 00 00 sw (r15+0),r1
return 0;
800ae0c: 34 0b 00 00 mvi r11,0
800ae10: e3 ff ff da bi 800ad78 <_POSIX_Thread_Translate_sched_param+0x68>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
800ae14: 59 cd 00 00 sw (r14+0),r13
return 0;
800ae18: e3 ff ff d8 bi 800ad78 <_POSIX_Thread_Translate_sched_param+0x68>
08009f74 <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
8009f74: 37 9c ff ec addi sp,sp,-20
8009f78: 5b 8b 00 14 sw (sp+20),r11
8009f7c: 5b 8c 00 10 sw (sp+16),r12
8009f80: 5b 8d 00 0c sw (sp+12),r13
8009f84: 5b 8e 00 08 sw (sp+8),r14
8009f88: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
8009f8c: 28 4e 01 1c lw r14,(r2+284)
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
8009f90: b8 40 08 00 mv r1,r2
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
8009f94: b8 40 68 00 mv r13,r2
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
8009f98: f8 00 0a 0b calli 800c7c4 <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
8009f9c: b9 a0 08 00 mv r1,r13
8009fa0: f8 00 0a 2d calli 800c854 <_POSIX_Keys_Run_destructors>
8009fa4: 35 cb 00 44 addi r11,r14,68
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
8009fa8: 29 ac 00 28 lw r12,(r13+40)
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
8009fac: e0 00 00 03 bi 8009fb8 <_POSIX_Threads_Delete_extension+0x44>
*(void **)the_thread->Wait.return_argument = value_ptr;
8009fb0: 28 23 00 28 lw r3,(r1+40) <== NOT EXECUTED
8009fb4: 58 6c 00 00 sw (r3+0),r12 <== NOT EXECUTED
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
8009fb8: b9 60 08 00 mv r1,r11
8009fbc: fb ff f4 2d calli 8007070 <_Thread_queue_Dequeue>
8009fc0: 5c 20 ff fc bne r1,r0,8009fb0 <_POSIX_Threads_Delete_extension+0x3c><== NEVER TAKEN
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
8009fc4: 29 c2 00 84 lw r2,(r14+132)
8009fc8: 34 01 00 04 mvi r1,4
8009fcc: 44 41 00 0b be r2,r1,8009ff8 <_POSIX_Threads_Delete_extension+0x84>
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
8009fd0: 59 a0 01 1c sw (r13+284),r0
_Workspace_Free( api );
8009fd4: b9 c0 08 00 mv r1,r14
8009fd8: fb ff f8 16 calli 8008030 <_Workspace_Free>
}
8009fdc: 2b 9d 00 04 lw ra,(sp+4)
8009fe0: 2b 8b 00 14 lw r11,(sp+20)
8009fe4: 2b 8c 00 10 lw r12,(sp+16)
8009fe8: 2b 8d 00 0c lw r13,(sp+12)
8009fec: 2b 8e 00 08 lw r14,(sp+8)
8009ff0: 37 9c 00 14 addi sp,sp,20
8009ff4: c3 a0 00 00 ret
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
8009ff8: 35 c1 00 a8 addi r1,r14,168
8009ffc: fb ff f7 35 calli 8007cd0 <_Watchdog_Remove>
800a000: e3 ff ff f4 bi 8009fd0 <_POSIX_Threads_Delete_extension+0x5c>
08009f24 <_POSIX_Threads_Exitted_extension>:
* This method is invoked each time a thread exits.
*/
static void _POSIX_Threads_Exitted_extension(
Thread_Control *executing
)
{
8009f24: 37 9c ff f8 addi sp,sp,-8
8009f28: 5b 8b 00 08 sw (sp+8),r11
8009f2c: 5b 9d 00 04 sw (sp+4),ra
8009f30: b8 20 58 00 mv r11,r1
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
8009f34: 28 21 00 08 lw r1,(r1+8)
8009f38: 34 02 00 18 mvi r2,24
8009f3c: f8 00 47 a7 calli 801bdd8 <__lshrsi3>
8009f40: 20 21 00 07 andi r1,r1,0x7
/*
* If the executing thread was not created with the POSIX API, then this
* API do not get to define its exit behavior.
*/
if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API )
8009f44: 34 02 00 03 mvi r2,3
8009f48: 44 22 00 05 be r1,r2,8009f5c <_POSIX_Threads_Exitted_extension+0x38>
pthread_exit( executing->Wait.return_argument );
}
8009f4c: 2b 9d 00 04 lw ra,(sp+4)
8009f50: 2b 8b 00 08 lw r11,(sp+8)
8009f54: 37 9c 00 08 addi sp,sp,8
8009f58: c3 a0 00 00 ret
/*
* If the executing thread was not created with the POSIX API, then this
* API do not get to define its exit behavior.
*/
if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API )
pthread_exit( executing->Wait.return_argument );
8009f5c: 29 61 00 28 lw r1,(r11+40)
8009f60: f8 00 0b 82 calli 800cd68 <pthread_exit>
}
8009f64: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8009f68: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
8009f6c: 37 9c 00 08 addi sp,sp,8 <== NOT EXECUTED
8009f70: c3 a0 00 00 ret <== NOT EXECUTED
08004234 <_POSIX_Threads_Initialize_user_threads_body>:
#include <rtems/posix/config.h>
#include <rtems/posix/key.h>
#include <rtems/posix/time.h>
void _POSIX_Threads_Initialize_user_threads_body(void)
{
8004234: 37 9c ff a8 addi sp,sp,-88
8004238: 5b 8b 00 14 sw (sp+20),r11
800423c: 5b 8c 00 10 sw (sp+16),r12
8004240: 5b 8d 00 0c sw (sp+12),r13
8004244: 5b 8e 00 08 sw (sp+8),r14
8004248: 5b 9d 00 04 sw (sp+4),ra
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
800424c: 78 01 08 02 mvhi r1,0x802
8004250: 38 21 00 c0 ori r1,r1,0xc0
maximum = Configuration_POSIX_API.number_of_initialization_threads;
8004254: 28 2e 00 30 lw r14,(r1+48)
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
8004258: 28 2c 00 34 lw r12,(r1+52)
maximum = Configuration_POSIX_API.number_of_initialization_threads;
if ( !user_threads || maximum == 0 )
800425c: 65 c2 00 00 cmpei r2,r14,0
8004260: 65 81 00 00 cmpei r1,r12,0
8004264: b8 41 08 00 or r1,r2,r1
8004268: 5c 20 00 15 bne r1,r0,80042bc <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
800426c: 34 0d 00 00 mvi r13,0
8004270: 37 8b 00 18 addi r11,sp,24
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
8004274: b9 60 08 00 mv r1,r11
8004278: f8 00 1a e9 calli 800ae1c <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
800427c: 34 02 00 02 mvi r2,2
8004280: b9 60 08 00 mv r1,r11
8004284: f8 00 1b 1d calli 800aef8 <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
8004288: 29 82 00 04 lw r2,(r12+4)
800428c: b9 60 08 00 mv r1,r11
8004290: f8 00 1b 26 calli 800af28 <pthread_attr_setstacksize>
status = pthread_create(
8004294: 29 83 00 00 lw r3,(r12+0)
8004298: 37 81 00 58 addi r1,sp,88
800429c: b9 60 10 00 mv r2,r11
80042a0: 34 04 00 00 mvi r4,0
80042a4: fb ff fe bb calli 8003d90 <pthread_create>
80042a8: b8 20 18 00 mv r3,r1
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
80042ac: 5c 20 00 0b bne r1,r0,80042d8 <_POSIX_Threads_Initialize_user_threads_body+0xa4>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
80042b0: 35 ad 00 01 addi r13,r13,1
80042b4: 35 8c 00 08 addi r12,r12,8
80042b8: 55 cd ff ef bgu r14,r13,8004274 <_POSIX_Threads_Initialize_user_threads_body+0x40><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
80042bc: 2b 9d 00 04 lw ra,(sp+4)
80042c0: 2b 8b 00 14 lw r11,(sp+20)
80042c4: 2b 8c 00 10 lw r12,(sp+16)
80042c8: 2b 8d 00 0c lw r13,(sp+12)
80042cc: 2b 8e 00 08 lw r14,(sp+8)
80042d0: 37 9c 00 58 addi sp,sp,88
80042d4: c3 a0 00 00 ret
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
80042d8: 34 01 00 02 mvi r1,2
80042dc: 34 02 00 01 mvi r2,1
80042e0: f8 00 07 93 calli 800612c <_Internal_error_Occurred>
0800a180 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
800a180: 37 9c ff f4 addi sp,sp,-12
800a184: 5b 8b 00 0c sw (sp+12),r11
800a188: 5b 8c 00 08 sw (sp+8),r12
800a18c: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
800a190: 28 4c 01 1c lw r12,(r2+284)
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
800a194: b8 40 58 00 mv r11,r2
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
800a198: 35 81 00 98 addi r1,r12,152
800a19c: f8 00 04 8e calli 800b3d4 <_Timespec_To_ticks>
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
800a1a0: 78 03 08 02 mvhi r3,0x802
800a1a4: 38 63 00 d8 ori r3,r3,0xd8
800a1a8: 29 84 00 88 lw r4,(r12+136)
800a1ac: 40 62 00 00 lbu r2,(r3+0)
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
800a1b0: 29 63 00 1c lw r3,(r11+28)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
the_thread->cpu_time_budget = ticks;
800a1b4: 59 61 00 74 sw (r11+116),r1
800a1b8: c8 44 10 00 sub r2,r2,r4
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
800a1bc: 59 62 00 18 sw (r11+24),r2
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
800a1c0: 5c 60 00 06 bne r3,r0,800a1d8 <_POSIX_Threads_Sporadic_budget_TSR+0x58><== NEVER TAKEN
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
800a1c4: 29 61 00 14 lw r1,(r11+20)
800a1c8: 50 41 00 04 bgeu r2,r1,800a1d8 <_POSIX_Threads_Sporadic_budget_TSR+0x58>
_Thread_Change_priority( the_thread, new_priority, true );
800a1cc: b9 60 08 00 mv r1,r11
800a1d0: 34 03 00 01 mvi r3,1
800a1d4: fb ff f1 43 calli 80066e0 <_Thread_Change_priority>
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
800a1d8: 35 81 00 90 addi r1,r12,144
800a1dc: f8 00 04 7e calli 800b3d4 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
800a1e0: 59 81 00 b4 sw (r12+180),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
800a1e4: 78 01 08 02 mvhi r1,0x802
800a1e8: 35 82 00 a8 addi r2,r12,168
800a1ec: 38 21 09 f0 ori r1,r1,0x9f0
800a1f0: fb ff f6 52 calli 8007b38 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
800a1f4: 2b 9d 00 04 lw ra,(sp+4)
800a1f8: 2b 8b 00 0c lw r11,(sp+12)
800a1fc: 2b 8c 00 08 lw r12,(sp+8)
800a200: 37 9c 00 0c addi sp,sp,12
800a204: c3 a0 00 00 ret
0800a208 <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
800a208: 37 9c ff fc addi sp,sp,-4
800a20c: 5b 9d 00 04 sw (sp+4),ra
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
800a210: 28 22 01 1c lw r2,(r1+284)
800a214: 78 04 08 02 mvhi r4,0x802
800a218: 38 84 00 d8 ori r4,r4,0xd8
800a21c: 28 42 00 8c lw r2,(r2+140)
800a220: 40 84 00 00 lbu r4,(r4+0)
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
800a224: 28 25 00 1c lw r5,(r1+28)
800a228: c8 82 10 00 sub r2,r4,r2
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
800a22c: 34 04 ff ff mvi r4,-1
800a230: 58 24 00 74 sw (r1+116),r4
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
800a234: 58 22 00 18 sw (r1+24),r2
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
800a238: 5c a0 00 05 bne r5,r0,800a24c <_POSIX_Threads_Sporadic_budget_callout+0x44><== NEVER TAKEN
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
800a23c: 28 23 00 14 lw r3,(r1+20)
800a240: 50 62 00 03 bgeu r3,r2,800a24c <_POSIX_Threads_Sporadic_budget_callout+0x44><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
800a244: 34 03 00 01 mvi r3,1
800a248: fb ff f1 26 calli 80066e0 <_Thread_Change_priority>
#if 0
printk( "lower priority\n" );
#endif
}
}
}
800a24c: 2b 9d 00 04 lw ra,(sp+4)
800a250: 37 9c 00 04 addi sp,sp,4
800a254: c3 a0 00 00 ret
0800c7c4 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
800c7c4: 37 9c ff ec addi sp,sp,-20
800c7c8: 5b 8b 00 14 sw (sp+20),r11
800c7cc: 5b 8c 00 10 sw (sp+16),r12
800c7d0: 5b 8d 00 0c sw (sp+12),r13
800c7d4: 5b 8e 00 08 sw (sp+8),r14
800c7d8: 5b 9d 00 04 sw (sp+4),ra
POSIX_Cancel_Handler_control *handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
800c7dc: 28 2c 01 1c lw r12,(r1+284)
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
800c7e0: 34 01 00 01 mvi r1,1
while ( !_Chain_Is_empty( handler_stack ) ) {
800c7e4: 29 82 00 e4 lw r2,(r12+228)
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
800c7e8: 59 81 00 d8 sw (r12+216),r1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
800c7ec: 35 8d 00 e8 addi r13,r12,232
while ( !_Chain_Is_empty( handler_stack ) ) {
800c7f0: 44 4d 00 12 be r2,r13,800c838 <_POSIX_Threads_cancel_run+0x74>
_ISR_Disable( level );
800c7f4: 34 0e ff fe mvi r14,-2
800c7f8: 90 00 08 00 rcsr r1,IE
800c7fc: a0 2e 10 00 and r2,r1,r14
800c800: d0 02 00 00 wcsr IE,r2
handler = (POSIX_Cancel_Handler_control *)
800c804: 29 8b 00 ec lw r11,(r12+236)
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
800c808: 29 63 00 00 lw r3,(r11+0)
previous = the_node->previous;
800c80c: 29 62 00 04 lw r2,(r11+4)
next->previous = previous;
800c810: 58 62 00 04 sw (r3+4),r2
previous->next = next;
800c814: 58 43 00 00 sw (r2+0),r3
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
800c818: d0 01 00 00 wcsr IE,r1
(*handler->routine)( handler->arg );
800c81c: 29 62 00 08 lw r2,(r11+8)
800c820: 29 61 00 0c lw r1,(r11+12)
800c824: d8 40 00 00 call r2
_Workspace_Free( handler );
800c828: b9 60 08 00 mv r1,r11
800c82c: fb ff ee 01 calli 8008030 <_Workspace_Free>
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
800c830: 29 81 00 e4 lw r1,(r12+228)
800c834: 5c 2d ff f1 bne r1,r13,800c7f8 <_POSIX_Threads_cancel_run+0x34><== NEVER TAKEN
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
800c838: 2b 9d 00 04 lw ra,(sp+4)
800c83c: 2b 8b 00 14 lw r11,(sp+20)
800c840: 2b 8c 00 10 lw r12,(sp+16)
800c844: 2b 8d 00 0c lw r13,(sp+12)
800c848: 2b 8e 00 08 lw r14,(sp+8)
800c84c: 37 9c 00 14 addi sp,sp,20
800c850: c3 a0 00 00 ret
08003f10 <_POSIX_Timer_TSR>:
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
8003f10: 37 9c ff e8 addi sp,sp,-24
8003f14: 5b 8b 00 10 sw (sp+16),r11
8003f18: 5b 8c 00 0c sw (sp+12),r12
8003f1c: 5b 8d 00 08 sw (sp+8),r13
8003f20: 5b 9d 00 04 sw (sp+4),ra
8003f24: b8 40 58 00 mv r11,r2
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
8003f28: 28 42 00 68 lw r2,(r2+104)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
8003f2c: 29 61 00 54 lw r1,(r11+84)
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
8003f30: 34 42 00 01 addi r2,r2,1
8003f34: 59 62 00 68 sw (r11+104),r2
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
8003f38: 5c 20 00 0f bne r1,r0,8003f74 <_POSIX_Timer_TSR+0x64>
8003f3c: 29 62 00 58 lw r2,(r11+88)
8003f40: 5c 41 00 0d bne r2,r1,8003f74 <_POSIX_Timer_TSR+0x64> <== ALWAYS TAKEN
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
8003f44: 34 01 00 04 mvi r1,4 <== NOT EXECUTED
8003f48: 31 61 00 3c sb (r11+60),r1 <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
8003f4c: 29 61 00 38 lw r1,(r11+56)
8003f50: 29 62 00 44 lw r2,(r11+68)
8003f54: f8 00 18 f2 calli 800a31c <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
8003f58: 59 60 00 68 sw (r11+104),r0
}
8003f5c: 2b 9d 00 04 lw ra,(sp+4)
8003f60: 2b 8b 00 10 lw r11,(sp+16)
8003f64: 2b 8c 00 0c lw r12,(sp+12)
8003f68: 2b 8d 00 08 lw r13,(sp+8)
8003f6c: 37 9c 00 18 addi sp,sp,24
8003f70: c3 a0 00 00 ret
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
8003f74: 29 62 00 64 lw r2,(r11+100)
8003f78: 29 63 00 08 lw r3,(r11+8)
8003f7c: 78 04 08 00 mvhi r4,0x800
8003f80: 35 61 00 10 addi r1,r11,16
8003f84: 38 84 3f 10 ori r4,r4,0x3f10
8003f88: b9 60 28 00 mv r5,r11
8003f8c: f8 00 1a 4a calli 800a8b4 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
8003f90: 44 20 ff f3 be r1,r0,8003f5c <_POSIX_Timer_TSR+0x4c> <== NEVER TAKEN
8003f94: 78 02 08 02 mvhi r2,0x802
8003f98: 38 42 08 c8 ori r2,r2,0x8c8
8003f9c: 37 81 00 14 addi r1,sp,20
8003fa0: f8 00 05 00 calli 80053a0 <_TOD_Get_with_nanoseconds>
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
8003fa4: 28 2d 00 00 lw r13,(r1+0)
8003fa8: 28 2c 00 04 lw r12,(r1+4)
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
8003fac: 78 01 08 01 mvhi r1,0x801
8003fb0: 38 21 e6 08 ori r1,r1,0xe608
8003fb4: 28 24 00 00 lw r4,(r1+0)
8003fb8: 34 03 00 00 mvi r3,0
8003fbc: b9 a0 08 00 mv r1,r13
8003fc0: b9 80 10 00 mv r2,r12
8003fc4: f8 00 4e 2a calli 801786c <__divdi3>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
8003fc8: 78 01 08 01 mvhi r1,0x801
8003fcc: 38 21 e6 08 ori r1,r1,0xe608
8003fd0: 28 24 00 00 lw r4,(r1+0)
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
8003fd4: 59 62 00 6c sw (r11+108),r2
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
8003fd8: b9 a0 08 00 mv r1,r13
8003fdc: b9 80 10 00 mv r2,r12
8003fe0: 34 03 00 00 mvi r3,0
8003fe4: f8 00 50 24 calli 8018074 <__moddi3>
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
8003fe8: 34 01 00 03 mvi r1,3
8003fec: 59 62 00 70 sw (r11+112),r2
8003ff0: 31 61 00 3c sb (r11+60),r1
8003ff4: e3 ff ff d6 bi 8003f4c <_POSIX_Timer_TSR+0x3c>
0800c92c <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
800c92c: 37 9c ff a0 addi sp,sp,-96
800c930: 5b 8b 00 2c sw (sp+44),r11
800c934: 5b 8c 00 28 sw (sp+40),r12
800c938: 5b 8d 00 24 sw (sp+36),r13
800c93c: 5b 8e 00 20 sw (sp+32),r14
800c940: 5b 8f 00 1c sw (sp+28),r15
800c944: 5b 90 00 18 sw (sp+24),r16
800c948: 5b 91 00 14 sw (sp+20),r17
800c94c: 5b 92 00 10 sw (sp+16),r18
800c950: 5b 93 00 0c sw (sp+12),r19
800c954: 5b 94 00 08 sw (sp+8),r20
800c958: 5b 9d 00 04 sw (sp+4),ra
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
800c95c: 37 8e 00 58 addi r14,sp,88
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
800c960: 20 64 00 ff andi r4,r3,0xff
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
800c964: 34 05 00 01 mvi r5,1
800c968: b9 c0 18 00 mv r3,r14
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
800c96c: b8 20 68 00 mv r13,r1
800c970: b8 40 58 00 mv r11,r2
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
800c974: f8 00 00 57 calli 800cad0 <_POSIX_signals_Clear_signals>
is_global, true ) )
return false;
800c978: 34 06 00 00 mvi r6,0
{
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
800c97c: 44 20 00 42 be r1,r0,800ca84 <_POSIX_signals_Check_signal+0x158>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
800c980: b5 6b 20 00 add r4,r11,r11
800c984: b4 8b 20 00 add r4,r4,r11
800c988: 78 05 08 02 mvhi r5,0x802
800c98c: b4 84 20 00 add r4,r4,r4
800c990: 38 a5 0e 68 ori r5,r5,0xe68
800c994: b4 84 20 00 add r4,r4,r4
800c998: b4 a4 28 00 add r5,r5,r4
800c99c: 28 a7 00 08 lw r7,(r5+8)
800c9a0: 34 01 00 01 mvi r1,1
800c9a4: 44 e1 00 38 be r7,r1,800ca84 <_POSIX_signals_Check_signal+0x158><== NEVER TAKEN
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
800c9a8: 78 0c 08 02 mvhi r12,0x802
800c9ac: 39 8c 0d e0 ori r12,r12,0xde0
800c9b0: 29 84 00 10 lw r4,(r12+16)
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
800c9b4: 29 af 00 d0 lw r15,(r13+208)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
800c9b8: 28 a1 00 04 lw r1,(r5+4)
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
800c9bc: 28 94 00 20 lw r20,(r4+32)
800c9c0: 28 93 00 24 lw r19,(r4+36)
800c9c4: 28 92 00 28 lw r18,(r4+40)
800c9c8: 28 91 00 2c lw r17,(r4+44)
800c9cc: 28 90 00 30 lw r16,(r4+48)
800c9d0: 28 8a 00 34 lw r10,(r4+52)
800c9d4: 28 89 00 38 lw r9,(r4+56)
800c9d8: 28 88 00 3c lw r8,(r4+60)
800c9dc: 28 86 00 40 lw r6,(r4+64)
800c9e0: 28 83 00 44 lw r3,(r4+68)
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
800c9e4: 28 a2 00 00 lw r2,(r5+0)
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
800c9e8: b8 2f 08 00 or r1,r1,r15
800c9ec: 59 a1 00 d0 sw (r13+208),r1
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
800c9f0: 5b 94 00 30 sw (sp+48),r20
800c9f4: 5b 93 00 34 sw (sp+52),r19
800c9f8: 5b 92 00 38 sw (sp+56),r18
800c9fc: 5b 91 00 3c sw (sp+60),r17
800ca00: 5b 90 00 40 sw (sp+64),r16
800ca04: 5b 8a 00 44 sw (sp+68),r10
800ca08: 5b 89 00 48 sw (sp+72),r9
800ca0c: 5b 88 00 4c sw (sp+76),r8
800ca10: 5b 86 00 50 sw (sp+80),r6
800ca14: 5b 83 00 54 sw (sp+84),r3
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
800ca18: 34 01 00 02 mvi r1,2
800ca1c: 44 41 00 28 be r2,r1,800cabc <_POSIX_signals_Check_signal+0x190>
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
800ca20: b9 60 08 00 mv r1,r11
800ca24: d8 e0 00 00 call r7
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
800ca28: 29 82 00 10 lw r2,(r12+16)
800ca2c: 2b 81 00 30 lw r1,(sp+48)
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
800ca30: 34 06 00 01 mvi r6,1
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
800ca34: 58 41 00 20 sw (r2+32),r1
800ca38: 2b 81 00 34 lw r1,(sp+52)
800ca3c: 58 41 00 24 sw (r2+36),r1
800ca40: 2b 81 00 38 lw r1,(sp+56)
800ca44: 58 41 00 28 sw (r2+40),r1
800ca48: 2b 81 00 3c lw r1,(sp+60)
800ca4c: 58 41 00 2c sw (r2+44),r1
800ca50: 2b 81 00 40 lw r1,(sp+64)
800ca54: 58 41 00 30 sw (r2+48),r1
800ca58: 2b 81 00 44 lw r1,(sp+68)
800ca5c: 58 41 00 34 sw (r2+52),r1
800ca60: 2b 81 00 48 lw r1,(sp+72)
800ca64: 58 41 00 38 sw (r2+56),r1
800ca68: 2b 81 00 4c lw r1,(sp+76)
800ca6c: 58 41 00 3c sw (r2+60),r1
800ca70: 2b 81 00 50 lw r1,(sp+80)
800ca74: 58 41 00 40 sw (r2+64),r1
800ca78: 2b 81 00 54 lw r1,(sp+84)
800ca7c: 58 41 00 44 sw (r2+68),r1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
800ca80: 59 af 00 d0 sw (r13+208),r15
return true;
}
800ca84: b8 c0 08 00 mv r1,r6
800ca88: 2b 9d 00 04 lw ra,(sp+4)
800ca8c: 2b 8b 00 2c lw r11,(sp+44)
800ca90: 2b 8c 00 28 lw r12,(sp+40)
800ca94: 2b 8d 00 24 lw r13,(sp+36)
800ca98: 2b 8e 00 20 lw r14,(sp+32)
800ca9c: 2b 8f 00 1c lw r15,(sp+28)
800caa0: 2b 90 00 18 lw r16,(sp+24)
800caa4: 2b 91 00 14 lw r17,(sp+20)
800caa8: 2b 92 00 10 lw r18,(sp+16)
800caac: 2b 93 00 0c lw r19,(sp+12)
800cab0: 2b 94 00 08 lw r20,(sp+8)
800cab4: 37 9c 00 60 addi sp,sp,96
800cab8: c3 a0 00 00 ret
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
800cabc: b9 60 08 00 mv r1,r11
800cac0: b9 c0 10 00 mv r2,r14
800cac4: 34 03 00 00 mvi r3,0
800cac8: d8 e0 00 00 call r7
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
800cacc: e3 ff ff d7 bi 800ca28 <_POSIX_signals_Check_signal+0xfc>
0800d174 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
800d174: 37 9c ff f4 addi sp,sp,-12
800d178: 5b 8b 00 0c sw (sp+12),r11
800d17c: 5b 8c 00 08 sw (sp+8),r12
800d180: 5b 9d 00 04 sw (sp+4),ra
800d184: b8 20 10 00 mv r2,r1
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
800d188: 90 00 60 00 rcsr r12,IE
800d18c: 34 01 ff fe mvi r1,-2
800d190: a1 81 08 00 and r1,r12,r1
800d194: d0 01 00 00 wcsr IE,r1
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
800d198: b4 42 20 00 add r4,r2,r2
800d19c: b4 82 20 00 add r4,r4,r2
800d1a0: 78 01 08 02 mvhi r1,0x802
800d1a4: b4 84 18 00 add r3,r4,r4
800d1a8: 38 21 0e 68 ori r1,r1,0xe68
800d1ac: b4 63 18 00 add r3,r3,r3
800d1b0: b4 23 18 00 add r3,r1,r3
800d1b4: 28 63 00 00 lw r3,(r3+0)
800d1b8: 34 01 00 02 mvi r1,2
800d1bc: 44 61 00 10 be r3,r1,800d1fc <_POSIX_signals_Clear_process_signals+0x88>
800d1c0: 34 42 ff ff addi r2,r2,-1
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
800d1c4: 78 0b 08 02 mvhi r11,0x802
800d1c8: 34 01 00 01 mvi r1,1
800d1cc: f8 00 3a b5 calli 801bca0 <__ashlsi3>
800d1d0: 39 6b 10 5c ori r11,r11,0x105c
800d1d4: 29 62 00 00 lw r2,(r11+0)
800d1d8: a4 20 08 00 not r1,r1
800d1dc: a0 22 08 00 and r1,r1,r2
800d1e0: 59 61 00 00 sw (r11+0),r1
}
_ISR_Enable( level );
800d1e4: d0 0c 00 00 wcsr IE,r12
}
800d1e8: 2b 9d 00 04 lw ra,(sp+4)
800d1ec: 2b 8b 00 0c lw r11,(sp+12)
800d1f0: 2b 8c 00 08 lw r12,(sp+8)
800d1f4: 37 9c 00 0c addi sp,sp,12
800d1f8: c3 a0 00 00 ret
800d1fc: 78 01 08 02 mvhi r1,0x802
800d200: b4 84 20 00 add r4,r4,r4
800d204: 38 21 10 60 ori r1,r1,0x1060
800d208: b4 84 20 00 add r4,r4,r4
800d20c: b4 24 20 00 add r4,r1,r4
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
800d210: 28 81 00 00 lw r1,(r4+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
800d214: 34 84 00 04 addi r4,r4,4
800d218: 44 24 ff ea be r1,r4,800d1c0 <_POSIX_signals_Clear_process_signals+0x4c><== ALWAYS TAKEN
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
800d21c: d0 0c 00 00 wcsr IE,r12 <== NOT EXECUTED
}
800d220: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
800d224: 2b 8b 00 0c lw r11,(sp+12) <== NOT EXECUTED
800d228: 2b 8c 00 08 lw r12,(sp+8) <== NOT EXECUTED
800d22c: 37 9c 00 0c addi sp,sp,12 <== NOT EXECUTED
800d230: c3 a0 00 00 ret <== NOT EXECUTED
08004f28 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
sigset_t set
)
{
8004f28: 37 9c ff f0 addi sp,sp,-16
8004f2c: 5b 8b 00 10 sw (sp+16),r11
8004f30: 5b 8c 00 0c sw (sp+12),r12
8004f34: 5b 8d 00 08 sw (sp+8),r13
8004f38: 5b 9d 00 04 sw (sp+4),ra
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8004f3c: 34 0b 00 1b mvi r11,27
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
sigset_t set
)
{
8004f40: b8 20 60 00 mv r12,r1
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8004f44: 34 0d 00 20 mvi r13,32
8004f48: 35 62 ff ff addi r2,r11,-1
8004f4c: 34 01 00 01 mvi r1,1
8004f50: f8 00 46 e7 calli 8016aec <__ashlsi3>
if ( set & signo_to_mask( signo ) ) {
8004f54: a0 2c 08 00 and r1,r1,r12
8004f58: 5c 20 00 0d bne r1,r0,8004f8c <_POSIX_signals_Get_lowest+0x64><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8004f5c: 35 6b 00 01 addi r11,r11,1
8004f60: 5d 6d ff fa bne r11,r13,8004f48 <_POSIX_signals_Get_lowest+0x20>
8004f64: 34 0b 00 01 mvi r11,1
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
8004f68: 34 0d 00 1b mvi r13,27
8004f6c: e0 00 00 03 bi 8004f78 <_POSIX_signals_Get_lowest+0x50>
8004f70: 35 6b 00 01 addi r11,r11,1
8004f74: 45 6d 00 06 be r11,r13,8004f8c <_POSIX_signals_Get_lowest+0x64><== NEVER TAKEN
8004f78: 35 62 ff ff addi r2,r11,-1
8004f7c: 34 01 00 01 mvi r1,1
8004f80: f8 00 46 db calli 8016aec <__ashlsi3>
if ( set & signo_to_mask( signo ) ) {
8004f84: a0 2c 10 00 and r2,r1,r12
8004f88: 44 40 ff fa be r2,r0,8004f70 <_POSIX_signals_Get_lowest+0x48>
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
8004f8c: b9 60 08 00 mv r1,r11
8004f90: 2b 9d 00 04 lw ra,(sp+4)
8004f94: 2b 8b 00 10 lw r11,(sp+16)
8004f98: 2b 8c 00 0c lw r12,(sp+12)
8004f9c: 2b 8d 00 08 lw r13,(sp+8)
8004fa0: 37 9c 00 10 addi sp,sp,16
8004fa4: c3 a0 00 00 ret
08009b48 <_POSIX_signals_Post_switch_hook>:
*/
static void _POSIX_signals_Post_switch_hook(
Thread_Control *the_thread
)
{
8009b48: 37 9c ff dc addi sp,sp,-36
8009b4c: 5b 8b 00 24 sw (sp+36),r11
8009b50: 5b 8c 00 20 sw (sp+32),r12
8009b54: 5b 8d 00 1c sw (sp+28),r13
8009b58: 5b 8e 00 18 sw (sp+24),r14
8009b5c: 5b 8f 00 14 sw (sp+20),r15
8009b60: 5b 90 00 10 sw (sp+16),r16
8009b64: 5b 91 00 0c sw (sp+12),r17
8009b68: 5b 92 00 08 sw (sp+8),r18
8009b6c: 5b 9d 00 04 sw (sp+4),ra
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
8009b70: 78 11 08 02 mvhi r17,0x802
8009b74: 3a 31 0d e0 ori r17,r17,0xde0
8009b78: 2a 22 00 10 lw r2,(r17+16)
POSIX_API_Control *api;
int signo;
ISR_Level level;
int hold_errno;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8009b7c: 28 2c 01 1c lw r12,(r1+284)
/*
* We need to ensure that if the signal handler executes a call
* which overwrites the unblocking status, we restore it.
*/
hold_errno = _Thread_Executing->Wait.return_code;
8009b80: 28 52 00 34 lw r18,(r2+52)
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
8009b84: 45 80 00 2b be r12,r0,8009c30 <_POSIX_signals_Post_switch_hook+0xe8><== NEVER TAKEN
8009b88: 78 0f 08 02 mvhi r15,0x802
8009b8c: 39 ef 10 5c ori r15,r15,0x105c
*
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
8009b90: 34 10 ff fe mvi r16,-2
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8009b94: 34 0d 00 1b mvi r13,27
8009b98: 34 0e 00 20 mvi r14,32
*
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
8009b9c: 90 00 08 00 rcsr r1,IE
8009ba0: a0 30 10 00 and r2,r1,r16
8009ba4: d0 02 00 00 wcsr IE,r2
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
8009ba8: 29 e4 00 00 lw r4,(r15+0)
8009bac: 29 83 00 d4 lw r3,(r12+212)
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
8009bb0: 29 82 00 d0 lw r2,(r12+208)
(api->signals_pending | _POSIX_signals_Pending)) ) {
8009bb4: b8 83 18 00 or r3,r4,r3
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
8009bb8: a4 40 10 00 not r2,r2
8009bbc: a0 62 10 00 and r2,r3,r2
8009bc0: 44 40 00 19 be r2,r0,8009c24 <_POSIX_signals_Post_switch_hook+0xdc>
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
8009bc4: d0 01 00 00 wcsr IE,r1
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8009bc8: 34 0b 00 1b mvi r11,27
_POSIX_signals_Check_signal( api, signo, false );
8009bcc: b9 60 10 00 mv r2,r11
8009bd0: 34 03 00 00 mvi r3,0
8009bd4: b9 80 08 00 mv r1,r12
8009bd8: f8 00 0b 55 calli 800c92c <_POSIX_signals_Check_signal>
_POSIX_signals_Check_signal( api, signo, true );
8009bdc: b9 60 10 00 mv r2,r11
8009be0: b9 80 08 00 mv r1,r12
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8009be4: 35 6b 00 01 addi r11,r11,1
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
8009be8: 34 03 00 01 mvi r3,1
8009bec: f8 00 0b 50 calli 800c92c <_POSIX_signals_Check_signal>
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
8009bf0: 5d 6e ff f7 bne r11,r14,8009bcc <_POSIX_signals_Post_switch_hook+0x84>
8009bf4: 34 0b 00 01 mvi r11,1
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
8009bf8: b9 60 10 00 mv r2,r11
8009bfc: 34 03 00 00 mvi r3,0
8009c00: b9 80 08 00 mv r1,r12
8009c04: f8 00 0b 4a calli 800c92c <_POSIX_signals_Check_signal>
_POSIX_signals_Check_signal( api, signo, true );
8009c08: b9 60 10 00 mv r2,r11
8009c0c: b9 80 08 00 mv r1,r12
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
8009c10: 35 6b 00 01 addi r11,r11,1
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
8009c14: 34 03 00 01 mvi r3,1
8009c18: f8 00 0b 45 calli 800c92c <_POSIX_signals_Check_signal>
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
8009c1c: 5d 6d ff f7 bne r11,r13,8009bf8 <_POSIX_signals_Post_switch_hook+0xb0>
8009c20: e3 ff ff df bi 8009b9c <_POSIX_signals_Post_switch_hook+0x54>
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
8009c24: d0 01 00 00 wcsr IE,r1
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
}
_Thread_Executing->Wait.return_code = hold_errno;
8009c28: 2a 21 00 10 lw r1,(r17+16)
8009c2c: 58 32 00 34 sw (r1+52),r18
}
8009c30: 2b 9d 00 04 lw ra,(sp+4)
8009c34: 2b 8b 00 24 lw r11,(sp+36)
8009c38: 2b 8c 00 20 lw r12,(sp+32)
8009c3c: 2b 8d 00 1c lw r13,(sp+28)
8009c40: 2b 8e 00 18 lw r14,(sp+24)
8009c44: 2b 8f 00 14 lw r15,(sp+20)
8009c48: 2b 90 00 10 lw r16,(sp+16)
8009c4c: 2b 91 00 0c lw r17,(sp+12)
8009c50: 2b 92 00 08 lw r18,(sp+8)
8009c54: 37 9c 00 24 addi sp,sp,36
8009c58: c3 a0 00 00 ret
0801ca8c <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
801ca8c: 37 9c ff ec addi sp,sp,-20
801ca90: 5b 8b 00 14 sw (sp+20),r11
801ca94: 5b 8c 00 10 sw (sp+16),r12
801ca98: 5b 8d 00 0c sw (sp+12),r13
801ca9c: 5b 8e 00 08 sw (sp+8),r14
801caa0: 5b 9d 00 04 sw (sp+4),ra
801caa4: b8 20 58 00 mv r11,r1
801caa8: b8 40 70 00 mv r14,r2
801caac: 34 01 00 01 mvi r1,1
801cab0: 34 42 ff ff addi r2,r2,-1
801cab4: b8 60 68 00 mv r13,r3
801cab8: fb ff fc 7a calli 801bca0 <__ashlsi3>
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
801cabc: 78 02 08 01 mvhi r2,0x801
801cac0: 38 42 de 44 ori r2,r2,0xde44
801cac4: 29 64 00 10 lw r4,(r11+16)
801cac8: 28 43 00 00 lw r3,(r2+0)
{
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
801cacc: 29 65 01 1c lw r5,(r11+284)
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
801cad0: a0 83 10 00 and r2,r4,r3
801cad4: 44 43 00 21 be r2,r3,801cb58 <_POSIX_signals_Unblock_thread+0xcc>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
801cad8: 28 a2 00 d0 lw r2,(r5+208)
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
801cadc: 34 0c 00 00 mvi r12,0
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
801cae0: a4 40 10 00 not r2,r2
801cae4: a0 22 08 00 and r1,r1,r2
801cae8: 44 20 00 14 be r1,r0,801cb38 <_POSIX_signals_Unblock_thread+0xac>
801caec: 78 01 10 00 mvhi r1,0x1000
801caf0: a0 81 08 00 and r1,r4,r1
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
801caf4: 44 20 00 31 be r1,r0,801cbb8 <_POSIX_signals_Unblock_thread+0x12c>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
801caf8: 78 03 08 01 mvhi r3,0x801
the_thread->Wait.return_code = EINTR;
801cafc: 34 01 00 04 mvi r1,4
801cb00: 38 63 dc 04 ori r3,r3,0xdc04
801cb04: 59 61 00 34 sw (r11+52),r1
801cb08: 28 61 00 00 lw r1,(r3+0)
801cb0c: a0 81 08 00 and r1,r4,r1
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
801cb10: 5c 20 00 3a bne r1,r0,801cbf8 <_POSIX_signals_Unblock_thread+0x16c>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_delaying (
States_Control the_states
)
{
return (the_states & STATES_DELAYING);
801cb14: 20 84 00 08 andi r4,r4,0x8
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
801cb18: 44 8c 00 08 be r4,r12,801cb38 <_POSIX_signals_Unblock_thread+0xac><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
801cb1c: 35 61 00 48 addi r1,r11,72
801cb20: fb ff ac 6c calli 8007cd0 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
801cb24: 78 03 08 01 mvhi r3,0x801
801cb28: 38 63 dc 0c ori r3,r3,0xdc0c
801cb2c: 28 62 00 00 lw r2,(r3+0)
801cb30: b9 60 08 00 mv r1,r11
801cb34: fb ff b9 39 calli 800b018 <_Thread_Clear_state>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
801cb38: b9 80 08 00 mv r1,r12
801cb3c: 2b 9d 00 04 lw ra,(sp+4)
801cb40: 2b 8b 00 14 lw r11,(sp+20)
801cb44: 2b 8c 00 10 lw r12,(sp+16)
801cb48: 2b 8d 00 0c lw r13,(sp+12)
801cb4c: 2b 8e 00 08 lw r14,(sp+8)
801cb50: 37 9c 00 14 addi sp,sp,20
801cb54: c3 a0 00 00 ret
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
801cb58: 29 62 00 30 lw r2,(r11+48)
801cb5c: a0 22 10 00 and r2,r1,r2
801cb60: 44 40 00 20 be r2,r0,801cbe0 <_POSIX_signals_Unblock_thread+0x154>
the_thread->Wait.return_code = EINTR;
801cb64: 34 01 00 04 mvi r1,4
801cb68: 59 61 00 34 sw (r11+52),r1
the_info = (siginfo_t *) the_thread->Wait.return_argument;
801cb6c: 29 61 00 28 lw r1,(r11+40)
if ( !info ) {
801cb70: 45 a0 00 25 be r13,r0,801cc04 <_POSIX_signals_Unblock_thread+0x178>
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
801cb74: 29 a2 00 00 lw r2,(r13+0)
801cb78: 58 22 00 00 sw (r1+0),r2
801cb7c: 29 a2 00 04 lw r2,(r13+4)
801cb80: 58 22 00 04 sw (r1+4),r2
801cb84: 29 a2 00 08 lw r2,(r13+8)
801cb88: 58 22 00 08 sw (r1+8),r2
}
_Thread_queue_Extract_with_proxy( the_thread );
801cb8c: b9 60 08 00 mv r1,r11
801cb90: fb ff aa 60 calli 8007510 <_Thread_queue_Extract_with_proxy>
return true;
801cb94: 34 0c 00 01 mvi r12,1
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
801cb98: b9 80 08 00 mv r1,r12
801cb9c: 2b 9d 00 04 lw ra,(sp+4)
801cba0: 2b 8b 00 14 lw r11,(sp+20)
801cba4: 2b 8c 00 10 lw r12,(sp+16)
801cba8: 2b 8d 00 0c lw r13,(sp+12)
801cbac: 2b 8e 00 08 lw r14,(sp+8)
801cbb0: 37 9c 00 14 addi sp,sp,20
801cbb4: c3 a0 00 00 ret
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
801cbb8: 5c 8c ff e0 bne r4,r12,801cb38 <_POSIX_signals_Unblock_thread+0xac><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
801cbbc: 78 01 08 02 mvhi r1,0x802
801cbc0: 38 21 0d e0 ori r1,r1,0xde0
801cbc4: 28 22 00 08 lw r2,(r1+8)
801cbc8: 44 4c ff dc be r2,r12,801cb38 <_POSIX_signals_Unblock_thread+0xac>
801cbcc: 28 22 00 10 lw r2,(r1+16)
801cbd0: 5d 62 ff da bne r11,r2,801cb38 <_POSIX_signals_Unblock_thread+0xac><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
801cbd4: 34 02 00 01 mvi r2,1
801cbd8: 30 22 00 0c sb (r1+12),r2
801cbdc: e3 ff ff d7 bi 801cb38 <_POSIX_signals_Unblock_thread+0xac>
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
801cbe0: 28 a2 00 d0 lw r2,(r5+208)
/*
* This should only be reached via pthread_kill().
*/
return false;
801cbe4: 34 0c 00 00 mvi r12,0
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
801cbe8: a4 40 10 00 not r2,r2
801cbec: a0 22 08 00 and r1,r1,r2
801cbf0: 5c 2c ff dd bne r1,r12,801cb64 <_POSIX_signals_Unblock_thread+0xd8>
801cbf4: e3 ff ff d1 bi 801cb38 <_POSIX_signals_Unblock_thread+0xac>
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
801cbf8: b9 60 08 00 mv r1,r11
801cbfc: fb ff aa 45 calli 8007510 <_Thread_queue_Extract_with_proxy>
801cc00: e3 ff ff ce bi 801cb38 <_POSIX_signals_Unblock_thread+0xac>
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
801cc04: 34 02 00 01 mvi r2,1
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
801cc08: 58 2e 00 00 sw (r1+0),r14
the_info->si_code = SI_USER;
801cc0c: 58 22 00 04 sw (r1+4),r2
the_info->si_value.sival_int = 0;
801cc10: 58 20 00 08 sw (r1+8),r0
801cc14: e3 ff ff de bi 801cb8c <_POSIX_signals_Unblock_thread+0x100>
0800691c <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
800691c: 37 9c ff ec addi sp,sp,-20
8006920: 5b 8b 00 14 sw (sp+20),r11
8006924: 5b 8c 00 10 sw (sp+16),r12
8006928: 5b 8d 00 0c sw (sp+12),r13
800692c: 5b 8e 00 08 sw (sp+8),r14
8006930: 5b 9d 00 04 sw (sp+4),ra
8006934: b8 40 60 00 mv r12,r2
8006938: b8 20 68 00 mv r13,r1
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
800693c: 44 40 00 35 be r2,r0,8006a10 <_RBTree_Extract_unprotected+0xf4>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
8006940: 28 21 00 08 lw r1,(r1+8)
8006944: 44 22 00 4a be r1,r2,8006a6c <_RBTree_Extract_unprotected+0x150>
the_rbtree->first[RBT_LEFT] = next;
}
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
8006948: 29 a1 00 0c lw r1,(r13+12)
800694c: 44 2c 00 4d be r1,r12,8006a80 <_RBTree_Extract_unprotected+0x164>
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
8006950: 29 8b 00 04 lw r11,(r12+4)
8006954: 45 60 00 53 be r11,r0,8006aa0 <_RBTree_Extract_unprotected+0x184>
8006958: 29 81 00 08 lw r1,(r12+8)
800695c: 5c 20 00 03 bne r1,r0,8006968 <_RBTree_Extract_unprotected+0x4c>
8006960: e0 00 00 36 bi 8006a38 <_RBTree_Extract_unprotected+0x11c>
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
8006964: b8 40 58 00 mv r11,r2
8006968: 29 62 00 08 lw r2,(r11+8)
800696c: 5c 40 ff fe bne r2,r0,8006964 <_RBTree_Extract_unprotected+0x48>
* target's position (target is the right child of target->parent)
* when target vacates it. if there is no child, then target->parent
* should become NULL. This may cause the coloring to be violated.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = target->child[RBT_LEFT];
8006970: 29 6e 00 04 lw r14,(r11+4)
if(leaf) {
8006974: 45 c2 00 48 be r14,r2,8006a94 <_RBTree_Extract_unprotected+0x178>
leaf->parent = target->parent;
8006978: 29 61 00 00 lw r1,(r11+0)
800697c: 59 c1 00 00 sw (r14+0),r1
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
dir = target != target->parent->child[0];
8006980: 29 61 00 00 lw r1,(r11+0)
target->parent->child[dir] = leaf;
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
8006984: 29 84 00 00 lw r4,(r12+0)
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
8006988: 29 63 00 0c lw r3,(r11+12)
dir = target != target->parent->child[0];
800698c: 28 22 00 04 lw r2,(r1+4)
8006990: fc 4b 10 00 cmpne r2,r2,r11
target->parent->child[dir] = leaf;
8006994: b4 42 10 00 add r2,r2,r2
8006998: b4 42 10 00 add r2,r2,r2
800699c: b4 22 10 00 add r2,r1,r2
80069a0: 58 4e 00 04 sw (r2+4),r14
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
80069a4: 28 81 00 04 lw r1,(r4+4)
80069a8: fc 2c 08 00 cmpne r1,r1,r12
the_node->parent->child[dir] = target;
80069ac: b4 21 08 00 add r1,r1,r1
80069b0: b4 21 08 00 add r1,r1,r1
80069b4: b4 81 08 00 add r1,r4,r1
80069b8: 58 2b 00 04 sw (r1+4),r11
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
80069bc: 29 81 00 08 lw r1,(r12+8)
80069c0: 59 61 00 08 sw (r11+8),r1
if (the_node->child[RBT_RIGHT])
80069c4: 29 81 00 08 lw r1,(r12+8)
80069c8: 44 20 00 02 be r1,r0,80069d0 <_RBTree_Extract_unprotected+0xb4><== NEVER TAKEN
the_node->child[RBT_RIGHT]->parent = target;
80069cc: 58 2b 00 00 sw (r1+0),r11
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
80069d0: 29 81 00 04 lw r1,(r12+4)
80069d4: 59 61 00 04 sw (r11+4),r1
if (the_node->child[RBT_LEFT])
80069d8: 29 81 00 04 lw r1,(r12+4)
80069dc: 44 20 00 02 be r1,r0,80069e4 <_RBTree_Extract_unprotected+0xc8>
the_node->child[RBT_LEFT]->parent = target;
80069e0: 58 2b 00 00 sw (r1+0),r11
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
80069e4: 29 82 00 00 lw r2,(r12+0)
target->color = the_node->color;
80069e8: 29 81 00 0c lw r1,(r12+12)
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
80069ec: 59 62 00 00 sw (r11+0),r2
target->color = the_node->color;
80069f0: 59 61 00 0c sw (r11+12),r1
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
80069f4: 44 60 00 0e be r3,r0,8006a2c <_RBTree_Extract_unprotected+0x110>
/* Wipe the_node */
_RBTree_Set_off_rbtree(the_node);
/* set root to black, if it exists */
if (the_rbtree->root) the_rbtree->root->color = RBT_BLACK;
80069f8: 29 a1 00 04 lw r1,(r13+4)
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree(
RBTree_Node *node
)
{
node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL;
80069fc: 59 80 00 08 sw (r12+8),r0
8006a00: 59 80 00 04 sw (r12+4),r0
8006a04: 59 80 00 00 sw (r12+0),r0
8006a08: 44 20 00 02 be r1,r0,8006a10 <_RBTree_Extract_unprotected+0xf4>
8006a0c: 58 20 00 0c sw (r1+12),r0
}
8006a10: 2b 9d 00 04 lw ra,(sp+4)
8006a14: 2b 8b 00 14 lw r11,(sp+20)
8006a18: 2b 8c 00 10 lw r12,(sp+16)
8006a1c: 2b 8d 00 0c lw r13,(sp+12)
8006a20: 2b 8e 00 08 lw r14,(sp+8)
8006a24: 37 9c 00 14 addi sp,sp,20
8006a28: c3 a0 00 00 ret
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
if (leaf) {
8006a2c: 45 c3 ff f3 be r14,r3,80069f8 <_RBTree_Extract_unprotected+0xdc>
leaf->color = RBT_BLACK; /* case 2 */
8006a30: 59 c0 00 0c sw (r14+12),r0
8006a34: e3 ff ff f1 bi 80069f8 <_RBTree_Extract_unprotected+0xdc>
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
8006a38: b9 60 70 00 mv r14,r11
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
if( leaf ) {
leaf->parent = the_node->parent;
8006a3c: 29 81 00 00 lw r1,(r12+0)
8006a40: 59 c1 00 00 sw (r14+0),r1
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
8006a44: 29 82 00 00 lw r2,(r12+0)
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
8006a48: 29 83 00 0c lw r3,(r12+12)
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
8006a4c: 28 41 00 04 lw r1,(r2+4)
8006a50: fc 2c 08 00 cmpne r1,r1,r12
the_node->parent->child[dir] = leaf;
8006a54: b4 21 08 00 add r1,r1,r1
8006a58: b4 21 08 00 add r1,r1,r1
8006a5c: b4 41 08 00 add r1,r2,r1
8006a60: 58 2e 00 04 sw (r1+4),r14
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
8006a64: 5c 60 ff e5 bne r3,r0,80069f8 <_RBTree_Extract_unprotected+0xdc>
8006a68: e3 ff ff f1 bi 8006a2c <_RBTree_Extract_unprotected+0x110>
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_RIGHT );
8006a6c: b8 40 08 00 mv r1,r2
8006a70: 34 02 00 01 mvi r2,1
8006a74: f8 00 01 09 calli 8006e98 <_RBTree_Next_unprotected>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
RBTree_Node *next;
next = _RBTree_Successor_unprotected(the_node);
the_rbtree->first[RBT_LEFT] = next;
8006a78: 59 a1 00 08 sw (r13+8),r1
8006a7c: e3 ff ff b3 bi 8006948 <_RBTree_Extract_unprotected+0x2c>
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_LEFT );
8006a80: b9 80 08 00 mv r1,r12
8006a84: 34 02 00 00 mvi r2,0
8006a88: f8 00 01 04 calli 8006e98 <_RBTree_Next_unprotected>
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
RBTree_Node *previous;
previous = _RBTree_Predecessor_unprotected(the_node);
the_rbtree->first[RBT_RIGHT] = previous;
8006a8c: 59 a1 00 0c sw (r13+12),r1
8006a90: e3 ff ff b0 bi 8006950 <_RBTree_Extract_unprotected+0x34>
leaf = target->child[RBT_LEFT];
if(leaf) {
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
8006a94: b9 60 08 00 mv r1,r11
8006a98: fb ff fe e2 calli 8006620 <_RBTree_Extract_validate_unprotected>
8006a9c: e3 ff ff b9 bi 8006980 <_RBTree_Extract_unprotected+0x64>
* the_node's location in the tree. This may cause the coloring to be
* violated. We will fix it later.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
8006aa0: 29 8e 00 08 lw r14,(r12+8)
if( leaf ) {
8006aa4: 5d cb ff e6 bne r14,r11,8006a3c <_RBTree_Extract_unprotected+0x120>
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
8006aa8: b9 80 08 00 mv r1,r12
8006aac: fb ff fe dd calli 8006620 <_RBTree_Extract_validate_unprotected>
8006ab0: e3 ff ff e5 bi 8006a44 <_RBTree_Extract_unprotected+0x128>
08006620 <_RBTree_Extract_validate_unprotected>:
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
RBTree_Node *the_node
)
{
8006620: 37 9c ff fc addi sp,sp,-4
8006624: 5b 8b 00 04 sw (sp+4),r11
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
8006628: 28 22 00 00 lw r2,(r1+0)
if(!parent->parent) return;
800662c: 28 43 00 00 lw r3,(r2+0)
8006630: 44 60 00 23 be r3,r0,80066bc <_RBTree_Extract_validate_unprotected+0x9c>
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
8006634: 28 43 00 04 lw r3,(r2+4)
8006638: 44 23 00 af be r1,r3,80068f4 <_RBTree_Extract_validate_unprotected+0x2d4>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
800663c: 34 04 00 01 mvi r4,1
8006640: e0 00 00 1a bi 80066a8 <_RBTree_Extract_validate_unprotected+0x88>
sibling = _RBTree_Sibling(the_node);
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
8006644: 28 45 00 00 lw r5,(r2+0)
8006648: 44 a0 00 1a be r5,r0,80066b0 <_RBTree_Extract_validate_unprotected+0x90>
800664c: 44 60 00 03 be r3,r0,8006658 <_RBTree_Extract_validate_unprotected+0x38><== NEVER TAKEN
8006650: 28 66 00 0c lw r6,(r3+12)
8006654: 44 c4 00 1d be r6,r4,80066c8 <_RBTree_Extract_validate_unprotected+0xa8>
_RBTree_Rotate(parent, dir);
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
8006658: 28 65 00 08 lw r5,(r3+8)
800665c: 44 a0 00 03 be r5,r0,8006668 <_RBTree_Extract_validate_unprotected+0x48>
8006660: 28 a6 00 0c lw r6,(r5+12)
8006664: 44 c4 00 4d be r6,r4,8006798 <_RBTree_Extract_validate_unprotected+0x178>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
8006668: 28 66 00 04 lw r6,(r3+4)
800666c: 44 c0 00 03 be r6,r0,8006678 <_RBTree_Extract_validate_unprotected+0x58>
8006670: 28 c6 00 0c lw r6,(r6+12)
8006674: 44 c4 00 49 be r6,r4,8006798 <_RBTree_Extract_validate_unprotected+0x178>
sibling->color = RBT_RED;
8006678: 58 64 00 0c sw (r3+12),r4
800667c: 28 43 00 0c lw r3,(r2+12)
8006680: 44 64 00 3c be r3,r4,8006770 <_RBTree_Extract_validate_unprotected+0x150>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
8006684: 28 45 00 00 lw r5,(r2+0)
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
8006688: 34 03 00 00 mvi r3,0
800668c: 44 a0 00 05 be r5,r0,80066a0 <_RBTree_Extract_validate_unprotected+0x80><== NEVER TAKEN
if(!(the_node->parent->parent)) return NULL;
8006690: 28 a1 00 00 lw r1,(r5+0)
8006694: 44 20 00 03 be r1,r0,80066a0 <_RBTree_Extract_validate_unprotected+0x80>
if(the_node == the_node->parent->child[RBT_LEFT])
8006698: 28 a3 00 04 lw r3,(r5+4)
800669c: 44 43 00 3d be r2,r3,8006790 <_RBTree_Extract_validate_unprotected+0x170>
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
c->parent = the_node->parent;
the_node->parent = c;
80066a0: b8 40 08 00 mv r1,r2
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
80066a4: b8 a0 10 00 mv r2,r5
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
80066a8: 28 25 00 0c lw r5,(r1+12)
80066ac: 5c a4 ff e6 bne r5,r4,8006644 <_RBTree_Extract_validate_unprotected+0x24>
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
80066b0: 28 22 00 00 lw r2,(r1+0)
80066b4: 28 42 00 00 lw r2,(r2+0)
80066b8: 44 40 00 32 be r2,r0,8006780 <_RBTree_Extract_validate_unprotected+0x160>
}
80066bc: 2b 8b 00 04 lw r11,(sp+4)
80066c0: 37 9c 00 04 addi sp,sp,4
80066c4: c3 a0 00 00 ret
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
80066c8: 28 46 00 04 lw r6,(r2+4)
* then rotate parent left, making the sibling be the_node's grandparent.
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
80066cc: 58 44 00 0c sw (r2+12),r4
sibling->color = RBT_BLACK;
80066d0: 58 60 00 0c sw (r3+12),r0
dir = the_node != parent->child[0];
80066d4: fc c1 50 00 cmpne r10,r6,r1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
80066d8: 34 03 00 00 mvi r3,0
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
80066dc: 19 49 00 01 xori r9,r10,0x1
80066e0: b5 29 38 00 add r7,r9,r9
80066e4: b4 e7 40 00 add r8,r7,r7
80066e8: b4 48 40 00 add r8,r2,r8
80066ec: 29 08 00 04 lw r8,(r8+4)
80066f0: 45 00 ff da be r8,r0,8006658 <_RBTree_Extract_validate_unprotected+0x38><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
80066f4: 34 08 00 00 mvi r8,0
80066f8: 45 20 00 03 be r9,r0,8006704 <_RBTree_Extract_validate_unprotected+0xe4>
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
80066fc: 28 46 00 08 lw r6,(r2+8)
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006700: 34 08 00 01 mvi r8,1
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
8006704: b5 4a 18 00 add r3,r10,r10
8006708: b4 63 48 00 add r9,r3,r3
800670c: b4 c9 48 00 add r9,r6,r9
8006710: b5 08 40 00 add r8,r8,r8
8006714: 29 2a 00 04 lw r10,(r9+4)
8006718: b5 08 40 00 add r8,r8,r8
800671c: b4 48 40 00 add r8,r2,r8
8006720: 59 0a 00 04 sw (r8+4),r10
if (c->child[dir])
8006724: 29 28 00 04 lw r8,(r9+4)
8006728: 45 00 00 03 be r8,r0,8006734 <_RBTree_Extract_validate_unprotected+0x114><== NEVER TAKEN
c->child[dir]->parent = the_node;
800672c: 59 02 00 00 sw (r8+0),r2
8006730: 28 45 00 00 lw r5,(r2+0)
c->child[dir] = the_node;
8006734: b4 63 18 00 add r3,r3,r3
8006738: b4 c3 18 00 add r3,r6,r3
800673c: 58 62 00 04 sw (r3+4),r2
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
8006740: 28 a3 00 04 lw r3,(r5+4)
c->parent = the_node->parent;
8006744: 58 c5 00 00 sw (r6+0),r5
the_node->parent = c;
8006748: b4 e7 38 00 add r7,r7,r7
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
800674c: fc 43 18 00 cmpne r3,r2,r3
c->parent = the_node->parent;
the_node->parent = c;
8006750: b4 47 38 00 add r7,r2,r7
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
8006754: b4 63 18 00 add r3,r3,r3
8006758: b4 63 18 00 add r3,r3,r3
800675c: b4 a3 28 00 add r5,r5,r3
8006760: 58 a6 00 04 sw (r5+4),r6
c->parent = the_node->parent;
the_node->parent = c;
8006764: 28 e3 00 04 lw r3,(r7+4)
8006768: 58 46 00 00 sw (r2+0),r6
800676c: e3 ff ff bb bi 8006658 <_RBTree_Extract_validate_unprotected+0x38>
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
8006770: 58 40 00 0c sw (r2+12),r0
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
8006774: 28 22 00 00 lw r2,(r1+0)
8006778: 28 42 00 00 lw r2,(r2+0)
800677c: 5c 40 ff d0 bne r2,r0,80066bc <_RBTree_Extract_validate_unprotected+0x9c><== ALWAYS TAKEN
8006780: 58 20 00 0c sw (r1+12),r0
}
8006784: 2b 8b 00 04 lw r11,(sp+4)
8006788: 37 9c 00 04 addi sp,sp,4
800678c: c3 a0 00 00 ret
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
8006790: 28 a3 00 08 lw r3,(r5+8)
8006794: e3 ff ff c3 bi 80066a0 <_RBTree_Extract_validate_unprotected+0x80>
* cases, either the_node is to the left or the right of the parent.
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
8006798: 28 47 00 04 lw r7,(r2+4)
800679c: fc e1 38 00 cmpne r7,r7,r1
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
80067a0: 18 e8 00 01 xori r8,r7,0x1
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
80067a4: b5 08 20 00 add r4,r8,r8
80067a8: b4 84 48 00 add r9,r4,r4
80067ac: b4 69 30 00 add r6,r3,r9
80067b0: 28 c6 00 04 lw r6,(r6+4)
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
80067b4: 44 c0 00 04 be r6,r0,80067c4 <_RBTree_Extract_validate_unprotected+0x1a4>
80067b8: 28 cb 00 0c lw r11,(r6+12)
80067bc: 34 0a 00 01 mvi r10,1
80067c0: 45 6a 00 54 be r11,r10,8006910 <_RBTree_Extract_validate_unprotected+0x2f0>
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
80067c4: b4 e7 48 00 add r9,r7,r7
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
80067c8: 19 0a 00 01 xori r10,r8,0x1
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
80067cc: b5 29 48 00 add r9,r9,r9
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
80067d0: b5 4a 30 00 add r6,r10,r10
80067d4: b4 69 48 00 add r9,r3,r9
80067d8: b4 c6 30 00 add r6,r6,r6
80067dc: 29 29 00 04 lw r9,(r9+4)
80067e0: b4 66 30 00 add r6,r3,r6
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
80067e4: 34 0b 00 01 mvi r11,1
80067e8: 28 c6 00 04 lw r6,(r6+4)
80067ec: 58 6b 00 0c sw (r3+12),r11
sibling->child[dir]->color = RBT_BLACK;
80067f0: 59 20 00 0c sw (r9+12),r0
80067f4: 44 c0 00 1a be r6,r0,800685c <_RBTree_Extract_validate_unprotected+0x23c><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
80067f8: 5d 40 00 41 bne r10,r0,80068fc <_RBTree_Extract_validate_unprotected+0x2dc>
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
80067fc: 28 65 00 04 lw r5,(r3+4)
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006800: 34 06 00 00 mvi r6,0
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
8006804: b4 84 48 00 add r9,r4,r4
8006808: b4 a9 48 00 add r9,r5,r9
800680c: b4 c6 30 00 add r6,r6,r6
8006810: 29 2a 00 04 lw r10,(r9+4)
8006814: b4 c6 30 00 add r6,r6,r6
8006818: b4 66 30 00 add r6,r3,r6
800681c: 58 ca 00 04 sw (r6+4),r10
if (c->child[dir])
8006820: 29 26 00 04 lw r6,(r9+4)
8006824: 44 c0 00 02 be r6,r0,800682c <_RBTree_Extract_validate_unprotected+0x20c>
c->child[dir]->parent = the_node;
8006828: 58 c3 00 00 sw (r6+0),r3
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
800682c: 28 66 00 00 lw r6,(r3+0)
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
8006830: b4 84 48 00 add r9,r4,r4
8006834: b4 a9 48 00 add r9,r5,r9
8006838: 59 23 00 04 sw (r9+4),r3
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
800683c: 28 c9 00 04 lw r9,(r6+4)
c->parent = the_node->parent;
8006840: 58 a6 00 00 sw (r5+0),r6
the_node->parent = c;
8006844: 58 65 00 00 sw (r3+0),r5
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
8006848: fc 69 18 00 cmpne r3,r3,r9
800684c: b4 63 18 00 add r3,r3,r3
8006850: b4 63 18 00 add r3,r3,r3
8006854: b4 c3 18 00 add r3,r6,r3
8006858: 58 65 00 04 sw (r3+4),r5
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
800685c: b4 84 20 00 add r4,r4,r4
8006860: b4 44 18 00 add r3,r2,r4
8006864: 28 63 00 04 lw r3,(r3+4)
8006868: b4 64 20 00 add r4,r3,r4
800686c: 28 86 00 04 lw r6,(r4+4)
8006870: b8 60 20 00 mv r4,r3
}
sibling->color = parent->color;
8006874: 28 45 00 0c lw r5,(r2+12)
8006878: 58 65 00 0c sw (r3+12),r5
parent->color = RBT_BLACK;
800687c: 58 40 00 0c sw (r2+12),r0
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
8006880: 58 c0 00 0c sw (r6+12),r0
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
8006884: 44 80 ff 8b be r4,r0,80066b0 <_RBTree_Extract_validate_unprotected+0x90><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006888: 45 00 00 1f be r8,r0,8006904 <_RBTree_Extract_validate_unprotected+0x2e4>
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
800688c: 28 43 00 08 lw r3,(r2+8)
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006890: 34 04 00 01 mvi r4,1
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
8006894: b4 e7 38 00 add r7,r7,r7
8006898: b4 e7 28 00 add r5,r7,r7
800689c: b4 65 28 00 add r5,r3,r5
80068a0: b4 84 20 00 add r4,r4,r4
80068a4: 28 a6 00 04 lw r6,(r5+4)
80068a8: b4 84 20 00 add r4,r4,r4
80068ac: b4 44 20 00 add r4,r2,r4
80068b0: 58 86 00 04 sw (r4+4),r6
if (c->child[dir])
80068b4: 28 a4 00 04 lw r4,(r5+4)
80068b8: 44 80 00 02 be r4,r0,80068c0 <_RBTree_Extract_validate_unprotected+0x2a0>
c->child[dir]->parent = the_node;
80068bc: 58 82 00 00 sw (r4+0),r2
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
80068c0: 28 44 00 00 lw r4,(r2+0)
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
80068c4: b4 e7 38 00 add r7,r7,r7
80068c8: b4 67 38 00 add r7,r3,r7
80068cc: 58 e2 00 04 sw (r7+4),r2
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
80068d0: 28 85 00 04 lw r5,(r4+4)
c->parent = the_node->parent;
80068d4: 58 64 00 00 sw (r3+0),r4
the_node->parent = c;
80068d8: 58 43 00 00 sw (r2+0),r3
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
80068dc: fc 45 10 00 cmpne r2,r2,r5
80068e0: b4 42 10 00 add r2,r2,r2
80068e4: b4 42 10 00 add r2,r2,r2
80068e8: b4 82 10 00 add r2,r4,r2
80068ec: 58 43 00 04 sw (r2+4),r3
80068f0: e3 ff ff 70 bi 80066b0 <_RBTree_Extract_validate_unprotected+0x90>
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
80068f4: 28 43 00 08 lw r3,(r2+8)
80068f8: e3 ff ff 51 bi 800663c <_RBTree_Extract_validate_unprotected+0x1c>
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
80068fc: 34 06 00 01 mvi r6,1
8006900: e3 ff ff c1 bi 8006804 <_RBTree_Extract_validate_unprotected+0x1e4>
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
8006904: 28 43 00 04 lw r3,(r2+4)
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006908: 34 04 00 00 mvi r4,0
800690c: e3 ff ff e2 bi 8006894 <_RBTree_Extract_validate_unprotected+0x274>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
8006910: b4 49 48 00 add r9,r2,r9
8006914: 29 24 00 04 lw r4,(r9+4)
8006918: e3 ff ff d7 bi 8006874 <_RBTree_Extract_validate_unprotected+0x254>
08006d00 <_RBTree_Find>:
RBTree_Node *_RBTree_Find(
RBTree_Control *the_rbtree,
RBTree_Node *search_node
)
{
8006d00: 37 9c ff e8 addi sp,sp,-24
8006d04: 5b 8b 00 18 sw (sp+24),r11
8006d08: 5b 8c 00 14 sw (sp+20),r12
8006d0c: 5b 8d 00 10 sw (sp+16),r13
8006d10: 5b 8e 00 0c sw (sp+12),r14
8006d14: 5b 8f 00 08 sw (sp+8),r15
8006d18: 5b 9d 00 04 sw (sp+4),ra
8006d1c: b8 20 60 00 mv r12,r1
8006d20: b8 40 68 00 mv r13,r2
ISR_Level level;
RBTree_Node *return_node;
return_node = NULL;
_ISR_Disable( level );
8006d24: 90 00 78 00 rcsr r15,IE
8006d28: 34 01 ff fe mvi r1,-2
8006d2c: a1 e1 08 00 and r1,r15,r1
8006d30: d0 01 00 00 wcsr IE,r1
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
8006d34: 29 8b 00 04 lw r11,(r12+4)
RBTree_Node* found = NULL;
8006d38: 34 0e 00 00 mvi r14,0
int compare_result;
while (iter_node) {
8006d3c: 45 60 00 0f be r11,r0,8006d78 <_RBTree_Find+0x78> <== NEVER TAKEN
compare_result = the_rbtree->compare_function(the_node, iter_node);
8006d40: 29 83 00 10 lw r3,(r12+16)
8006d44: b9 60 10 00 mv r2,r11
8006d48: b9 a0 08 00 mv r1,r13
8006d4c: d8 60 00 00 call r3
found = iter_node;
if ( the_rbtree->is_unique )
break;
}
RBTree_Direction dir =
8006d50: 68 23 00 00 cmpgi r3,r1,0
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
8006d54: 5c 20 00 04 bne r1,r0,8006d64 <_RBTree_Find+0x64>
found = iter_node;
if ( the_rbtree->is_unique )
8006d58: 41 82 00 14 lbu r2,(r12+20)
8006d5c: b9 60 70 00 mv r14,r11
8006d60: 5c 41 00 10 bne r2,r1,8006da0 <_RBTree_Find+0xa0>
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
8006d64: b4 63 18 00 add r3,r3,r3
8006d68: b4 63 18 00 add r3,r3,r3
8006d6c: b5 63 58 00 add r11,r11,r3
8006d70: 29 6b 00 04 lw r11,(r11+4)
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
8006d74: 5d 60 ff f3 bne r11,r0,8006d40 <_RBTree_Find+0x40>
return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
_ISR_Enable( level );
8006d78: d0 0f 00 00 wcsr IE,r15
return return_node;
}
8006d7c: b9 c0 08 00 mv r1,r14
8006d80: 2b 9d 00 04 lw ra,(sp+4)
8006d84: 2b 8b 00 18 lw r11,(sp+24)
8006d88: 2b 8c 00 14 lw r12,(sp+20)
8006d8c: 2b 8d 00 10 lw r13,(sp+16)
8006d90: 2b 8e 00 0c lw r14,(sp+12)
8006d94: 2b 8f 00 08 lw r15,(sp+8)
8006d98: 37 9c 00 18 addi sp,sp,24
8006d9c: c3 a0 00 00 ret
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
found = iter_node;
if ( the_rbtree->is_unique )
8006da0: b9 60 70 00 mv r14,r11
8006da4: e3 ff ff f5 bi 8006d78 <_RBTree_Find+0x78>
080071e4 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
80071e4: 37 9c ff ec addi sp,sp,-20
80071e8: 5b 8b 00 14 sw (sp+20),r11
80071ec: 5b 8c 00 10 sw (sp+16),r12
80071f0: 5b 8d 00 0c sw (sp+12),r13
80071f4: 5b 8e 00 08 sw (sp+8),r14
80071f8: 5b 9d 00 04 sw (sp+4),ra
80071fc: b8 20 68 00 mv r13,r1
8007200: b8 80 58 00 mv r11,r4
8007204: b8 a0 70 00 mv r14,r5
8007208: 20 c6 00 ff andi r6,r6,0xff
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
800720c: 44 20 00 0f be r1,r0,8007248 <_RBTree_Initialize+0x64> <== NEVER TAKEN
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
8007210: 58 20 00 00 sw (r1+0),r0
the_rbtree->root = NULL;
8007214: 58 20 00 04 sw (r1+4),r0
the_rbtree->first[0] = NULL;
8007218: 58 20 00 08 sw (r1+8),r0
the_rbtree->first[1] = NULL;
800721c: 58 20 00 0c sw (r1+12),r0
the_rbtree->compare_function = compare_function;
8007220: 58 22 00 10 sw (r1+16),r2
the_rbtree->is_unique = is_unique;
8007224: 30 26 00 14 sb (r1+20),r6
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
8007228: 44 80 00 08 be r4,r0,8007248 <_RBTree_Initialize+0x64> <== NEVER TAKEN
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
800722c: b8 60 60 00 mv r12,r3
while ( count-- ) {
_RBTree_Insert_unprotected(the_rbtree, next);
8007230: b9 80 10 00 mv r2,r12
8007234: b9 a0 08 00 mv r1,r13
#include <rtems/system.h>
#include <rtems/score/address.h>
#include <rtems/score/rbtree.h>
#include <rtems/score/isr.h>
void _RBTree_Initialize(
8007238: 35 6b ff ff addi r11,r11,-1
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
_RBTree_Insert_unprotected(the_rbtree, next);
800723c: fb ff fe f1 calli 8006e00 <_RBTree_Insert_unprotected>
#include <rtems/system.h>
#include <rtems/score/address.h>
#include <rtems/score/rbtree.h>
#include <rtems/score/isr.h>
void _RBTree_Initialize(
8007240: b5 8e 60 00 add r12,r12,r14
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
8007244: 5d 60 ff fb bne r11,r0,8007230 <_RBTree_Initialize+0x4c>
_RBTree_Insert_unprotected(the_rbtree, next);
next = (RBTree_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
}
8007248: 2b 9d 00 04 lw ra,(sp+4)
800724c: 2b 8b 00 14 lw r11,(sp+20)
8007250: 2b 8c 00 10 lw r12,(sp+16)
8007254: 2b 8d 00 0c lw r13,(sp+12)
8007258: 2b 8e 00 08 lw r14,(sp+8)
800725c: 37 9c 00 14 addi sp,sp,20
8007260: c3 a0 00 00 ret
08006ae8 <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
8006ae8: 37 9c ff e4 addi sp,sp,-28
8006aec: 5b 8b 00 1c sw (sp+28),r11
8006af0: 5b 8c 00 18 sw (sp+24),r12
8006af4: 5b 8d 00 14 sw (sp+20),r13
8006af8: 5b 8e 00 10 sw (sp+16),r14
8006afc: 5b 8f 00 0c sw (sp+12),r15
8006b00: 5b 90 00 08 sw (sp+8),r16
8006b04: 5b 9d 00 04 sw (sp+4),ra
if(!the_node) return (RBTree_Node*)-1;
8006b08: 34 0d ff ff mvi r13,-1
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
8006b0c: b8 40 58 00 mv r11,r2
8006b10: b8 20 60 00 mv r12,r1
if(!the_node) return (RBTree_Node*)-1;
8006b14: 44 40 00 87 be r2,r0,8006d30 <_RBTree_Insert_unprotected+0x248><== NEVER TAKEN
RBTree_Node *iter_node = the_rbtree->root;
8006b18: 28 2f 00 04 lw r15,(r1+4)
int compare_result;
if (!iter_node) { /* special case: first node inserted */
8006b1c: 5d e0 00 03 bne r15,r0,8006b28 <_RBTree_Insert_unprotected+0x40>
8006b20: e0 00 00 a3 bi 8006dac <_RBTree_Insert_unprotected+0x2c4>
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
if (!iter_node->child[dir]) {
8006b24: b9 a0 78 00 mv r15,r13
the_node->parent = (RBTree_Node *) the_rbtree;
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
8006b28: 29 83 00 10 lw r3,(r12+16)
8006b2c: b9 e0 10 00 mv r2,r15
8006b30: b9 60 08 00 mv r1,r11
8006b34: d8 60 00 00 call r3
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
8006b38: 41 82 00 14 lbu r2,(r12+20)
8006b3c: 44 40 00 02 be r2,r0,8006b44 <_RBTree_Insert_unprotected+0x5c>
8006b40: 44 20 00 99 be r1,r0,8006da4 <_RBTree_Insert_unprotected+0x2bc><== NEVER TAKEN
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
8006b44: a4 20 08 00 not r1,r1
8006b48: 34 02 00 1f mvi r2,31
8006b4c: fb ff e8 7f calli 8000d48 <__lshrsi3>
if (!iter_node->child[dir]) {
8006b50: b4 21 18 00 add r3,r1,r1
8006b54: b4 63 18 00 add r3,r3,r3
8006b58: b5 e3 18 00 add r3,r15,r3
8006b5c: 28 6d 00 04 lw r13,(r3+4)
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
8006b60: b8 20 70 00 mv r14,r1
if (!iter_node->child[dir]) {
8006b64: 34 63 00 04 addi r3,r3,4
8006b68: 5d a0 ff ef bne r13,r0,8006b24 <_RBTree_Insert_unprotected+0x3c>
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
8006b6c: 34 30 00 02 addi r16,r1,2
8006b70: b6 10 08 00 add r1,r16,r16
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
8006b74: 59 60 00 08 sw (r11+8),r0
8006b78: 59 60 00 04 sw (r11+4),r0
8006b7c: b4 21 08 00 add r1,r1,r1
the_node->color = RBT_RED;
iter_node->child[dir] = the_node;
8006b80: 58 6b 00 00 sw (r3+0),r11
8006b84: b5 81 08 00 add r1,r12,r1
the_node->parent = iter_node;
8006b88: 59 6f 00 00 sw (r11+0),r15
/* update min/max */
compare_result = the_rbtree->compare_function(
8006b8c: 28 22 00 00 lw r2,(r1+0)
8006b90: 29 84 00 10 lw r4,(r12+16)
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
if (!iter_node->child[dir]) {
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
the_node->color = RBT_RED;
8006b94: 34 03 00 01 mvi r3,1
8006b98: 59 63 00 0c sw (r11+12),r3
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
/* update min/max */
compare_result = the_rbtree->compare_function(
8006b9c: b9 60 08 00 mv r1,r11
8006ba0: d8 80 00 00 call r4
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
8006ba4: 5d cd 00 6f bne r14,r13,8006d60 <_RBTree_Insert_unprotected+0x278>
8006ba8: 49 a1 00 6f bg r13,r1,8006d64 <_RBTree_Insert_unprotected+0x27c>
(dir && _RBTree_Is_greater(compare_result)) ) {
the_rbtree->first[dir] = the_node;
8006bac: 29 63 00 00 lw r3,(r11+0)
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
8006bb0: 34 06 00 01 mvi r6,1
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
8006bb4: 28 62 00 00 lw r2,(r3+0)
8006bb8: b8 40 08 00 mv r1,r2
8006bbc: 44 40 00 5c be r2,r0,8006d2c <_RBTree_Insert_unprotected+0x244>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
8006bc0: 28 64 00 0c lw r4,(r3+12)
8006bc4: 5c 86 00 5b bne r4,r6,8006d30 <_RBTree_Insert_unprotected+0x248>
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(!(the_node->parent->parent->parent)) return NULL;
8006bc8: 28 47 00 00 lw r7,(r2+0)
8006bcc: 44 e0 00 74 be r7,r0,8006d9c <_RBTree_Insert_unprotected+0x2b4><== NEVER TAKEN
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
8006bd0: 28 44 00 04 lw r4,(r2+4)
8006bd4: b8 80 28 00 mv r5,r4
8006bd8: 44 64 00 60 be r3,r4,8006d58 <_RBTree_Insert_unprotected+0x270>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
8006bdc: 44 a0 00 03 be r5,r0,8006be8 <_RBTree_Insert_unprotected+0x100>
8006be0: 28 a8 00 0c lw r8,(r5+12)
8006be4: 45 06 00 65 be r8,r6,8006d78 <_RBTree_Insert_unprotected+0x290>
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
8006be8: 28 65 00 04 lw r5,(r3+4)
RBTree_Direction pdir = the_node->parent != g->child[0];
8006bec: fc 64 20 00 cmpne r4,r3,r4
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
8006bf0: fd 65 38 00 cmpne r7,r11,r5
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
8006bf4: 44 e4 00 27 be r7,r4,8006c90 <_RBTree_Insert_unprotected+0x1a8>
* in an unique @a the_rbtree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
RBTree_Node *_RBTree_Insert_unprotected(
8006bf8: 18 89 00 01 xori r9,r4,0x1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
8006bfc: b5 29 38 00 add r7,r9,r9
8006c00: b4 e7 38 00 add r7,r7,r7
8006c04: b4 67 38 00 add r7,r3,r7
8006c08: 28 e8 00 04 lw r8,(r7+4)
8006c0c: b4 84 38 00 add r7,r4,r4
8006c10: 45 00 00 1c be r8,r0,8006c80 <_RBTree_Insert_unprotected+0x198><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006c14: 34 08 00 00 mvi r8,0
8006c18: 45 20 00 03 be r9,r0,8006c24 <_RBTree_Insert_unprotected+0x13c>
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
8006c1c: 28 65 00 08 lw r5,(r3+8)
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006c20: 34 08 00 01 mvi r8,1
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
8006c24: b4 84 38 00 add r7,r4,r4
8006c28: b4 e7 48 00 add r9,r7,r7
8006c2c: b4 a9 48 00 add r9,r5,r9
8006c30: b5 08 40 00 add r8,r8,r8
8006c34: 29 2a 00 04 lw r10,(r9+4)
8006c38: b5 08 40 00 add r8,r8,r8
8006c3c: b4 68 40 00 add r8,r3,r8
8006c40: 59 0a 00 04 sw (r8+4),r10
if (c->child[dir])
8006c44: 29 28 00 04 lw r8,(r9+4)
8006c48: 45 00 00 03 be r8,r0,8006c54 <_RBTree_Insert_unprotected+0x16c>
c->child[dir]->parent = the_node;
8006c4c: 59 03 00 00 sw (r8+0),r3
8006c50: 28 62 00 00 lw r2,(r3+0)
c->child[dir] = the_node;
8006c54: b4 e7 40 00 add r8,r7,r7
8006c58: b4 a8 40 00 add r8,r5,r8
8006c5c: 59 03 00 04 sw (r8+4),r3
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
8006c60: 28 48 00 04 lw r8,(r2+4)
c->parent = the_node->parent;
8006c64: 58 a2 00 00 sw (r5+0),r2
the_node->parent = c;
8006c68: 58 65 00 00 sw (r3+0),r5
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
8006c6c: fc 68 18 00 cmpne r3,r3,r8
8006c70: b4 63 18 00 add r3,r3,r3
8006c74: b4 63 18 00 add r3,r3,r3
8006c78: b4 43 10 00 add r2,r2,r3
8006c7c: 58 45 00 04 sw (r2+4),r5
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
8006c80: b4 e7 38 00 add r7,r7,r7
8006c84: b5 67 58 00 add r11,r11,r7
8006c88: 29 6b 00 04 lw r11,(r11+4)
8006c8c: 29 63 00 00 lw r3,(r11+0)
}
the_node->parent->color = RBT_BLACK;
g->color = RBT_RED;
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
8006c90: c8 c4 20 00 sub r4,r6,r4
* in an unique @a the_rbtree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
RBTree_Node *_RBTree_Insert_unprotected(
8006c94: 64 85 00 00 cmpei r5,r4,0
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
8006c98: 58 60 00 0c sw (r3+12),r0
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
8006c9c: b4 a5 10 00 add r2,r5,r5
8006ca0: b4 42 10 00 add r2,r2,r2
8006ca4: b4 22 10 00 add r2,r1,r2
8006ca8: 28 42 00 04 lw r2,(r2+4)
g->color = RBT_RED;
8006cac: 58 26 00 0c sw (r1+12),r6
8006cb0: 44 40 ff c1 be r2,r0,8006bb4 <_RBTree_Insert_unprotected+0xcc><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006cb4: 44 a0 00 37 be r5,r0,8006d90 <_RBTree_Insert_unprotected+0x2a8>
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
8006cb8: 28 22 00 08 lw r2,(r1+8)
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006cbc: 34 03 00 01 mvi r3,1
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
8006cc0: b4 84 20 00 add r4,r4,r4
8006cc4: b4 84 28 00 add r5,r4,r4
8006cc8: b4 45 28 00 add r5,r2,r5
8006ccc: b4 63 18 00 add r3,r3,r3
8006cd0: 28 a7 00 04 lw r7,(r5+4)
8006cd4: b4 63 18 00 add r3,r3,r3
8006cd8: b4 23 18 00 add r3,r1,r3
8006cdc: 58 67 00 04 sw (r3+4),r7
if (c->child[dir])
8006ce0: 28 a3 00 04 lw r3,(r5+4)
8006ce4: 44 60 00 02 be r3,r0,8006cec <_RBTree_Insert_unprotected+0x204>
c->child[dir]->parent = the_node;
8006ce8: 58 61 00 00 sw (r3+0),r1
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
8006cec: 28 25 00 00 lw r5,(r1+0)
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
8006cf0: b4 84 20 00 add r4,r4,r4
8006cf4: b4 44 20 00 add r4,r2,r4
8006cf8: 58 81 00 04 sw (r4+4),r1
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
8006cfc: 28 a3 00 04 lw r3,(r5+4)
c->parent = the_node->parent;
8006d00: 58 45 00 00 sw (r2+0),r5
the_node->parent = c;
8006d04: 58 22 00 00 sw (r1+0),r2
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
8006d08: fc 23 08 00 cmpne r1,r1,r3
c->parent = the_node->parent;
the_node->parent = c;
8006d0c: 29 63 00 00 lw r3,(r11+0)
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
8006d10: b4 21 08 00 add r1,r1,r1
8006d14: b4 21 08 00 add r1,r1,r1
8006d18: b4 a1 08 00 add r1,r5,r1
8006d1c: 58 22 00 04 sw (r1+4),r2
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
8006d20: 28 62 00 00 lw r2,(r3+0)
8006d24: b8 40 08 00 mv r1,r2
8006d28: 5c 40 ff a6 bne r2,r0,8006bc0 <_RBTree_Insert_unprotected+0xd8><== ALWAYS TAKEN
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
8006d2c: 59 60 00 0c sw (r11+12),r0
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
8006d30: b9 a0 08 00 mv r1,r13
8006d34: 2b 9d 00 04 lw ra,(sp+4)
8006d38: 2b 8b 00 1c lw r11,(sp+28)
8006d3c: 2b 8c 00 18 lw r12,(sp+24)
8006d40: 2b 8d 00 14 lw r13,(sp+20)
8006d44: 2b 8e 00 10 lw r14,(sp+16)
8006d48: 2b 8f 00 0c lw r15,(sp+12)
8006d4c: 2b 90 00 08 lw r16,(sp+8)
8006d50: 37 9c 00 1c addi sp,sp,28
8006d54: c3 a0 00 00 ret
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
8006d58: 28 45 00 08 lw r5,(r2+8)
8006d5c: e3 ff ff a0 bi 8006bdc <_RBTree_Insert_unprotected+0xf4>
compare_result = the_rbtree->compare_function(
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
(dir && _RBTree_Is_greater(compare_result)) ) {
8006d60: 4c 01 ff 93 bge r0,r1,8006bac <_RBTree_Insert_unprotected+0xc4>
the_rbtree->first[dir] = the_node;
8006d64: b6 10 80 00 add r16,r16,r16
8006d68: b6 10 80 00 add r16,r16,r16
8006d6c: b5 90 60 00 add r12,r12,r16
8006d70: 59 8b 00 00 sw (r12+0),r11
8006d74: e3 ff ff 8e bi 8006bac <_RBTree_Insert_unprotected+0xc4>
u = _RBTree_Parent_sibling(the_node);
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
8006d78: 58 60 00 0c sw (r3+12),r0
u->color = RBT_BLACK;
8006d7c: 58 a0 00 0c sw (r5+12),r0
g->color = RBT_RED;
8006d80: 58 46 00 0c sw (r2+12),r6
8006d84: b8 e0 18 00 mv r3,r7
8006d88: b8 40 58 00 mv r11,r2
8006d8c: e3 ff ff 8a bi 8006bb4 <_RBTree_Insert_unprotected+0xcc>
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
8006d90: 28 22 00 04 lw r2,(r1+4)
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8006d94: 34 03 00 00 mvi r3,0
8006d98: e3 ff ff ca bi 8006cc0 <_RBTree_Insert_unprotected+0x1d8>
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
8006d9c: 28 44 00 04 lw r4,(r2+4) <== NOT EXECUTED
8006da0: e3 ff ff 92 bi 8006be8 <_RBTree_Insert_unprotected+0x100> <== NOT EXECUTED
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
8006da4: b9 e0 68 00 mv r13,r15
8006da8: e3 ff ff e2 bi 8006d30 <_RBTree_Insert_unprotected+0x248>
RBTree_Node *iter_node = the_rbtree->root;
int compare_result;
if (!iter_node) { /* special case: first node inserted */
the_node->color = RBT_BLACK;
8006dac: 58 40 00 0c sw (r2+12),r0
the_rbtree->root = the_node;
8006db0: 59 82 00 04 sw (r12+4),r2
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
8006db4: 59 82 00 0c sw (r12+12),r2
8006db8: 59 82 00 08 sw (r12+8),r2
the_node->parent = (RBTree_Node *) the_rbtree;
8006dbc: 59 61 00 00 sw (r11+0),r1
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
8006dc0: 58 40 00 08 sw (r2+8),r0
8006dc4: 58 40 00 04 sw (r2+4),r0
} /* while(iter_node) */
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
8006dc8: 34 0d 00 00 mvi r13,0
8006dcc: e3 ff ff d9 bi 8006d30 <_RBTree_Insert_unprotected+0x248>
08006e04 <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
8006e04: 37 9c ff e8 addi sp,sp,-24
8006e08: 5b 8b 00 18 sw (sp+24),r11
8006e0c: 5b 8c 00 14 sw (sp+20),r12
8006e10: 5b 8d 00 10 sw (sp+16),r13
8006e14: 5b 8e 00 0c sw (sp+12),r14
8006e18: 5b 8f 00 08 sw (sp+8),r15
8006e1c: 5b 9d 00 04 sw (sp+4),ra
8006e20: b8 40 60 00 mv r12,r2
8006e24: 64 42 00 00 cmpei r2,r2,0
8006e28: b8 60 78 00 mv r15,r3
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
8006e2c: 34 42 00 02 addi r2,r2,2
8006e30: b4 42 10 00 add r2,r2,r2
8006e34: b4 42 10 00 add r2,r2,r2
8006e38: b4 22 08 00 add r1,r1,r2
8006e3c: 28 2b 00 00 lw r11,(r1+0)
8006e40: b8 80 70 00 mv r14,r4
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
8006e44: 5d 60 00 03 bne r11,r0,8006e50 <_RBTree_Iterate_unprotected+0x4c><== ALWAYS TAKEN
8006e48: e0 00 00 0c bi 8006e78 <_RBTree_Iterate_unprotected+0x74> <== NOT EXECUTED
8006e4c: 44 2d 00 0b be r1,r13,8006e78 <_RBTree_Iterate_unprotected+0x74>
stop = (*visitor)( current, dir, visitor_arg );
8006e50: b9 60 08 00 mv r1,r11
8006e54: b9 c0 18 00 mv r3,r14
8006e58: b9 80 10 00 mv r2,r12
8006e5c: d9 e0 00 00 call r15
8006e60: b8 20 68 00 mv r13,r1
current = _RBTree_Next_unprotected( current, dir );
8006e64: b9 80 10 00 mv r2,r12
8006e68: b9 60 08 00 mv r1,r11
8006e6c: f8 00 00 0b calli 8006e98 <_RBTree_Next_unprotected>
8006e70: b8 20 58 00 mv r11,r1
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
8006e74: 45 a0 ff f6 be r13,r0,8006e4c <_RBTree_Iterate_unprotected+0x48><== ALWAYS TAKEN
stop = (*visitor)( current, dir, visitor_arg );
current = _RBTree_Next_unprotected( current, dir );
}
}
8006e78: 2b 9d 00 04 lw ra,(sp+4)
8006e7c: 2b 8b 00 18 lw r11,(sp+24)
8006e80: 2b 8c 00 14 lw r12,(sp+20)
8006e84: 2b 8d 00 10 lw r13,(sp+16)
8006e88: 2b 8e 00 0c lw r14,(sp+12)
8006e8c: 2b 8f 00 08 lw r15,(sp+8)
8006e90: 37 9c 00 18 addi sp,sp,24
8006e94: c3 a0 00 00 ret
08004e40 <_RTEMS_signal_Post_switch_hook>:
#include <rtems/score/thread.h>
#include <rtems/score/apiext.h>
#include <rtems/rtems/tasks.h>
static void _RTEMS_signal_Post_switch_hook( Thread_Control *executing )
{
8004e40: 37 9c ff f0 addi sp,sp,-16
8004e44: 5b 8b 00 0c sw (sp+12),r11
8004e48: 5b 8c 00 08 sw (sp+8),r12
8004e4c: 5b 9d 00 04 sw (sp+4),ra
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
8004e50: 28 2b 01 18 lw r11,(r1+280)
if ( !api )
8004e54: 45 60 00 1a be r11,r0,8004ebc <_RTEMS_signal_Post_switch_hook+0x7c><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
8004e58: 90 00 10 00 rcsr r2,IE
8004e5c: 34 01 ff fe mvi r1,-2
8004e60: a0 41 08 00 and r1,r2,r1
8004e64: d0 01 00 00 wcsr IE,r1
signal_set = asr->signals_posted;
8004e68: 29 6c 00 14 lw r12,(r11+20)
asr->signals_posted = 0;
8004e6c: 59 60 00 14 sw (r11+20),r0
_ISR_Enable( level );
8004e70: d0 02 00 00 wcsr IE,r2
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
8004e74: 45 80 00 12 be r12,r0,8004ebc <_RTEMS_signal_Post_switch_hook+0x7c>
return;
asr->nest_level += 1;
8004e78: 29 64 00 1c lw r4,(r11+28)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
8004e7c: 29 61 00 10 lw r1,(r11+16)
8004e80: 37 83 00 10 addi r3,sp,16
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
8004e84: 34 84 00 01 addi r4,r4,1
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
8004e88: 38 02 ff ff mvu r2,0xffff
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
8004e8c: 59 64 00 1c sw (r11+28),r4
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
8004e90: f8 00 01 3d calli 8005384 <rtems_task_mode>
(*asr->handler)( signal_set );
8004e94: 29 62 00 0c lw r2,(r11+12)
8004e98: b9 80 08 00 mv r1,r12
8004e9c: d8 40 00 00 call r2
asr->nest_level -= 1;
8004ea0: 29 63 00 1c lw r3,(r11+28)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
8004ea4: 2b 81 00 10 lw r1,(sp+16)
8004ea8: 38 02 ff ff mvu r2,0xffff
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
(*asr->handler)( signal_set );
asr->nest_level -= 1;
8004eac: 34 63 ff ff addi r3,r3,-1
8004eb0: 59 63 00 1c sw (r11+28),r3
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
8004eb4: 37 83 00 10 addi r3,sp,16
8004eb8: f8 00 01 33 calli 8005384 <rtems_task_mode>
}
8004ebc: 2b 9d 00 04 lw ra,(sp+4)
8004ec0: 2b 8b 00 0c lw r11,(sp+12)
8004ec4: 2b 8c 00 08 lw r12,(sp+8)
8004ec8: 37 9c 00 10 addi sp,sp,16
8004ecc: c3 a0 00 00 ret
08004184 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
8004184: 37 9c ff e8 addi sp,sp,-24
8004188: 5b 8b 00 14 sw (sp+20),r11
800418c: 5b 8c 00 10 sw (sp+16),r12
8004190: 5b 8d 00 0c sw (sp+12),r13
8004194: 5b 8e 00 08 sw (sp+8),r14
8004198: 5b 9d 00 04 sw (sp+4),ra
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
800419c: 78 01 08 02 mvhi r1,0x802
80041a0: 38 21 00 a4 ori r1,r1,0xa4
80041a4: 28 2b 00 2c lw r11,(r1+44)
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
80041a8: 28 2e 00 28 lw r14,(r1+40)
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
80041ac: 45 60 00 15 be r11,r0,8004200 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
80041b0: 45 c0 00 14 be r14,r0,8004200 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c><== NEVER TAKEN
80041b4: 34 0c 00 00 mvi r12,0
return_value = rtems_task_create(
80041b8: 29 61 00 00 lw r1,(r11+0)
80041bc: 29 62 00 08 lw r2,(r11+8)
80041c0: 29 63 00 04 lw r3,(r11+4)
80041c4: 29 64 00 14 lw r4,(r11+20)
80041c8: 29 65 00 0c lw r5,(r11+12)
80041cc: 37 86 00 18 addi r6,sp,24
80041d0: fb ff ff 52 calli 8003f18 <rtems_task_create>
80041d4: b8 20 68 00 mv r13,r1
user_tasks[ index ].stack_size,
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
80041d8: 5c 20 00 11 bne r1,r0,800421c <_RTEMS_tasks_Initialize_user_tasks_body+0x98>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
80041dc: 29 63 00 18 lw r3,(r11+24)
80041e0: 2b 81 00 18 lw r1,(sp+24)
80041e4: 29 62 00 10 lw r2,(r11+16)
80041e8: f8 00 00 14 calli 8004238 <rtems_task_start>
80041ec: b8 20 18 00 mv r3,r1
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
80041f0: 5c 2d 00 0f bne r1,r13,800422c <_RTEMS_tasks_Initialize_user_tasks_body+0xa8>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
80041f4: 35 8c 00 01 addi r12,r12,1
80041f8: 35 6b 00 1c addi r11,r11,28
80041fc: 55 cc ff ef bgu r14,r12,80041b8 <_RTEMS_tasks_Initialize_user_tasks_body+0x34><== NEVER TAKEN
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
}
}
8004200: 2b 9d 00 04 lw ra,(sp+4)
8004204: 2b 8b 00 14 lw r11,(sp+20)
8004208: 2b 8c 00 10 lw r12,(sp+16)
800420c: 2b 8d 00 0c lw r13,(sp+12)
8004210: 2b 8e 00 08 lw r14,(sp+8)
8004214: 37 9c 00 18 addi sp,sp,24
8004218: c3 a0 00 00 ret
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
800421c: 34 01 00 01 mvi r1,1
8004220: 34 02 00 01 mvi r2,1
8004224: b9 a0 18 00 mv r3,r13
8004228: f8 00 04 9d calli 800549c <_Internal_error_Occurred>
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
800422c: 34 01 00 01 mvi r1,1
8004230: 34 02 00 01 mvi r2,1
8004234: f8 00 04 9a calli 800549c <_Internal_error_Occurred>
0800a6e8 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
800a6e8: 28 21 01 24 lw r1,(r1+292)
while (tvp) {
800a6ec: 44 20 00 08 be r1,r0,800a70c <_RTEMS_tasks_Switch_extension+0x24>
tvp->tval = *tvp->ptr;
800a6f0: 28 23 00 04 lw r3,(r1+4)
*tvp->ptr = tvp->gval;
800a6f4: 28 24 00 08 lw r4,(r1+8)
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
800a6f8: 28 65 00 00 lw r5,(r3+0)
800a6fc: 58 25 00 0c sw (r1+12),r5
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
800a700: 28 21 00 00 lw r1,(r1+0)
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
800a704: 58 64 00 00 sw (r3+0),r4
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
800a708: 5c 20 ff fa bne r1,r0,800a6f0 <_RTEMS_tasks_Switch_extension+0x8><== NEVER TAKEN
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
800a70c: 28 41 01 24 lw r1,(r2+292)
while (tvp) {
800a710: 44 20 00 08 be r1,r0,800a730 <_RTEMS_tasks_Switch_extension+0x48>
tvp->gval = *tvp->ptr;
800a714: 28 22 00 04 lw r2,(r1+4)
*tvp->ptr = tvp->tval;
800a718: 28 23 00 0c lw r3,(r1+12)
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
800a71c: 28 44 00 00 lw r4,(r2+0)
800a720: 58 24 00 08 sw (r1+8),r4
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
800a724: 28 21 00 00 lw r1,(r1+0)
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
800a728: 58 43 00 00 sw (r2+0),r3
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
800a72c: 5c 20 ff fa bne r1,r0,800a714 <_RTEMS_tasks_Switch_extension+0x2c><== NEVER TAKEN
800a730: c3 a0 00 00 ret
080386d8 <_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
)
{
80386d8: 37 9c ff e4 addi sp,sp,-28
80386dc: 5b 8b 00 14 sw (sp+20),r11
80386e0: 5b 8c 00 10 sw (sp+16),r12
80386e4: 5b 8d 00 0c sw (sp+12),r13
80386e8: 5b 8e 00 08 sw (sp+8),r14
80386ec: 5b 9d 00 04 sw (sp+4),ra
80386f0: b8 40 68 00 mv r13,r2
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
80386f4: 78 02 08 06 mvhi r2,0x806
80386f8: b8 20 58 00 mv r11,r1
80386fc: 38 42 ef e8 ori r2,r2,0xefe8
8038700: 37 81 00 18 addi r1,sp,24
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
8038704: 29 6c 00 40 lw r12,(r11+64)
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
)
{
8038708: b8 60 70 00 mv r14,r3
803870c: fb ff 2f 8e calli 8004544 <_TOD_Get_with_nanoseconds>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8038710: 2b 85 00 1c lw r5,(sp+28)
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
8038714: 29 61 00 54 lw r1,(r11+84)
8038718: 29 66 00 50 lw r6,(r11+80)
803871c: 2b 82 00 18 lw r2,(sp+24)
8038720: c8 a1 08 00 sub r1,r5,r1
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
8038724: 78 04 08 06 mvhi r4,0x806
8038728: f4 25 38 00 cmpgu r7,r1,r5
803872c: 38 84 f5 00 ori r4,r4,0xf500
8038730: 28 88 00 10 lw r8,(r4+16)
8038734: c8 46 30 00 sub r6,r2,r6
8038738: c8 c7 30 00 sub r6,r6,r7
803873c: 59 a1 00 04 sw (r13+4),r1
8038740: 59 a6 00 00 sw (r13+0),r6
#endif
/*
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
8038744: 29 83 00 80 lw r3,(r12+128)
8038748: 29 86 00 84 lw r6,(r12+132)
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
803874c: 34 01 00 01 mvi r1,1
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
8038750: 45 0c 00 08 be r8,r12,8038770 <_Rate_monotonic_Get_status+0x98>
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
8038754: 2b 9d 00 04 lw ra,(sp+4)
8038758: 2b 8b 00 14 lw r11,(sp+20)
803875c: 2b 8c 00 10 lw r12,(sp+16)
8038760: 2b 8d 00 0c lw r13,(sp+12)
8038764: 2b 8e 00 08 lw r14,(sp+8)
8038768: 37 9c 00 1c addi sp,sp,28
803876c: c3 a0 00 00 ret
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
8038770: 28 81 00 24 lw r1,(r4+36)
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
8038774: b4 c5 28 00 add r5,r6,r5
8038778: f4 c5 30 00 cmpgu r6,r6,r5
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
803877c: 28 87 00 20 lw r7,(r4+32)
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
8038780: b4 62 10 00 add r2,r3,r2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
8038784: c8 a1 08 00 sub r1,r5,r1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
8038788: b4 c2 10 00 add r2,r6,r2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
803878c: f4 25 28 00 cmpgu r5,r1,r5
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8038790: 29 64 00 48 lw r4,(r11+72)
8038794: c8 47 10 00 sub r2,r2,r7
8038798: c8 45 28 00 sub r5,r2,r5
803879c: 29 62 00 4c lw r2,(r11+76)
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
80387a0: 48 85 00 10 bg r4,r5,80387e0 <_Rate_monotonic_Get_status+0x108><== NEVER TAKEN
80387a4: 44 85 00 11 be r4,r5,80387e8 <_Rate_monotonic_Get_status+0x110>
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
80387a8: c8 22 10 00 sub r2,r1,r2
80387ac: f4 41 08 00 cmpgu r1,r2,r1
80387b0: c8 a4 20 00 sub r4,r5,r4
80387b4: c8 81 08 00 sub r1,r4,r1
80387b8: 59 c1 00 00 sw (r14+0),r1
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
80387bc: 34 01 00 01 mvi r1,1
80387c0: 59 c2 00 04 sw (r14+4),r2
}
80387c4: 2b 9d 00 04 lw ra,(sp+4)
80387c8: 2b 8b 00 14 lw r11,(sp+20)
80387cc: 2b 8c 00 10 lw r12,(sp+16)
80387d0: 2b 8d 00 0c lw r13,(sp+12)
80387d4: 2b 8e 00 08 lw r14,(sp+8)
80387d8: 37 9c 00 1c addi sp,sp,28
80387dc: c3 a0 00 00 ret
/*
* 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;
80387e0: 34 01 00 00 mvi r1,0
80387e4: e3 ff ff dc bi 8038754 <_Rate_monotonic_Get_status+0x7c>
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
80387e8: 54 41 ff fe bgu r2,r1,80387e0 <_Rate_monotonic_Get_status+0x108>
80387ec: e3 ff ff ef bi 80387a8 <_Rate_monotonic_Get_status+0xd0>
08038bdc <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
8038bdc: 37 9c ff f4 addi sp,sp,-12
8038be0: 5b 8b 00 08 sw (sp+8),r11
8038be4: 5b 9d 00 04 sw (sp+4),ra
8038be8: b8 20 10 00 mv r2,r1
8038bec: 78 01 08 06 mvhi r1,0x806
8038bf0: 38 21 fb 30 ori r1,r1,0xfb30
8038bf4: 37 83 00 0c addi r3,sp,12
8038bf8: fb ff 31 72 calli 80051c0 <_Objects_Get>
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
8038bfc: 2b 82 00 0c lw r2,(sp+12)
8038c00: b8 20 58 00 mv r11,r1
8038c04: 44 40 00 05 be r2,r0,8038c18 <_Rate_monotonic_Timeout+0x3c><== ALWAYS TAKEN
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
8038c08: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8038c0c: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
8038c10: 37 9c 00 0c addi sp,sp,12 <== NOT EXECUTED
8038c14: c3 a0 00 00 ret <== NOT EXECUTED
*/
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_thread = the_period->owner;
8038c18: 28 21 00 40 lw r1,(r1+64)
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_PERIOD);
8038c1c: 28 23 00 10 lw r3,(r1+16)
8038c20: 20 63 40 00 andi r3,r3,0x4000
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
8038c24: 44 62 00 04 be r3,r2,8038c34 <_Rate_monotonic_Timeout+0x58>
8038c28: 28 23 00 20 lw r3,(r1+32)
8038c2c: 29 62 00 08 lw r2,(r11+8)
8038c30: 44 62 00 1a be r3,r2,8038c98 <_Rate_monotonic_Timeout+0xbc>
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
8038c34: 29 62 00 38 lw r2,(r11+56)
8038c38: 34 01 00 01 mvi r1,1
8038c3c: 44 41 00 0c be r2,r1,8038c6c <_Rate_monotonic_Timeout+0x90><== NEVER TAKEN
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
8038c40: 34 01 00 04 mvi r1,4
8038c44: 59 61 00 38 sw (r11+56),r1
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8038c48: 78 01 08 06 mvhi r1,0x806
8038c4c: 38 21 f0 60 ori r1,r1,0xf060
8038c50: 28 22 00 00 lw r2,(r1+0)
--level;
8038c54: 34 42 ff ff addi r2,r2,-1
_Thread_Dispatch_disable_level = level;
8038c58: 58 22 00 00 sw (r1+0),r2
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
8038c5c: 2b 9d 00 04 lw ra,(sp+4)
8038c60: 2b 8b 00 08 lw r11,(sp+8)
8038c64: 37 9c 00 0c addi sp,sp,12
8038c68: c3 a0 00 00 ret
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
8038c6c: 34 02 00 03 mvi r2,3 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
8038c70: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
8038c74: 59 62 00 38 sw (r11+56),r2 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
8038c78: fb ff ff 2b calli 8038924 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
8038c7c: 29 62 00 3c lw r2,(r11+60)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8038c80: 78 01 08 06 mvhi r1,0x806
8038c84: 38 21 f0 f8 ori r1,r1,0xf0f8
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
8038c88: 59 62 00 1c sw (r11+28),r2
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8038c8c: 35 62 00 10 addi r2,r11,16
8038c90: fb ff 38 cb calli 8006fbc <_Watchdog_Insert>
8038c94: e3 ff ff ed bi 8038c48 <_Rate_monotonic_Timeout+0x6c>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
8038c98: 78 03 08 05 mvhi r3,0x805
8038c9c: 38 63 e2 9c ori r3,r3,0xe29c
8038ca0: 28 62 00 00 lw r2,(r3+0)
8038ca4: fb ff 54 21 calli 800dd28 <_Thread_Clear_state>
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
8038ca8: b9 60 08 00 mv r1,r11
8038cac: e3 ff ff f3 bi 8038c78 <_Rate_monotonic_Timeout+0x9c>
080387f0 <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
80387f0: 37 9c ff e8 addi sp,sp,-24
80387f4: 5b 8b 00 08 sw (sp+8),r11
80387f8: 5b 9d 00 04 sw (sp+4),ra
80387fc: b8 20 58 00 mv r11,r1
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
8038800: 28 21 00 58 lw r1,(r1+88)
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
8038804: 29 62 00 38 lw r2,(r11+56)
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
8038808: 34 21 00 01 addi r1,r1,1
803880c: 59 61 00 58 sw (r11+88),r1
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
8038810: 34 01 00 04 mvi r1,4
8038814: 44 41 00 3a be r2,r1,80388fc <_Rate_monotonic_Update_statistics+0x10c>
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
8038818: b9 60 08 00 mv r1,r11
803881c: 37 82 00 0c addi r2,sp,12
8038820: 37 83 00 14 addi r3,sp,20
8038824: fb ff ff ad calli 80386d8 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
8038828: 44 20 00 13 be r1,r0,8038874 <_Rate_monotonic_Update_statistics+0x84><== NEVER TAKEN
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
803882c: 2b 82 00 18 lw r2,(sp+24)
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
8038830: 29 63 00 74 lw r3,(r11+116)
8038834: 29 65 00 70 lw r5,(r11+112)
8038838: 2b 81 00 14 lw r1,(sp+20)
803883c: b4 43 18 00 add r3,r2,r3
8038840: f4 43 30 00 cmpgu r6,r2,r3
8038844: b4 25 28 00 add r5,r1,r5
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
8038848: 29 64 00 60 lw r4,(r11+96)
803884c: b4 c5 28 00 add r5,r6,r5
8038850: 59 65 00 70 sw (r11+112),r5
8038854: 59 63 00 74 sw (r11+116),r3
8038858: 48 81 00 0b bg r4,r1,8038884 <_Rate_monotonic_Update_statistics+0x94>
803885c: 5c 81 00 0c bne r4,r1,803888c <_Rate_monotonic_Update_statistics+0x9c><== NEVER TAKEN
8038860: 29 63 00 64 lw r3,(r11+100)
8038864: 54 62 00 08 bgu r3,r2,8038884 <_Rate_monotonic_Update_statistics+0x94>
8038868: e0 00 00 09 bi 803888c <_Rate_monotonic_Update_statistics+0x9c>
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
stats->max_wall_time = since_last_period;
803886c: 59 61 00 80 sw (r11+128),r1
8038870: 59 62 00 84 sw (r11+132),r2
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
8038874: 2b 9d 00 04 lw ra,(sp+4)
8038878: 2b 8b 00 08 lw r11,(sp+8)
803887c: 37 9c 00 18 addi sp,sp,24
8038880: c3 a0 00 00 ret
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
stats->min_cpu_time = executed;
8038884: 59 61 00 60 sw (r11+96),r1
8038888: 59 62 00 64 sw (r11+100),r2
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
803888c: 29 63 00 68 lw r3,(r11+104)
8038890: 48 23 00 18 bg r1,r3,80388f0 <_Rate_monotonic_Update_statistics+0x100><== NEVER TAKEN
8038894: 44 61 00 21 be r3,r1,8038918 <_Rate_monotonic_Update_statistics+0x128><== ALWAYS TAKEN
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8038898: 2b 82 00 10 lw r2,(sp+16)
803889c: 29 63 00 8c lw r3,(r11+140)
80388a0: 29 65 00 88 lw r5,(r11+136)
80388a4: 2b 81 00 0c lw r1,(sp+12)
80388a8: b4 43 18 00 add r3,r2,r3
80388ac: f4 43 30 00 cmpgu r6,r2,r3
80388b0: b4 25 28 00 add r5,r1,r5
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
80388b4: 29 64 00 78 lw r4,(r11+120)
80388b8: b4 c5 28 00 add r5,r6,r5
80388bc: 59 65 00 88 sw (r11+136),r5
80388c0: 59 63 00 8c sw (r11+140),r3
80388c4: 48 81 00 08 bg r4,r1,80388e4 <_Rate_monotonic_Update_statistics+0xf4>
80388c8: 44 81 00 11 be r4,r1,803890c <_Rate_monotonic_Update_statistics+0x11c><== ALWAYS TAKEN
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
80388cc: 29 63 00 80 lw r3,(r11+128)
80388d0: 48 23 ff e7 bg r1,r3,803886c <_Rate_monotonic_Update_statistics+0x7c><== NEVER TAKEN
80388d4: 5c 61 ff e8 bne r3,r1,8038874 <_Rate_monotonic_Update_statistics+0x84><== NEVER TAKEN
80388d8: 29 63 00 84 lw r3,(r11+132)
80388dc: 54 43 ff e4 bgu r2,r3,803886c <_Rate_monotonic_Update_statistics+0x7c>
80388e0: e3 ff ff e5 bi 8038874 <_Rate_monotonic_Update_statistics+0x84>
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
stats->min_wall_time = since_last_period;
80388e4: 59 61 00 78 sw (r11+120),r1
80388e8: 59 62 00 7c sw (r11+124),r2
80388ec: e3 ff ff f8 bi 80388cc <_Rate_monotonic_Update_statistics+0xdc>
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
stats->min_cpu_time = executed;
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
stats->max_cpu_time = executed;
80388f0: 59 61 00 68 sw (r11+104),r1
80388f4: 59 62 00 6c sw (r11+108),r2
80388f8: e3 ff ff e8 bi 8038898 <_Rate_monotonic_Update_statistics+0xa8>
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
80388fc: 29 61 00 5c lw r1,(r11+92)
8038900: 34 21 00 01 addi r1,r1,1
8038904: 59 61 00 5c sw (r11+92),r1
8038908: e3 ff ff c4 bi 8038818 <_Rate_monotonic_Update_statistics+0x28>
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
803890c: 29 63 00 7c lw r3,(r11+124)
8038910: 54 62 ff f5 bgu r3,r2,80388e4 <_Rate_monotonic_Update_statistics+0xf4>
8038914: e3 ff ff ee bi 80388cc <_Rate_monotonic_Update_statistics+0xdc>
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
stats->min_cpu_time = executed;
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
8038918: 29 63 00 6c lw r3,(r11+108)
803891c: 54 43 ff f5 bgu r2,r3,80388f0 <_Rate_monotonic_Update_statistics+0x100>
8038920: e3 ff ff de bi 8038898 <_Rate_monotonic_Update_statistics+0xa8>
08006f1c <_Scheduler_CBS_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_CBS_Allocate(
Thread_Control *the_thread
)
{
8006f1c: 37 9c ff f8 addi sp,sp,-8
8006f20: 5b 8b 00 08 sw (sp+8),r11
8006f24: 5b 9d 00 04 sw (sp+4),ra
8006f28: b8 20 58 00 mv r11,r1
void *sched;
Scheduler_CBS_Per_thread *schinfo;
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
8006f2c: 34 01 00 1c mvi r1,28
8006f30: f8 00 08 07 calli 8008f4c <_Workspace_Allocate>
if ( sched ) {
8006f34: 44 20 00 06 be r1,r0,8006f4c <_Scheduler_CBS_Allocate+0x30><== NEVER TAKEN
the_thread->scheduler_info = sched;
8006f38: 59 61 00 88 sw (r11+136),r1
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
8006f3c: 34 02 00 02 mvi r2,2
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
if ( sched ) {
the_thread->scheduler_info = sched;
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
8006f40: 58 2b 00 00 sw (r1+0),r11
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
8006f44: 58 22 00 14 sw (r1+20),r2
schinfo->cbs_server = NULL;
8006f48: 58 20 00 18 sw (r1+24),r0
}
return sched;
}
8006f4c: 2b 9d 00 04 lw ra,(sp+4)
8006f50: 2b 8b 00 08 lw r11,(sp+8)
8006f54: 37 9c 00 08 addi sp,sp,8
8006f58: c3 a0 00 00 ret
08008280 <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
8008280: 37 9c ff f4 addi sp,sp,-12
8008284: 5b 8b 00 08 sw (sp+8),r11
8008288: 5b 9d 00 04 sw (sp+4),ra
800828c: b8 20 58 00 mv r11,r1
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server_id server_id;
/* Put violating task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
8008290: 28 22 00 ac lw r2,(r1+172)
if ( the_thread->real_priority != new_priority )
8008294: 28 21 00 18 lw r1,(r1+24)
8008298: 44 22 00 02 be r1,r2,80082a0 <_Scheduler_CBS_Budget_callout+0x20><== NEVER TAKEN
the_thread->real_priority = new_priority;
800829c: 59 62 00 18 sw (r11+24),r2
if ( the_thread->current_priority != new_priority )
80082a0: 29 61 00 14 lw r1,(r11+20)
80082a4: 44 22 00 04 be r1,r2,80082b4 <_Scheduler_CBS_Budget_callout+0x34><== NEVER TAKEN
_Thread_Change_priority(the_thread, new_priority, true);
80082a8: b9 60 08 00 mv r1,r11
80082ac: 34 03 00 01 mvi r3,1
80082b0: f8 00 01 a6 calli 8008948 <_Thread_Change_priority>
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
80082b4: 29 6b 00 88 lw r11,(r11+136)
if ( sched_info->cbs_server->cbs_budget_overrun ) {
80082b8: 29 61 00 18 lw r1,(r11+24)
80082bc: 28 22 00 0c lw r2,(r1+12)
80082c0: 44 40 00 08 be r2,r0,80082e0 <_Scheduler_CBS_Budget_callout+0x60><== NEVER TAKEN
_Scheduler_CBS_Get_server_id(
80082c4: 28 21 00 00 lw r1,(r1+0)
80082c8: 37 82 00 0c addi r2,sp,12
80082cc: fb ff ff d6 calli 8008224 <_Scheduler_CBS_Get_server_id>
sched_info->cbs_server->task_id,
&server_id
);
sched_info->cbs_server->cbs_budget_overrun( server_id );
80082d0: 29 62 00 18 lw r2,(r11+24)
80082d4: 2b 81 00 0c lw r1,(sp+12)
80082d8: 28 42 00 0c lw r2,(r2+12)
80082dc: d8 40 00 00 call r2
}
}
80082e0: 2b 9d 00 04 lw ra,(sp+4)
80082e4: 2b 8b 00 08 lw r11,(sp+8)
80082e8: 37 9c 00 0c addi sp,sp,12
80082ec: c3 a0 00 00 ret
08007cec <_Scheduler_CBS_Cleanup>:
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Cleanup (void)
{
8007cec: 37 9c ff ec addi sp,sp,-20
8007cf0: 5b 8b 00 14 sw (sp+20),r11
8007cf4: 5b 8c 00 10 sw (sp+16),r12
8007cf8: 5b 8d 00 0c sw (sp+12),r13
8007cfc: 5b 8e 00 08 sw (sp+8),r14
8007d00: 5b 9d 00 04 sw (sp+4),ra
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
8007d04: 78 0d 08 02 mvhi r13,0x802
8007d08: 39 ad 30 18 ori r13,r13,0x3018
8007d0c: 29 a1 00 00 lw r1,(r13+0)
8007d10: 44 20 00 1a be r1,r0,8007d78 <_Scheduler_CBS_Cleanup+0x8c> <== NEVER TAKEN
8007d14: 78 0e 08 02 mvhi r14,0x802
8007d18: 39 ce 3e e8 ori r14,r14,0x3ee8
8007d1c: 29 c2 00 00 lw r2,(r14+0)
8007d20: 34 0c 00 00 mvi r12,0
8007d24: 34 0b 00 00 mvi r11,0
if ( _Scheduler_CBS_Server_list[ i ] )
8007d28: b4 4c 08 00 add r1,r2,r12
8007d2c: 28 23 00 00 lw r3,(r1+0)
_Scheduler_CBS_Destroy_server( i );
8007d30: b9 60 08 00 mv r1,r11
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
8007d34: 35 6b 00 01 addi r11,r11,1
if ( _Scheduler_CBS_Server_list[ i ] )
8007d38: 44 60 00 03 be r3,r0,8007d44 <_Scheduler_CBS_Cleanup+0x58>
_Scheduler_CBS_Destroy_server( i );
8007d3c: f8 00 00 57 calli 8007e98 <_Scheduler_CBS_Destroy_server>
8007d40: 29 c2 00 00 lw r2,(r14+0)
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
8007d44: 29 a1 00 00 lw r1,(r13+0)
8007d48: 35 8c 00 04 addi r12,r12,4
8007d4c: 54 2b ff f7 bgu r1,r11,8007d28 <_Scheduler_CBS_Cleanup+0x3c>
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
8007d50: b8 40 08 00 mv r1,r2
8007d54: f8 00 09 7f calli 800a350 <_Workspace_Free>
return SCHEDULER_CBS_OK;
}
8007d58: 34 01 00 00 mvi r1,0
8007d5c: 2b 9d 00 04 lw ra,(sp+4)
8007d60: 2b 8b 00 14 lw r11,(sp+20)
8007d64: 2b 8c 00 10 lw r12,(sp+16)
8007d68: 2b 8d 00 0c lw r13,(sp+12)
8007d6c: 2b 8e 00 08 lw r14,(sp+8)
8007d70: 37 9c 00 14 addi sp,sp,20
8007d74: c3 a0 00 00 ret
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
8007d78: 78 01 08 02 mvhi r1,0x802 <== NOT EXECUTED
8007d7c: 38 21 3e e8 ori r1,r1,0x3ee8 <== NOT EXECUTED
8007d80: 28 22 00 00 lw r2,(r1+0) <== NOT EXECUTED
8007d84: e3 ff ff f3 bi 8007d50 <_Scheduler_CBS_Cleanup+0x64> <== NOT EXECUTED
08007d88 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
8007d88: 37 9c ff e4 addi sp,sp,-28
8007d8c: 5b 8b 00 14 sw (sp+20),r11
8007d90: 5b 8c 00 10 sw (sp+16),r12
8007d94: 5b 8d 00 0c sw (sp+12),r13
8007d98: 5b 8e 00 08 sw (sp+8),r14
8007d9c: 5b 9d 00 04 sw (sp+4),ra
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
8007da0: 28 24 00 04 lw r4,(r1+4)
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
8007da4: b8 20 58 00 mv r11,r1
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
8007da8: 34 01 ff ee mvi r1,-18
)
{
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
8007dac: 4c 04 00 2e bge r0,r4,8007e64 <_Scheduler_CBS_Create_server+0xdc>
8007db0: 29 64 00 00 lw r4,(r11+0)
8007db4: 4c 04 00 2c bge r0,r4,8007e64 <_Scheduler_CBS_Create_server+0xdc>
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
8007db8: 78 01 08 02 mvhi r1,0x802
8007dbc: 38 21 30 18 ori r1,r1,0x3018
8007dc0: 28 24 00 00 lw r4,(r1+0)
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
8007dc4: 34 01 ff e6 mvi r1,-26
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
8007dc8: 44 80 00 27 be r4,r0,8007e64 <_Scheduler_CBS_Create_server+0xdc><== NEVER TAKEN
if ( !_Scheduler_CBS_Server_list[i] )
8007dcc: 78 0e 08 02 mvhi r14,0x802
8007dd0: 39 ce 3e e8 ori r14,r14,0x3ee8
8007dd4: 29 cd 00 00 lw r13,(r14+0)
8007dd8: 29 a1 00 00 lw r1,(r13+0)
8007ddc: 44 20 00 2d be r1,r0,8007e90 <_Scheduler_CBS_Create_server+0x108>
8007de0: b9 a0 08 00 mv r1,r13
8007de4: 34 0c 00 00 mvi r12,0
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
8007de8: 35 8c 00 01 addi r12,r12,1
8007dec: 54 8c 00 25 bgu r4,r12,8007e80 <_Scheduler_CBS_Create_server+0xf8>
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
8007df0: 34 01 ff e6 mvi r1,-26
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
8007df4: 45 84 00 1c be r12,r4,8007e64 <_Scheduler_CBS_Create_server+0xdc>
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
8007df8: 58 6c 00 00 sw (r3+0),r12
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
8007dfc: 34 01 00 10 mvi r1,16
8007e00: 5b 82 00 1c sw (sp+28),r2
8007e04: 5b 83 00 18 sw (sp+24),r3
8007e08: f8 00 09 47 calli 800a324 <_Workspace_Allocate>
the_server = _Scheduler_CBS_Server_list[*server_id];
8007e0c: 2b 83 00 18 lw r3,(sp+24)
8007e10: 29 c4 00 00 lw r4,(r14+0)
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
8007e14: b5 8c 60 00 add r12,r12,r12
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
8007e18: 28 63 00 00 lw r3,(r3+0)
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
8007e1c: b5 8c 60 00 add r12,r12,r12
8007e20: b5 ac 60 00 add r12,r13,r12
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
8007e24: b4 63 18 00 add r3,r3,r3
8007e28: b4 63 18 00 add r3,r3,r3
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
8007e2c: 59 81 00 00 sw (r12+0),r1
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
8007e30: b4 83 18 00 add r3,r4,r3
8007e34: 28 63 00 00 lw r3,(r3+0)
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
8007e38: 34 01 ff ef mvi r1,-17
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
8007e3c: 2b 82 00 1c lw r2,(sp+28)
8007e40: 44 60 00 09 be r3,r0,8007e64 <_Scheduler_CBS_Create_server+0xdc><== NEVER TAKEN
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
8007e44: 29 64 00 00 lw r4,(r11+0)
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
8007e48: 34 01 00 00 mvi r1,0
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
8007e4c: 58 64 00 04 sw (r3+4),r4
8007e50: 29 65 00 04 lw r5,(r11+4)
the_server->task_id = -1;
8007e54: 34 04 ff ff mvi r4,-1
8007e58: 58 64 00 00 sw (r3+0),r4
the_server->cbs_budget_overrun = budget_overrun_callback;
8007e5c: 58 62 00 0c sw (r3+12),r2
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
8007e60: 58 65 00 08 sw (r3+8),r5
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
}
8007e64: 2b 9d 00 04 lw ra,(sp+4)
8007e68: 2b 8b 00 14 lw r11,(sp+20)
8007e6c: 2b 8c 00 10 lw r12,(sp+16)
8007e70: 2b 8d 00 0c lw r13,(sp+12)
8007e74: 2b 8e 00 08 lw r14,(sp+8)
8007e78: 37 9c 00 1c addi sp,sp,28
8007e7c: c3 a0 00 00 ret
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( !_Scheduler_CBS_Server_list[i] )
8007e80: 28 25 00 04 lw r5,(r1+4)
8007e84: 34 21 00 04 addi r1,r1,4
8007e88: 5c a0 ff d8 bne r5,r0,8007de8 <_Scheduler_CBS_Create_server+0x60>
8007e8c: e3 ff ff d9 bi 8007df0 <_Scheduler_CBS_Create_server+0x68>
8007e90: 34 0c 00 00 mvi r12,0
8007e94: e3 ff ff d9 bi 8007df8 <_Scheduler_CBS_Create_server+0x70>
08007f38 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
8007f38: 37 9c ff ec addi sp,sp,-20
8007f3c: 5b 8b 00 10 sw (sp+16),r11
8007f40: 5b 8c 00 0c sw (sp+12),r12
8007f44: 5b 8d 00 08 sw (sp+8),r13
8007f48: 5b 9d 00 04 sw (sp+4),ra
8007f4c: b8 40 68 00 mv r13,r2
8007f50: b8 20 60 00 mv r12,r1
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
the_thread = _Thread_Get(task_id, &location);
8007f54: 37 82 00 14 addi r2,sp,20
8007f58: b9 a0 08 00 mv r1,r13
8007f5c: f8 00 04 0a calli 8008f84 <_Thread_Get>
8007f60: b8 20 58 00 mv r11,r1
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
8007f64: 44 20 00 02 be r1,r0,8007f6c <_Scheduler_CBS_Detach_thread+0x34>
_Thread_Enable_dispatch();
8007f68: f8 00 03 fb calli 8008f54 <_Thread_Enable_dispatch>
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
8007f6c: 78 03 08 02 mvhi r3,0x802
8007f70: 38 63 30 18 ori r3,r3,0x3018
8007f74: 28 61 00 00 lw r1,(r3+0)
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
8007f78: 34 03 ff ee mvi r3,-18
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
_Thread_Enable_dispatch();
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
8007f7c: 51 81 00 19 bgeu r12,r1,8007fe0 <_Scheduler_CBS_Detach_thread+0xa8>
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
8007f80: 45 60 00 18 be r11,r0,8007fe0 <_Scheduler_CBS_Detach_thread+0xa8>
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
8007f84: 78 01 08 02 mvhi r1,0x802
8007f88: 38 21 3e e8 ori r1,r1,0x3ee8
8007f8c: 28 21 00 00 lw r1,(r1+0)
8007f90: b5 8c 60 00 add r12,r12,r12
8007f94: b5 8c 60 00 add r12,r12,r12
8007f98: b4 2c 60 00 add r12,r1,r12
8007f9c: 29 81 00 00 lw r1,(r12+0)
return SCHEDULER_CBS_ERROR_NOSERVER;
8007fa0: 34 03 ff e7 mvi r3,-25
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
8007fa4: 44 20 00 0f be r1,r0,8007fe0 <_Scheduler_CBS_Detach_thread+0xa8>
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
8007fa8: 28 22 00 00 lw r2,(r1+0)
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
8007fac: 34 03 ff ee mvi r3,-18
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
8007fb0: 5c 4d 00 0c bne r2,r13,8007fe0 <_Scheduler_CBS_Detach_thread+0xa8><== NEVER TAKEN
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
8007fb4: 29 66 00 88 lw r6,(r11+136)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
8007fb8: 41 63 00 9c lbu r3,(r11+156)
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
8007fbc: 29 65 00 a0 lw r5,(r11+160)
the_thread->budget_callout = the_thread->Start.budget_callout;
8007fc0: 29 64 00 a4 lw r4,(r11+164)
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
8007fc4: 34 02 ff ff mvi r2,-1
8007fc8: 58 22 00 00 sw (r1+0),r2
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
8007fcc: 58 c0 00 18 sw (r6+24),r0
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
8007fd0: 31 63 00 70 sb (r11+112),r3
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
8007fd4: 59 65 00 78 sw (r11+120),r5
the_thread->budget_callout = the_thread->Start.budget_callout;
8007fd8: 59 64 00 7c sw (r11+124),r4
the_thread->is_preemptible = the_thread->Start.is_preemptible;
return SCHEDULER_CBS_OK;
8007fdc: 34 03 00 00 mvi r3,0
}
8007fe0: b8 60 08 00 mv r1,r3
8007fe4: 2b 9d 00 04 lw ra,(sp+4)
8007fe8: 2b 8b 00 10 lw r11,(sp+16)
8007fec: 2b 8c 00 0c lw r12,(sp+12)
8007ff0: 2b 8d 00 08 lw r13,(sp+8)
8007ff4: 37 9c 00 14 addi sp,sp,20
8007ff8: c3 a0 00 00 ret
08008224 <_Scheduler_CBS_Get_server_id>:
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
8008224: 78 03 08 02 mvhi r3,0x802
8008228: 38 63 30 18 ori r3,r3,0x3018
800822c: 28 66 00 00 lw r6,(r3+0)
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
8008230: 34 03 ff e7 mvi r3,-25
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
8008234: 44 c0 00 0d be r6,r0,8008268 <_Scheduler_CBS_Get_server_id+0x44><== NEVER TAKEN
8008238: 78 03 08 02 mvhi r3,0x802
800823c: 38 63 3e e8 ori r3,r3,0x3ee8
8008240: 28 63 00 00 lw r3,(r3+0)
8008244: 34 04 00 00 mvi r4,0
if ( _Scheduler_CBS_Server_list[i] &&
8008248: 28 65 00 00 lw r5,(r3+0)
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
800824c: 34 63 00 04 addi r3,r3,4
if ( _Scheduler_CBS_Server_list[i] &&
8008250: 44 a0 00 03 be r5,r0,800825c <_Scheduler_CBS_Get_server_id+0x38>
8008254: 28 a5 00 00 lw r5,(r5+0)
8008258: 44 a1 00 06 be r5,r1,8008270 <_Scheduler_CBS_Get_server_id+0x4c>
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
800825c: 34 84 00 01 addi r4,r4,1
8008260: 54 c4 ff fa bgu r6,r4,8008248 <_Scheduler_CBS_Get_server_id+0x24>
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
8008264: 34 03 ff e7 mvi r3,-25
}
8008268: b8 60 08 00 mv r1,r3
800826c: c3 a0 00 00 ret
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[i] &&
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
return SCHEDULER_CBS_OK;
8008270: 34 03 00 00 mvi r3,0
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[i] &&
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
8008274: 58 44 00 00 sw (r2+0),r4
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
}
8008278: b8 60 08 00 mv r1,r3
800827c: c3 a0 00 00 ret
080082f0 <_Scheduler_CBS_Initialize>:
int _Scheduler_CBS_Initialize(void)
{
80082f0: 37 9c ff f8 addi sp,sp,-8
80082f4: 5b 8b 00 08 sw (sp+8),r11
80082f8: 5b 9d 00 04 sw (sp+4),ra
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
80082fc: 78 0b 08 02 mvhi r11,0x802
8008300: 39 6b 30 18 ori r11,r11,0x3018
8008304: 29 61 00 00 lw r1,(r11+0)
8008308: b4 21 08 00 add r1,r1,r1
800830c: b4 21 08 00 add r1,r1,r1
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
8008310: f8 00 08 05 calli 800a324 <_Workspace_Allocate>
8008314: 78 02 08 02 mvhi r2,0x802
8008318: 38 42 3e e8 ori r2,r2,0x3ee8
800831c: 58 41 00 00 sw (r2+0),r1
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
8008320: 34 02 ff ef mvi r2,-17
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
8008324: 44 20 00 09 be r1,r0,8008348 <_Scheduler_CBS_Initialize+0x58><== NEVER TAKEN
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
8008328: 29 63 00 00 lw r3,(r11+0)
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
800832c: 34 02 00 00 mvi r2,0
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
8008330: 44 60 00 06 be r3,r0,8008348 <_Scheduler_CBS_Initialize+0x58><== NEVER TAKEN
_Scheduler_CBS_Server_list[i] = NULL;
8008334: 58 20 00 00 sw (r1+0),r0
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
8008338: 34 42 00 01 addi r2,r2,1
800833c: 34 21 00 04 addi r1,r1,4
8008340: 54 62 ff fd bgu r3,r2,8008334 <_Scheduler_CBS_Initialize+0x44>
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
8008344: 34 02 00 00 mvi r2,0
}
8008348: b8 40 08 00 mv r1,r2
800834c: 2b 9d 00 04 lw ra,(sp+4)
8008350: 2b 8b 00 08 lw r11,(sp+8)
8008354: 37 9c 00 08 addi sp,sp,8
8008358: c3 a0 00 00 ret
08006f5c <_Scheduler_CBS_Release_job>:
void _Scheduler_CBS_Release_job(
Thread_Control *the_thread,
uint32_t deadline
)
{
8006f5c: 37 9c ff fc addi sp,sp,-4
8006f60: 5b 9d 00 04 sw (sp+4),ra
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info =
(Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
Scheduler_CBS_Server *serv_info =
(Scheduler_CBS_Server *) sched_info->cbs_server;
8006f64: 28 23 00 88 lw r3,(r1+136)
void _Scheduler_CBS_Release_job(
Thread_Control *the_thread,
uint32_t deadline
)
{
8006f68: b8 40 20 00 mv r4,r2
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info =
(Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
Scheduler_CBS_Server *serv_info =
8006f6c: 28 63 00 18 lw r3,(r3+24)
(Scheduler_CBS_Server *) sched_info->cbs_server;
if (deadline) {
8006f70: 44 40 00 13 be r2,r0,8006fbc <_Scheduler_CBS_Release_job+0x60>
/* Initializing or shifting deadline. */
if (serv_info)
8006f74: 44 60 00 15 be r3,r0,8006fc8 <_Scheduler_CBS_Release_job+0x6c>
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
8006f78: 78 02 08 02 mvhi r2,0x802
8006f7c: 38 42 2a c8 ori r2,r2,0x2ac8
8006f80: 28 64 00 04 lw r4,(r3+4)
8006f84: 28 42 00 00 lw r2,(r2+0)
8006f88: 78 05 08 01 mvhi r5,0x801
8006f8c: 38 a5 fc 8c ori r5,r5,0xfc8c
8006f90: b4 44 10 00 add r2,r2,r4
8006f94: 28 a4 00 00 lw r4,(r5+0)
8006f98: a0 44 10 00 and r2,r2,r4
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
the_thread->cpu_time_budget = serv_info->parameters.budget;
8006f9c: 28 63 00 08 lw r3,(r3+8)
8006fa0: 58 23 00 74 sw (r1+116),r3
the_thread->real_priority = new_priority;
8006fa4: 58 22 00 18 sw (r1+24),r2
_Thread_Change_priority(the_thread, new_priority, true);
8006fa8: 34 03 00 01 mvi r3,1
8006fac: f8 00 01 4f calli 80074e8 <_Thread_Change_priority>
}
8006fb0: 2b 9d 00 04 lw ra,(sp+4)
8006fb4: 37 9c 00 04 addi sp,sp,4
8006fb8: c3 a0 00 00 ret
new_priority = (_Watchdog_Ticks_since_boot + deadline)
& ~SCHEDULER_EDF_PRIO_MSB;
}
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
8006fbc: 28 22 00 ac lw r2,(r1+172)
}
/* Budget replenishment for the next job. */
if (serv_info)
8006fc0: 5c 64 ff f7 bne r3,r4,8006f9c <_Scheduler_CBS_Release_job+0x40><== ALWAYS TAKEN
8006fc4: e3 ff ff f8 bi 8006fa4 <_Scheduler_CBS_Release_job+0x48> <== NOT EXECUTED
/* Initializing or shifting deadline. */
if (serv_info)
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
8006fc8: 78 02 08 02 mvhi r2,0x802
8006fcc: 38 42 2a c8 ori r2,r2,0x2ac8
8006fd0: 28 42 00 00 lw r2,(r2+0)
8006fd4: b4 82 10 00 add r2,r4,r2
8006fd8: 78 04 08 01 mvhi r4,0x801
8006fdc: 38 84 fc 8c ori r4,r4,0xfc8c
8006fe0: 28 83 00 00 lw r3,(r4+0)
8006fe4: a0 43 10 00 and r2,r2,r3
8006fe8: e3 ff ff ef bi 8006fa4 <_Scheduler_CBS_Release_job+0x48>
08006fec <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
8006fec: 37 9c ff ec addi sp,sp,-20
8006ff0: 5b 8b 00 14 sw (sp+20),r11
8006ff4: 5b 8c 00 10 sw (sp+16),r12
8006ff8: 5b 8d 00 0c sw (sp+12),r13
8006ffc: 5b 8e 00 08 sw (sp+8),r14
8007000: 5b 9d 00 04 sw (sp+4),ra
8007004: b8 20 58 00 mv r11,r1
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server *serv_info;
Priority_Control new_priority;
_Scheduler_EDF_Enqueue(the_thread);
8007008: f8 00 00 59 calli 800716c <_Scheduler_EDF_Enqueue>
/* TODO: flash critical section? */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server;
800700c: 29 61 00 88 lw r1,(r11+136)
8007010: 28 2c 00 18 lw r12,(r1+24)
* Late unblock rule for deadline-driven tasks. The remaining time to
* deadline must be sufficient to serve the remaining computation time
* without increased utilization of this task. It might cause a deadline
* miss of another task.
*/
if (serv_info) {
8007014: 45 80 00 0d be r12,r0,8007048 <_Scheduler_CBS_Unblock+0x5c>
time_t deadline = serv_info->parameters.deadline;
time_t budget = serv_info->parameters.budget;
time_t deadline_left = the_thread->cpu_time_budget;
time_t budget_left = the_thread->real_priority -
8007018: 78 01 08 02 mvhi r1,0x802
800701c: 38 21 2a c8 ori r1,r1,0x2ac8
8007020: 28 21 00 00 lw r1,(r1+0)
8007024: 29 6d 00 18 lw r13,(r11+24)
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
8007028: 29 82 00 04 lw r2,(r12+4)
800702c: c9 a1 08 00 sub r1,r13,r1
8007030: f8 00 5b 5a calli 801dd98 <__mulsi3>
8007034: b8 20 70 00 mv r14,r1
8007038: 29 82 00 08 lw r2,(r12+8)
800703c: 29 61 00 74 lw r1,(r11+116)
8007040: f8 00 5b 56 calli 801dd98 <__mulsi3>
8007044: 49 c1 00 18 bg r14,r1,80070a4 <_Scheduler_CBS_Unblock+0xb8>
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
if ( the_thread->real_priority != new_priority )
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
_Thread_Change_priority(the_thread, new_priority, true);
8007048: 29 61 00 14 lw r1,(r11+20)
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
800704c: 78 0c 08 02 mvhi r12,0x802
8007050: 39 8c 2e 80 ori r12,r12,0x2e80
8007054: 29 84 00 14 lw r4,(r12+20)
8007058: 78 02 08 02 mvhi r2,0x802
800705c: 38 42 20 1c ori r2,r2,0x201c
8007060: 28 43 00 30 lw r3,(r2+48)
8007064: 28 82 00 14 lw r2,(r4+20)
8007068: d8 60 00 00 call r3
800706c: 4c 01 00 07 bge r0,r1,8007088 <_Scheduler_CBS_Unblock+0x9c>
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
8007070: 29 81 00 10 lw r1,(r12+16)
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
8007074: 59 8b 00 14 sw (r12+20),r11
if ( _Thread_Executing->is_preemptible ||
8007078: 40 21 00 70 lbu r1,(r1+112)
800707c: 44 20 00 13 be r1,r0,80070c8 <_Scheduler_CBS_Unblock+0xdc>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
8007080: 34 01 00 01 mvi r1,1
8007084: 31 81 00 0c sb (r12+12),r1
}
}
8007088: 2b 9d 00 04 lw ra,(sp+4)
800708c: 2b 8b 00 14 lw r11,(sp+20)
8007090: 2b 8c 00 10 lw r12,(sp+16)
8007094: 2b 8d 00 0c lw r13,(sp+12)
8007098: 2b 8e 00 08 lw r14,(sp+8)
800709c: 37 9c 00 14 addi sp,sp,20
80070a0: c3 a0 00 00 ret
time_t budget_left = the_thread->real_priority -
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
80070a4: 29 62 00 ac lw r2,(r11+172)
if ( the_thread->real_priority != new_priority )
80070a8: 45 a2 00 02 be r13,r2,80070b0 <_Scheduler_CBS_Unblock+0xc4>
the_thread->real_priority = new_priority;
80070ac: 59 62 00 18 sw (r11+24),r2
if ( the_thread->current_priority != new_priority )
80070b0: 29 61 00 14 lw r1,(r11+20)
80070b4: 44 22 ff e6 be r1,r2,800704c <_Scheduler_CBS_Unblock+0x60>
_Thread_Change_priority(the_thread, new_priority, true);
80070b8: b9 60 08 00 mv r1,r11
80070bc: 34 03 00 01 mvi r3,1
80070c0: f8 00 01 0a calli 80074e8 <_Thread_Change_priority>
80070c4: e3 ff ff e1 bi 8007048 <_Scheduler_CBS_Unblock+0x5c>
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
80070c8: 29 62 00 14 lw r2,(r11+20)
80070cc: 44 41 ff ed be r2,r1,8007080 <_Scheduler_CBS_Unblock+0x94> <== NEVER TAKEN
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
}
}
80070d0: 2b 9d 00 04 lw ra,(sp+4)
80070d4: 2b 8b 00 14 lw r11,(sp+20)
80070d8: 2b 8c 00 10 lw r12,(sp+16)
80070dc: 2b 8d 00 0c lw r13,(sp+12)
80070e0: 2b 8e 00 08 lw r14,(sp+8)
80070e4: 37 9c 00 14 addi sp,sp,20
80070e8: c3 a0 00 00 ret
08006f1c <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
8006f1c: 37 9c ff f8 addi sp,sp,-8
8006f20: 5b 8b 00 08 sw (sp+8),r11
8006f24: 5b 9d 00 04 sw (sp+4),ra
8006f28: b8 20 58 00 mv r11,r1
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
8006f2c: 34 01 00 18 mvi r1,24
8006f30: f8 00 07 da calli 8008e98 <_Workspace_Allocate>
if ( sched ) {
8006f34: 44 20 00 05 be r1,r0,8006f48 <_Scheduler_EDF_Allocate+0x2c><== NEVER TAKEN
the_thread->scheduler_info = sched;
8006f38: 59 61 00 88 sw (r11+136),r1
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
8006f3c: 34 02 00 02 mvi r2,2
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
if ( sched ) {
the_thread->scheduler_info = sched;
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
8006f40: 58 2b 00 00 sw (r1+0),r11
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
8006f44: 58 22 00 14 sw (r1+20),r2
}
return sched;
}
8006f48: 2b 9d 00 04 lw ra,(sp+4)
8006f4c: 2b 8b 00 08 lw r11,(sp+8)
8006f50: 37 9c 00 08 addi sp,sp,8
8006f54: c3 a0 00 00 ret
08007190 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
8007190: 37 9c ff f4 addi sp,sp,-12
8007194: 5b 8b 00 0c sw (sp+12),r11
8007198: 5b 8c 00 08 sw (sp+8),r12
800719c: 5b 9d 00 04 sw (sp+4),ra
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
80071a0: 78 0b 08 02 mvhi r11,0x802
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
80071a4: b8 20 60 00 mv r12,r1
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
80071a8: 39 6b 2e 80 ori r11,r11,0x2e80
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
_Scheduler_EDF_Enqueue(the_thread);
80071ac: fb ff ff 8b calli 8006fd8 <_Scheduler_EDF_Enqueue>
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
80071b0: 29 61 00 14 lw r1,(r11+20)
80071b4: 78 02 08 02 mvhi r2,0x802
80071b8: 38 42 20 18 ori r2,r2,0x2018
80071bc: 28 43 00 30 lw r3,(r2+48)
80071c0: 28 21 00 14 lw r1,(r1+20)
80071c4: 29 82 00 14 lw r2,(r12+20)
80071c8: d8 60 00 00 call r3
80071cc: 4c 20 00 07 bge r1,r0,80071e8 <_Scheduler_EDF_Unblock+0x58>
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
80071d0: 29 61 00 10 lw r1,(r11+16)
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
80071d4: 59 6c 00 14 sw (r11+20),r12
if ( _Thread_Executing->is_preemptible ||
80071d8: 40 21 00 70 lbu r1,(r1+112)
80071dc: 44 20 00 08 be r1,r0,80071fc <_Scheduler_EDF_Unblock+0x6c>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
80071e0: 34 01 00 01 mvi r1,1
80071e4: 31 61 00 0c sb (r11+12),r1
}
}
80071e8: 2b 9d 00 04 lw ra,(sp+4)
80071ec: 2b 8b 00 0c lw r11,(sp+12)
80071f0: 2b 8c 00 08 lw r12,(sp+8)
80071f4: 37 9c 00 0c addi sp,sp,12
80071f8: c3 a0 00 00 ret
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
80071fc: 29 82 00 14 lw r2,(r12+20)
8007200: 5c 41 ff fa bne r2,r1,80071e8 <_Scheduler_EDF_Unblock+0x58><== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
8007204: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
8007208: 31 61 00 0c sb (r11+12),r1 <== NOT EXECUTED
800720c: e3 ff ff f7 bi 80071e8 <_Scheduler_EDF_Unblock+0x58> <== NOT EXECUTED
0800600c <_Scheduler_priority_Block>:
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
800600c: 28 23 00 88 lw r3,(r1+136)
ready = sched_info->ready_chain;
8006010: 28 62 00 00 lw r2,(r3+0)
if ( _Chain_Has_only_one_node( ready ) ) {
8006014: 28 45 00 00 lw r5,(r2+0)
8006018: 28 44 00 08 lw r4,(r2+8)
800601c: 44 a4 00 37 be r5,r4,80060f8 <_Scheduler_priority_Block+0xec>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
8006020: 28 23 00 00 lw r3,(r1+0)
previous = the_node->previous;
8006024: 28 22 00 04 lw r2,(r1+4)
next->previous = previous;
8006028: 58 62 00 04 sw (r3+4),r2
previous->next = next;
800602c: 58 43 00 00 sw (r2+0),r3
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
8006030: 78 02 08 02 mvhi r2,0x802
8006034: 38 42 0d e0 ori r2,r2,0xde0
{
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
8006038: 28 43 00 14 lw r3,(r2+20)
800603c: 44 23 00 07 be r1,r3,8006058 <_Scheduler_priority_Block+0x4c>
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
8006040: 28 43 00 10 lw r3,(r2+16)
8006044: 44 23 00 02 be r1,r3,800604c <_Scheduler_priority_Block+0x40>
8006048: c3 a0 00 00 ret
_Thread_Dispatch_necessary = true;
800604c: 34 01 00 01 mvi r1,1
8006050: 30 41 00 0c sb (r2+12),r1
8006054: c3 a0 00 00 ret
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 );
8006058: 78 03 08 02 mvhi r3,0x802
800605c: 38 63 0e 20 ori r3,r3,0xe20
8006060: 2c 64 00 00 lhu r4,(r3+0)
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
(Chain_Control *) _Scheduler.information
8006064: 78 03 08 02 mvhi r3,0x802
8006068: 38 63 00 18 ori r3,r3,0x18
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
800606c: 28 67 00 00 lw r7,(r3+0)
8006070: 20 84 ff ff andi r4,r4,0xffff
8006074: 34 03 00 ff mvi r3,255
8006078: 54 83 00 3c bgu r4,r3,8006168 <_Scheduler_priority_Block+0x15c>
800607c: 78 05 08 01 mvhi r5,0x801
8006080: 38 a5 da a8 ori r5,r5,0xdaa8
8006084: b4 a4 20 00 add r4,r5,r4
8006088: 40 84 00 00 lbu r4,(r4+0)
800608c: 34 84 00 08 addi r4,r4,8
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
8006090: 78 06 08 02 mvhi r6,0x802
8006094: 38 c6 0e 40 ori r6,r6,0xe40
8006098: b4 84 20 00 add r4,r4,r4
800609c: b4 c4 30 00 add r6,r6,r4
80060a0: 2c c3 00 00 lhu r3,(r6+0)
80060a4: 34 06 00 ff mvi r6,255
80060a8: 54 66 00 25 bgu r3,r6,800613c <_Scheduler_priority_Block+0x130>
80060ac: b4 a3 18 00 add r3,r5,r3
80060b0: 40 65 00 00 lbu r5,(r3+0)
80060b4: 34 a5 00 08 addi r5,r5,8
return (_Priority_Bits_index( major ) << 4) +
80060b8: b4 84 18 00 add r3,r4,r4
80060bc: b4 63 18 00 add r3,r3,r3
80060c0: b4 63 18 00 add r3,r3,r3
80060c4: b4 a3 18 00 add r3,r5,r3
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
80060c8: b4 63 20 00 add r4,r3,r3
80060cc: b4 83 18 00 add r3,r4,r3
80060d0: b4 63 18 00 add r3,r3,r3
80060d4: b4 63 18 00 add r3,r3,r3
80060d8: b4 e3 18 00 add r3,r7,r3
}
80060dc: 28 65 00 00 lw r5,(r3+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
80060e0: 34 63 00 04 addi r3,r3,4
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
80060e4: 34 04 00 00 mvi r4,0
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
80060e8: 44 a3 00 02 be r5,r3,80060f0 <_Scheduler_priority_Block+0xe4><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
80060ec: b8 a0 20 00 mv r4,r5
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
80060f0: 58 44 00 14 sw (r2+20),r4
80060f4: e3 ff ff d3 bi 8006040 <_Scheduler_priority_Block+0x34>
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
80060f8: 28 64 00 04 lw r4,(r3+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 );
80060fc: 34 45 00 04 addi r5,r2,4
head->next = tail;
8006100: 58 45 00 00 sw (r2+0),r5
head->previous = NULL;
8006104: 58 40 00 04 sw (r2+4),r0
tail->previous = head;
8006108: 58 42 00 08 sw (r2+8),r2
800610c: 2c 65 00 0e lhu r5,(r3+14)
8006110: 2c 82 00 00 lhu r2,(r4+0)
8006114: a0 45 10 00 and r2,r2,r5
8006118: 0c 82 00 00 sh (r4+0),r2
if ( *the_priority_map->minor == 0 )
800611c: 5c 40 ff c5 bne r2,r0,8006030 <_Scheduler_priority_Block+0x24>
_Priority_Major_bit_map &= the_priority_map->block_major;
8006120: 78 02 08 02 mvhi r2,0x802
8006124: 38 42 0e 20 ori r2,r2,0xe20
8006128: 2c 44 00 00 lhu r4,(r2+0)
800612c: 2c 63 00 0c lhu r3,(r3+12)
8006130: a0 64 18 00 and r3,r3,r4
8006134: 0c 43 00 00 sh (r2+0),r3
8006138: e3 ff ff be bi 8006030 <_Scheduler_priority_Block+0x24>
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
800613c: 00 63 00 01 srui r3,r3,1
8006140: 00 63 00 01 srui r3,r3,1
8006144: 00 63 00 01 srui r3,r3,1
8006148: 00 63 00 01 srui r3,r3,1
800614c: 00 63 00 01 srui r3,r3,1
8006150: 00 63 00 01 srui r3,r3,1
8006154: 00 63 00 01 srui r3,r3,1
8006158: 00 63 00 01 srui r3,r3,1
800615c: b4 a3 18 00 add r3,r5,r3
8006160: 40 65 00 00 lbu r5,(r3+0)
8006164: e3 ff ff d5 bi 80060b8 <_Scheduler_priority_Block+0xac>
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 );
8006168: 00 84 00 01 srui r4,r4,1
800616c: 78 05 08 01 mvhi r5,0x801
8006170: 00 84 00 01 srui r4,r4,1
8006174: 38 a5 da a8 ori r5,r5,0xdaa8
8006178: 00 84 00 01 srui r4,r4,1
800617c: 00 84 00 01 srui r4,r4,1
8006180: 00 84 00 01 srui r4,r4,1
8006184: 00 84 00 01 srui r4,r4,1
8006188: 00 84 00 01 srui r4,r4,1
800618c: 00 84 00 01 srui r4,r4,1
8006190: b4 a4 20 00 add r4,r5,r4
8006194: 40 84 00 00 lbu r4,(r4+0)
8006198: e3 ff ff be bi 8006090 <_Scheduler_priority_Block+0x84>
08006368 <_Scheduler_priority_Schedule>:
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 );
8006368: 78 01 08 02 mvhi r1,0x802
800636c: 38 21 0e 20 ori r1,r1,0xe20
8006370: 2c 22 00 00 lhu r2,(r1+0)
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
(Chain_Control *) _Scheduler.information
8006374: 78 01 08 02 mvhi r1,0x802
8006378: 38 21 00 18 ori r1,r1,0x18
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
800637c: 28 25 00 00 lw r5,(r1+0)
8006380: 20 42 ff ff andi r2,r2,0xffff
8006384: 34 01 00 ff mvi r1,255
8006388: 54 41 00 2d bgu r2,r1,800643c <_Scheduler_priority_Schedule+0xd4>
800638c: 78 03 08 01 mvhi r3,0x801
8006390: 38 63 da a8 ori r3,r3,0xdaa8
8006394: b4 62 10 00 add r2,r3,r2
8006398: 40 42 00 00 lbu r2,(r2+0)
800639c: 34 42 00 08 addi r2,r2,8
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
80063a0: 78 04 08 02 mvhi r4,0x802
80063a4: 38 84 0e 40 ori r4,r4,0xe40
80063a8: b4 42 10 00 add r2,r2,r2
80063ac: b4 82 20 00 add r4,r4,r2
80063b0: 2c 81 00 00 lhu r1,(r4+0)
80063b4: 34 04 00 ff mvi r4,255
80063b8: 54 24 00 16 bgu r1,r4,8006410 <_Scheduler_priority_Schedule+0xa8>
80063bc: b4 61 08 00 add r1,r3,r1
80063c0: 40 23 00 00 lbu r3,(r1+0)
80063c4: 34 63 00 08 addi r3,r3,8
return (_Priority_Bits_index( major ) << 4) +
80063c8: b4 42 08 00 add r1,r2,r2
80063cc: b4 21 08 00 add r1,r1,r1
80063d0: b4 21 08 00 add r1,r1,r1
80063d4: b4 61 08 00 add r1,r3,r1
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
80063d8: b4 21 10 00 add r2,r1,r1
80063dc: b4 41 08 00 add r1,r2,r1
80063e0: b4 21 08 00 add r1,r1,r1
80063e4: b4 21 08 00 add r1,r1,r1
80063e8: b4 a1 08 00 add r1,r5,r1
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
_Scheduler_priority_Schedule_body();
}
80063ec: 28 23 00 00 lw r3,(r1+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
80063f0: 34 21 00 04 addi r1,r1,4
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
80063f4: 34 02 00 00 mvi r2,0
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
80063f8: 44 61 00 02 be r3,r1,8006400 <_Scheduler_priority_Schedule+0x98><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
80063fc: b8 60 10 00 mv r2,r3
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
8006400: 78 01 08 02 mvhi r1,0x802
8006404: 38 21 0d e0 ori r1,r1,0xde0
8006408: 58 22 00 14 sw (r1+20),r2
800640c: c3 a0 00 00 ret
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
8006410: 00 21 00 01 srui r1,r1,1
8006414: 00 21 00 01 srui r1,r1,1
8006418: 00 21 00 01 srui r1,r1,1
800641c: 00 21 00 01 srui r1,r1,1
8006420: 00 21 00 01 srui r1,r1,1
8006424: 00 21 00 01 srui r1,r1,1
8006428: 00 21 00 01 srui r1,r1,1
800642c: 00 21 00 01 srui r1,r1,1
8006430: b4 61 08 00 add r1,r3,r1
8006434: 40 23 00 00 lbu r3,(r1+0)
8006438: e3 ff ff e4 bi 80063c8 <_Scheduler_priority_Schedule+0x60>
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 );
800643c: 00 42 00 01 srui r2,r2,1
8006440: 78 03 08 01 mvhi r3,0x801
8006444: 00 42 00 01 srui r2,r2,1
8006448: 38 63 da a8 ori r3,r3,0xdaa8
800644c: 00 42 00 01 srui r2,r2,1
8006450: 00 42 00 01 srui r2,r2,1
8006454: 00 42 00 01 srui r2,r2,1
8006458: 00 42 00 01 srui r2,r2,1
800645c: 00 42 00 01 srui r2,r2,1
8006460: 00 42 00 01 srui r2,r2,1
8006464: b4 62 10 00 add r2,r3,r2
8006468: 40 42 00 00 lbu r2,(r2+0)
800646c: e3 ff ff cd bi 80063a0 <_Scheduler_priority_Schedule+0x38>
08006470 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
8006470: 37 9c ff f8 addi sp,sp,-8
8006474: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *executing;
executing = _Thread_Executing;
8006478: 78 01 08 02 mvhi r1,0x802
800647c: 38 21 0d e0 ori r1,r1,0xde0
8006480: 28 21 00 10 lw r1,(r1+16)
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
8006484: 40 22 00 70 lbu r2,(r1+112)
8006488: 44 40 00 09 be r2,r0,80064ac <_Scheduler_priority_Tick+0x3c>
return;
if ( !_States_Is_ready( executing->current_state ) )
800648c: 28 22 00 10 lw r2,(r1+16)
8006490: 5c 40 00 07 bne r2,r0,80064ac <_Scheduler_priority_Tick+0x3c>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
8006494: 28 22 00 78 lw r2,(r1+120)
8006498: 44 40 00 05 be r2,r0,80064ac <_Scheduler_priority_Tick+0x3c>
800649c: 34 03 00 02 mvi r3,2
80064a0: 50 62 00 0d bgeu r3,r2,80064d4 <_Scheduler_priority_Tick+0x64>
80064a4: 34 03 00 03 mvi r3,3
80064a8: 44 43 00 04 be r2,r3,80064b8 <_Scheduler_priority_Tick+0x48><== ALWAYS TAKEN
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
#endif
}
}
80064ac: 2b 9d 00 04 lw ra,(sp+4)
80064b0: 37 9c 00 08 addi sp,sp,8
80064b4: c3 a0 00 00 ret
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
80064b8: 28 22 00 74 lw r2,(r1+116)
80064bc: 34 42 ff ff addi r2,r2,-1
80064c0: 58 22 00 74 sw (r1+116),r2
80064c4: 5c 40 ff fa bne r2,r0,80064ac <_Scheduler_priority_Tick+0x3c>
(*executing->budget_callout)( executing );
80064c8: 28 22 00 7c lw r2,(r1+124)
80064cc: d8 40 00 00 call r2
80064d0: e3 ff ff f7 bi 80064ac <_Scheduler_priority_Tick+0x3c>
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
80064d4: 28 22 00 74 lw r2,(r1+116)
80064d8: 34 42 ff ff addi r2,r2,-1
80064dc: 58 22 00 74 sw (r1+116),r2
80064e0: 48 40 ff f3 bg r2,r0,80064ac <_Scheduler_priority_Tick+0x3c>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
80064e4: 78 02 08 02 mvhi r2,0x802
80064e8: 38 42 00 18 ori r2,r2,0x18
80064ec: 28 42 00 0c lw r2,(r2+12)
80064f0: 5b 81 00 08 sw (sp+8),r1
80064f4: d8 40 00 00 call r2
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield();
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
80064f8: 78 02 08 02 mvhi r2,0x802
80064fc: 38 42 08 f0 ori r2,r2,0x8f0
8006500: 28 42 00 00 lw r2,(r2+0)
8006504: 2b 81 00 08 lw r1,(sp+8)
8006508: 58 22 00 74 sw (r1+116),r2
800650c: e3 ff ff e8 bi 80064ac <_Scheduler_priority_Tick+0x3c>
0800519c <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
800519c: 37 9c ff f4 addi sp,sp,-12
80051a0: 5b 8b 00 0c sw (sp+12),r11
80051a4: 5b 8c 00 08 sw (sp+8),r12
80051a8: 5b 9d 00 04 sw (sp+4),ra
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
80051ac: 78 02 08 01 mvhi r2,0x801
80051b0: 38 42 fa d0 ori r2,r2,0xfad0
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
80051b4: b8 20 58 00 mv r11,r1
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
80051b8: 28 42 00 0c lw r2,(r2+12)
(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;
80051bc: 34 0c 00 00 mvi r12,0
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) ||
80051c0: 44 20 00 22 be r1,r0,8005248 <_TOD_Validate+0xac> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
80051c4: 78 03 08 01 mvhi r3,0x801
80051c8: 38 63 fe 54 ori r3,r3,0xfe54
80051cc: 28 61 00 00 lw r1,(r3+0)
80051d0: f8 00 65 7d calli 801e7c4 <__udivsi3>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
80051d4: 29 62 00 18 lw r2,(r11+24)
80051d8: 50 41 00 1c bgeu r2,r1,8005248 <_TOD_Validate+0xac>
(the_tod->ticks >= ticks_per_second) ||
80051dc: 29 62 00 14 lw r2,(r11+20)
80051e0: 34 01 00 3b mvi r1,59
80051e4: 54 41 00 19 bgu r2,r1,8005248 <_TOD_Validate+0xac>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
80051e8: 29 62 00 10 lw r2,(r11+16)
80051ec: 54 41 00 17 bgu r2,r1,8005248 <_TOD_Validate+0xac>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
80051f0: 29 62 00 0c lw r2,(r11+12)
80051f4: 34 01 00 17 mvi r1,23
80051f8: 54 41 00 14 bgu r2,r1,8005248 <_TOD_Validate+0xac>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
80051fc: 29 61 00 04 lw r1,(r11+4)
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
8005200: 44 20 00 12 be r1,r0,8005248 <_TOD_Validate+0xac> <== NEVER TAKEN
(the_tod->month == 0) ||
8005204: 34 02 00 0c mvi r2,12
8005208: 54 22 00 10 bgu r1,r2,8005248 <_TOD_Validate+0xac>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
800520c: 29 62 00 00 lw r2,(r11+0)
(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) ||
8005210: 34 03 07 c3 mvi r3,1987
8005214: 50 62 00 0d bgeu r3,r2,8005248 <_TOD_Validate+0xac>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
8005218: 29 63 00 08 lw r3,(r11+8)
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
800521c: 44 60 00 0b be r3,r0,8005248 <_TOD_Validate+0xac> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
8005220: 20 42 00 03 andi r2,r2,0x3
8005224: 5c 40 00 02 bne r2,r0,800522c <_TOD_Validate+0x90>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
8005228: 34 21 00 0d addi r1,r1,13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
800522c: 78 02 08 02 mvhi r2,0x802
8005230: b4 21 08 00 add r1,r1,r1
8005234: 38 42 07 d0 ori r2,r2,0x7d0
8005238: b4 21 08 00 add r1,r1,r1
800523c: b4 41 08 00 add r1,r2,r1
8005240: 28 2c 00 00 lw r12,(r1+0)
const uint32_t _TOD_Days_per_month[ 2 ][ 13 ] = {
{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
{ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
};
bool _TOD_Validate(
8005244: f1 83 60 00 cmpgeu r12,r12,r3
if ( the_tod->day > days_in_month )
return false;
return true;
}
8005248: b9 80 08 00 mv r1,r12
800524c: 2b 9d 00 04 lw ra,(sp+4)
8005250: 2b 8b 00 0c lw r11,(sp+12)
8005254: 2b 8c 00 08 lw r12,(sp+8)
8005258: 37 9c 00 0c addi sp,sp,12
800525c: c3 a0 00 00 ret
080066e0 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
80066e0: 37 9c ff e4 addi sp,sp,-28
80066e4: 5b 8b 00 1c sw (sp+28),r11
80066e8: 5b 8c 00 18 sw (sp+24),r12
80066ec: 5b 8d 00 14 sw (sp+20),r13
80066f0: 5b 8e 00 10 sw (sp+16),r14
80066f4: 5b 8f 00 0c sw (sp+12),r15
80066f8: 5b 90 00 08 sw (sp+8),r16
80066fc: 5b 9d 00 04 sw (sp+4),ra
8006700: b8 20 58 00 mv r11,r1
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
8006704: 28 2f 00 10 lw r15,(r1+16)
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
8006708: b8 40 60 00 mv r12,r2
800670c: 20 70 00 ff andi r16,r3,0xff
/*
* 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 );
8006710: f8 00 04 0c calli 8007740 <_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 )
8006714: 29 61 00 14 lw r1,(r11+20)
8006718: 44 2c 00 04 be r1,r12,8006728 <_Thread_Change_priority+0x48>
_Thread_Set_priority( the_thread, new_priority );
800671c: b9 60 08 00 mv r1,r11
8006720: b9 80 10 00 mv r2,r12
8006724: f8 00 03 e3 calli 80076b0 <_Thread_Set_priority>
_ISR_Disable( level );
8006728: 90 00 60 00 rcsr r12,IE
800672c: 34 0d ff fe mvi r13,-2
8006730: a1 8d 68 00 and r13,r12,r13
8006734: d0 0d 00 00 wcsr IE,r13
/*
* 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;
8006738: 29 61 00 10 lw r1,(r11+16)
if ( state != STATES_TRANSIENT ) {
800673c: 34 02 00 04 mvi r2,4
8006740: 44 22 00 1f be r1,r2,80067bc <_Thread_Change_priority+0xdc>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_transient (
States_Control the_states
)
{
return (the_states & STATES_TRANSIENT);
8006744: 21 ef 00 04 andi r15,r15,0x4
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
8006748: 45 e0 00 10 be r15,r0,8006788 <_Thread_Change_priority+0xa8><== ALWAYS TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
800674c: d0 0c 00 00 wcsr IE,r12 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
8006750: 78 03 08 01 mvhi r3,0x801 <== NOT EXECUTED
8006754: 38 63 dc 04 ori r3,r3,0xdc04 <== NOT EXECUTED
8006758: 28 62 00 00 lw r2,(r3+0) <== NOT EXECUTED
800675c: a0 22 08 00 and r1,r1,r2 <== NOT EXECUTED
if ( _States_Is_waiting_on_thread_queue( state ) ) {
8006760: 5c 20 00 13 bne r1,r0,80067ac <_Thread_Change_priority+0xcc><== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
8006764: 2b 9d 00 04 lw ra,(sp+4)
8006768: 2b 8b 00 1c lw r11,(sp+28)
800676c: 2b 8c 00 18 lw r12,(sp+24)
8006770: 2b 8d 00 14 lw r13,(sp+20)
8006774: 2b 8e 00 10 lw r14,(sp+16)
8006778: 2b 8f 00 0c lw r15,(sp+12)
800677c: 2b 90 00 08 lw r16,(sp+8)
8006780: 37 9c 00 1c addi sp,sp,28
8006784: c3 a0 00 00 ret
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
8006788: 34 02 ff fb mvi r2,-5
800678c: a0 22 10 00 and r2,r1,r2
*/
state = the_thread->current_state;
if ( state != STATES_TRANSIENT ) {
/* 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 );
8006790: 59 62 00 10 sw (r11+16),r2
_ISR_Enable( level );
8006794: d0 0c 00 00 wcsr IE,r12
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
8006798: 78 03 08 01 mvhi r3,0x801
800679c: 38 63 dc 04 ori r3,r3,0xdc04
80067a0: 28 62 00 00 lw r2,(r3+0)
80067a4: a0 22 08 00 and r1,r1,r2
if ( _States_Is_waiting_on_thread_queue( state ) ) {
80067a8: 44 20 ff ef be r1,r0,8006764 <_Thread_Change_priority+0x84>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
80067ac: 29 61 00 44 lw r1,(r11+68)
80067b0: b9 60 10 00 mv r2,r11
80067b4: f8 00 03 82 calli 80075bc <_Thread_queue_Requeue>
80067b8: e3 ff ff eb bi 8006764 <_Thread_Change_priority+0x84>
80067bc: 78 0e 08 02 mvhi r14,0x802
*/
RTEMS_INLINE_ROUTINE bool _States_Is_transient (
States_Control the_states
)
{
return (the_states & STATES_TRANSIENT);
80067c0: 21 ef 00 04 andi r15,r15,0x4
80067c4: 39 ce 00 18 ori r14,r14,0x18
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
80067c8: 5d e0 00 06 bne r15,r0,80067e0 <_Thread_Change_priority+0x100><== 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 );
80067cc: 59 60 00 10 sw (r11+16),r0
if ( prepend_it )
80067d0: 46 0f 00 13 be r16,r15,800681c <_Thread_Change_priority+0x13c>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
80067d4: 29 c2 00 28 lw r2,(r14+40)
80067d8: b9 60 08 00 mv r1,r11
80067dc: d8 40 00 00 call r2
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
80067e0: d0 0c 00 00 wcsr IE,r12
80067e4: d0 0d 00 00 wcsr IE,r13
* 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();
80067e8: 29 c1 00 08 lw r1,(r14+8)
80067ec: d8 20 00 00 call r1
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
80067f0: 78 01 08 02 mvhi r1,0x802
80067f4: 38 21 0d e0 ori r1,r1,0xde0
80067f8: 28 22 00 10 lw r2,(r1+16)
* 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() &&
80067fc: 28 23 00 14 lw r3,(r1+20)
8006800: 44 43 00 05 be r2,r3,8006814 <_Thread_Change_priority+0x134>
8006804: 40 42 00 70 lbu r2,(r2+112)
8006808: 44 40 00 03 be r2,r0,8006814 <_Thread_Change_priority+0x134>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
800680c: 34 02 00 01 mvi r2,1
8006810: 30 22 00 0c sb (r1+12),r2
_ISR_Enable( level );
8006814: d0 0c 00 00 wcsr IE,r12
8006818: e3 ff ff d3 bi 8006764 <_Thread_Change_priority+0x84>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
800681c: 29 c2 00 24 lw r2,(r14+36)
8006820: b9 60 08 00 mv r1,r11
8006824: d8 40 00 00 call r2
8006828: e3 ff ff ee bi 80067e0 <_Thread_Change_priority+0x100>
0800d48c <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
800d48c: 37 9c ff f8 addi sp,sp,-8
800d490: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
800d494: 37 82 00 08 addi r2,sp,8
800d498: f8 00 00 a7 calli 800d734 <_Thread_Get>
switch ( location ) {
800d49c: 2b 82 00 08 lw r2,(sp+8)
800d4a0: 5c 40 00 0a bne r2,r0,800d4c8 <_Thread_Delay_ended+0x3c> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
800d4a4: 78 03 08 02 mvhi r3,0x802
800d4a8: 38 63 86 44 ori r3,r3,0x8644
800d4ac: 28 62 00 00 lw r2,(r3+0)
800d4b0: fb ff ff 65 calli 800d244 <_Thread_Clear_state>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
800d4b4: 78 01 08 02 mvhi r1,0x802
800d4b8: 38 21 aa 78 ori r1,r1,0xaa78
800d4bc: 28 22 00 00 lw r2,(r1+0)
--level;
800d4c0: 34 42 ff ff addi r2,r2,-1
_Thread_Dispatch_disable_level = level;
800d4c4: 58 22 00 00 sw (r1+0),r2
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
800d4c8: 2b 9d 00 04 lw ra,(sp+4)
800d4cc: 37 9c 00 08 addi sp,sp,8
800d4d0: c3 a0 00 00 ret
08006a04 <_Thread_Dispatch>:
#if defined(RTEMS_SMP)
#include <rtems/score/smp.h>
#endif
void _Thread_Dispatch( void )
{
8006a04: 37 9c ff bc addi sp,sp,-68
8006a08: 5b 8b 00 3c sw (sp+60),r11
8006a0c: 5b 8c 00 38 sw (sp+56),r12
8006a10: 5b 8d 00 34 sw (sp+52),r13
8006a14: 5b 8e 00 30 sw (sp+48),r14
8006a18: 5b 8f 00 2c sw (sp+44),r15
8006a1c: 5b 90 00 28 sw (sp+40),r16
8006a20: 5b 91 00 24 sw (sp+36),r17
8006a24: 5b 92 00 20 sw (sp+32),r18
8006a28: 5b 93 00 1c sw (sp+28),r19
8006a2c: 5b 94 00 18 sw (sp+24),r20
8006a30: 5b 95 00 14 sw (sp+20),r21
8006a34: 5b 96 00 10 sw (sp+16),r22
8006a38: 5b 97 00 0c sw (sp+12),r23
8006a3c: 5b 98 00 08 sw (sp+8),r24
8006a40: 5b 9d 00 04 sw (sp+4),ra
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
8006a44: 78 01 08 02 mvhi r1,0x802
8006a48: 38 21 0d e0 ori r1,r1,0xde0
8006a4c: 28 2c 00 10 lw r12,(r1+16)
_ISR_Disable( level );
8006a50: 90 00 18 00 rcsr r3,IE
8006a54: 34 01 ff fe mvi r1,-2
8006a58: a0 61 08 00 and r1,r3,r1
8006a5c: d0 01 00 00 wcsr IE,r1
while ( _Thread_Dispatch_necessary == true ) {
8006a60: 78 0e 08 02 mvhi r14,0x802
8006a64: 39 ce 0d e0 ori r14,r14,0xde0
8006a68: 41 c2 00 0c lbu r2,(r14+12)
8006a6c: 78 11 08 02 mvhi r17,0x802
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
8006a70: b8 60 08 00 mv r1,r3
while ( _Thread_Dispatch_necessary == true ) {
8006a74: 20 42 00 ff andi r2,r2,0xff
8006a78: 3a 31 09 58 ori r17,r17,0x958
8006a7c: 44 40 00 4d be r2,r0,8006bb0 <_Thread_Dispatch+0x1ac>
heir = _Thread_Heir;
8006a80: 29 cd 00 14 lw r13,(r14+20)
* This routine sets thread dispatch level to the
* value passed in.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_set_disable_level(uint32_t value)
{
_Thread_Dispatch_disable_level = value;
8006a84: 34 01 00 01 mvi r1,1
8006a88: 5a 21 00 00 sw (r17+0),r1
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
8006a8c: 31 c0 00 0c sb (r14+12),r0
_Thread_Executing = heir;
8006a90: 59 cd 00 10 sw (r14+16),r13
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
8006a94: b8 60 08 00 mv r1,r3
/*
* 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 )
8006a98: 45 8d 00 46 be r12,r13,8006bb0 <_Thread_Dispatch+0x1ac>
8006a9c: 78 15 08 02 mvhi r21,0x802
8006aa0: 78 14 08 02 mvhi r20,0x802
8006aa4: 78 13 08 02 mvhi r19,0x802
8006aa8: 78 0f 08 02 mvhi r15,0x802
#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 )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
8006aac: 78 16 08 02 mvhi r22,0x802
8006ab0: 37 98 00 40 addi r24,sp,64
8006ab4: 3a b5 08 e0 ori r21,r21,0x8e0
8006ab8: 3a 94 09 c4 ori r20,r20,0x9c4
8006abc: 3a 73 01 a0 ori r19,r19,0x1a0
8006ac0: 39 ef 01 a4 ori r15,r15,0x1a4
*/
#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 )
8006ac4: 34 12 00 01 mvi r18,1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
8006ac8: 3a d6 08 f0 ori r22,r22,0x8f0
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
8006acc: 34 17 ff fe mvi r23,-2
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
8006ad0: b9 c0 80 00 mv r16,r14
*/
#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 )
8006ad4: 29 a1 00 78 lw r1,(r13+120)
8006ad8: 44 32 00 54 be r1,r18,8006c28 <_Thread_Dispatch+0x224>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
_ISR_Enable( level );
8006adc: d0 03 00 00 wcsr IE,r3
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
8006ae0: bb 00 08 00 mv r1,r24
8006ae4: ba a0 10 00 mv r2,r21
8006ae8: fb ff f8 d7 calli 8004e44 <_TOD_Get_with_nanoseconds>
#ifdef RTEMS_SMP
_Thread_Unnest_dispatch();
#endif
_API_extensions_Run_post_switch( executing );
}
8006aec: 2b 84 00 44 lw r4,(sp+68)
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
8006af0: 29 83 00 84 lw r3,(r12+132)
8006af4: 29 88 00 80 lw r8,(r12+128)
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
8006af8: 29 c5 00 24 lw r5,(r14+36)
8006afc: 2b 86 00 40 lw r6,(sp+64)
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
8006b00: b4 83 18 00 add r3,r4,r3
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
8006b04: 29 c1 00 20 lw r1,(r14+32)
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
8006b08: f4 83 48 00 cmpgu r9,r4,r3
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
8006b0c: c8 65 28 00 sub r5,r3,r5
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
8006b10: b4 c8 40 00 add r8,r6,r8
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
8006b14: f4 a3 18 00 cmpgu r3,r5,r3
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
8006b18: b5 28 38 00 add r7,r9,r8
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
8006b1c: c8 e1 38 00 sub r7,r7,r1
8006b20: c8 e3 38 00 sub r7,r7,r3
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
8006b24: 2a 83 00 00 lw r3,(r20+0)
8006b28: 59 87 00 80 sw (r12+128),r7
8006b2c: 59 85 00 84 sw (r12+132),r5
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
8006b30: 59 c6 00 20 sw (r14+32),r6
8006b34: 59 c4 00 24 sw (r14+36),r4
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
8006b38: 44 60 00 05 be r3,r0,8006b4c <_Thread_Dispatch+0x148> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
8006b3c: 28 61 00 00 lw r1,(r3+0)
8006b40: 59 81 01 14 sw (r12+276),r1
*_Thread_libc_reent = heir->libc_reent;
8006b44: 29 a1 01 14 lw r1,(r13+276)
8006b48: 58 61 00 00 sw (r3+0),r1
#ifdef RTEMS_SMP
_Thread_Unnest_dispatch();
#endif
_API_extensions_Run_post_switch( executing );
}
8006b4c: 2a 6b 00 00 lw r11,(r19+0)
{
const Chain_Control *chain = &_User_extensions_Switches_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
8006b50: 45 6f 00 07 be r11,r15,8006b6c <_Thread_Dispatch+0x168> <== NEVER TAKEN
const User_extensions_Switch_control *extension =
(const User_extensions_Switch_control *) node;
(*extension->thread_switch)( executing, heir );
8006b54: 29 63 00 08 lw r3,(r11+8)
8006b58: b9 80 08 00 mv r1,r12
8006b5c: b9 a0 10 00 mv r2,r13
8006b60: d8 60 00 00 call r3
8006b64: 29 6b 00 00 lw r11,(r11+0)
{
const Chain_Control *chain = &_User_extensions_Switches_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
8006b68: 5d 6f ff fb bne r11,r15,8006b54 <_Thread_Dispatch+0x150>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
8006b6c: 35 81 00 c0 addi r1,r12,192
8006b70: 35 a2 00 c0 addi r2,r13,192
8006b74: f8 00 05 47 calli 8008090 <_CPU_Context_switch>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
8006b78: 29 cc 00 10 lw r12,(r14+16)
_ISR_Disable( level );
8006b7c: 90 00 18 00 rcsr r3,IE
8006b80: a0 77 20 00 and r4,r3,r23
8006b84: d0 04 00 00 wcsr IE,r4
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
8006b88: 42 04 00 0c lbu r4,(r16+12)
8006b8c: ba 00 70 00 mv r14,r16
8006b90: 20 84 00 ff andi r4,r4,0xff
8006b94: 44 80 00 06 be r4,r0,8006bac <_Thread_Dispatch+0x1a8>
heir = _Thread_Heir;
8006b98: 2a 0d 00 14 lw r13,(r16+20)
8006b9c: 5a 32 00 00 sw (r17+0),r18
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 1 );
#endif
_Thread_Dispatch_necessary = false;
8006ba0: 32 00 00 0c sb (r16+12),r0
_Thread_Executing = heir;
8006ba4: 5a 0d 00 10 sw (r16+16),r13
/*
* 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 )
8006ba8: 5d ac ff cb bne r13,r12,8006ad4 <_Thread_Dispatch+0xd0> <== ALWAYS TAKEN
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
8006bac: b8 60 08 00 mv r1,r3
8006bb0: 5a 20 00 00 sw (r17+0),r0
post_switch:
#ifndef RTEMS_SMP
_Thread_Dispatch_set_disable_level( 0 );
#endif
_ISR_Enable( level );
8006bb4: d0 01 00 00 wcsr IE,r1
#ifdef RTEMS_SMP
_Thread_Unnest_dispatch();
#endif
_API_extensions_Run_post_switch( executing );
}
8006bb8: 78 01 08 02 mvhi r1,0x802
8006bbc: 38 21 09 c8 ori r1,r1,0x9c8
8006bc0: 28 2b 00 00 lw r11,(r1+0)
{
const Chain_Control *chain = &_API_extensions_Post_switch_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
8006bc4: 78 0d 08 02 mvhi r13,0x802
8006bc8: 39 ad 09 cc ori r13,r13,0x9cc
8006bcc: 45 6d 00 06 be r11,r13,8006be4 <_Thread_Dispatch+0x1e0>
const API_extensions_Post_switch_control *post_switch =
(const API_extensions_Post_switch_control *) node;
(*post_switch->hook)( executing );
8006bd0: 29 62 00 08 lw r2,(r11+8)
8006bd4: b9 80 08 00 mv r1,r12
8006bd8: d8 40 00 00 call r2
8006bdc: 29 6b 00 00 lw r11,(r11+0)
{
const Chain_Control *chain = &_API_extensions_Post_switch_list;
const Chain_Node *tail = _Chain_Immutable_tail( chain );
const Chain_Node *node = _Chain_Immutable_first( chain );
while ( node != tail ) {
8006be0: 5d 6d ff fc bne r11,r13,8006bd0 <_Thread_Dispatch+0x1cc> <== NEVER TAKEN
8006be4: 2b 9d 00 04 lw ra,(sp+4)
8006be8: 2b 8b 00 3c lw r11,(sp+60)
8006bec: 2b 8c 00 38 lw r12,(sp+56)
8006bf0: 2b 8d 00 34 lw r13,(sp+52)
8006bf4: 2b 8e 00 30 lw r14,(sp+48)
8006bf8: 2b 8f 00 2c lw r15,(sp+44)
8006bfc: 2b 90 00 28 lw r16,(sp+40)
8006c00: 2b 91 00 24 lw r17,(sp+36)
8006c04: 2b 92 00 20 lw r18,(sp+32)
8006c08: 2b 93 00 1c lw r19,(sp+28)
8006c0c: 2b 94 00 18 lw r20,(sp+24)
8006c10: 2b 95 00 14 lw r21,(sp+20)
8006c14: 2b 96 00 10 lw r22,(sp+16)
8006c18: 2b 97 00 0c lw r23,(sp+12)
8006c1c: 2b 98 00 08 lw r24,(sp+8)
8006c20: 37 9c 00 44 addi sp,sp,68
8006c24: c3 a0 00 00 ret
#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 )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
8006c28: 2a c1 00 00 lw r1,(r22+0)
8006c2c: 59 a1 00 74 sw (r13+116),r1
8006c30: e3 ff ff ab bi 8006adc <_Thread_Dispatch+0xd8>
0800cfb4 <_Thread_Handler>:
#define INIT_NAME __main
#define EXECUTE_GLOBAL_CONSTRUCTORS
#endif
void _Thread_Handler( void )
{
800cfb4: 37 9c ff f4 addi sp,sp,-12
800cfb8: 5b 8b 00 0c sw (sp+12),r11
800cfbc: 5b 8c 00 08 sw (sp+8),r12
800cfc0: 5b 9d 00 04 sw (sp+4),ra
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
800cfc4: 78 01 08 02 mvhi r1,0x802
800cfc8: 38 21 0d e0 ori r1,r1,0xde0
800cfcc: 28 2b 00 10 lw r11,(r1+16)
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
800cfd0: 29 61 00 a8 lw r1,(r11+168)
_ISR_Set_level(level);
800cfd4: 64 21 00 00 cmpei r1,r1,0
800cfd8: d0 01 00 00 wcsr IE,r1
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
800cfdc: 78 03 08 02 mvhi r3,0x802
800cfe0: 38 63 07 a8 ori r3,r3,0x7a8
800cfe4: 40 6c 00 00 lbu r12,(r3+0)
doneConstructors = true;
800cfe8: 34 04 00 01 mvi r4,1
);
}
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{
_User_extensions_Iterate(
800cfec: 78 02 08 00 mvhi r2,0x800
800cff0: b9 60 08 00 mv r1,r11
800cff4: 38 42 79 78 ori r2,r2,0x7978
800cff8: 30 64 00 00 sb (r3+0),r4
800cffc: fb ff ea 7b calli 80079e8 <_User_extensions_Iterate>
_User_extensions_Thread_begin( executing );
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
800d000: fb ff e7 0d calli 8006c34 <_Thread_Enable_dispatch>
/*
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (doCons) /* && (volatile void *)_init) */ {
800d004: 45 80 00 0d be r12,r0,800d038 <_Thread_Handler+0x84>
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
800d008: 29 61 00 90 lw r1,(r11+144)
800d00c: 44 20 00 0e be r1,r0,800d044 <_Thread_Handler+0x90>
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
800d010: 34 02 00 01 mvi r2,1
800d014: 44 22 00 11 be r1,r2,800d058 <_Thread_Handler+0xa4> <== ALWAYS TAKEN
}
}
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{
_User_extensions_Iterate(
800d018: 78 02 08 00 mvhi r2,0x800
800d01c: b9 60 08 00 mv r1,r11
800d020: 38 42 79 98 ori r2,r2,0x7998
800d024: fb ff ea 71 calli 80079e8 <_User_extensions_Iterate>
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
_Internal_error_Occurred(
800d028: 34 01 00 00 mvi r1,0
800d02c: 34 02 00 01 mvi r2,1
800d030: 34 03 00 05 mvi r3,5
800d034: fb ff e1 1a calli 800549c <_Internal_error_Occurred>
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (doCons) /* && (volatile void *)_init) */ {
INIT_NAME ();
800d038: fb ff cb f2 calli 8000000 <RamBase>
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
800d03c: 29 61 00 90 lw r1,(r11+144)
800d040: 5c 20 ff f4 bne r1,r0,800d010 <_Thread_Handler+0x5c>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
800d044: 29 62 00 8c lw r2,(r11+140)
800d048: 29 61 00 98 lw r1,(r11+152)
800d04c: d8 40 00 00 call r2
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
800d050: 59 61 00 28 sw (r11+40),r1
800d054: e3 ff ff f1 bi 800d018 <_Thread_Handler+0x64>
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
800d058: 29 62 00 8c lw r2,(r11+140)
800d05c: 29 61 00 94 lw r1,(r11+148)
800d060: d8 40 00 00 call r2
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
800d064: 59 61 00 28 sw (r11+40),r1
800d068: e3 ff ff ec bi 800d018 <_Thread_Handler+0x64>
08006fbc <_Thread_Handler_initialization>:
#if defined(RTEMS_SMP)
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
8006fbc: 37 9c ff f4 addi sp,sp,-12
8006fc0: 5b 8b 00 0c sw (sp+12),r11
8006fc4: 5b 8c 00 08 sw (sp+8),r12
8006fc8: 5b 9d 00 04 sw (sp+4),ra
uint32_t ticks_per_timeslice =
8006fcc: 78 01 08 01 mvhi r1,0x801
8006fd0: 38 21 d2 6c ori r1,r1,0xd26c
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
8006fd4: 28 23 00 28 lw r3,(r1+40)
#include <rtems/bspsmp.h>
#endif
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
8006fd8: 28 2b 00 14 lw r11,(r1+20)
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
8006fdc: 28 2c 00 08 lw r12,(r1+8)
rtems_configuration_get_maximum_extensions();
rtems_stack_allocate_init_hook stack_allocate_init_hook =
8006fe0: 28 22 00 24 lw r2,(r1+36)
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
8006fe4: 44 60 00 1f be r3,r0,8007060 <_Thread_Handler_initialization+0xa4><== NEVER TAKEN
8006fe8: 28 23 00 2c lw r3,(r1+44)
8006fec: 44 60 00 1d be r3,r0,8007060 <_Thread_Handler_initialization+0xa4>
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
8006ff0: 44 40 00 03 be r2,r0,8006ffc <_Thread_Handler_initialization+0x40>
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
8006ff4: 28 21 00 04 lw r1,(r1+4)
8006ff8: d8 40 00 00 call r2
_Thread_Dispatch_necessary = false;
8006ffc: 78 08 08 02 mvhi r8,0x802
8007000: 39 08 0d e0 ori r8,r8,0xde0
_Thread_Heir = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
8007004: 78 0a 08 02 mvhi r10,0x802
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
8007008: 78 09 08 02 mvhi r9,0x802
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
800700c: 78 01 08 02 mvhi r1,0x802
);
if ( stack_allocate_init_hook != NULL )
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
_Thread_Dispatch_necessary = false;
8007010: 31 00 00 0c sb (r8+12),r0
_Thread_Executing = NULL;
8007014: 59 00 00 10 sw (r8+16),r0
_Thread_Heir = NULL;
8007018: 59 00 00 14 sw (r8+20),r0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
800701c: 39 4a 09 d4 ori r10,r10,0x9d4
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
8007020: 39 29 08 f0 ori r9,r9,0x8f0
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
8007024: 38 21 0a 48 ori r1,r1,0xa48
8007028: 34 02 00 01 mvi r2,1
800702c: 34 03 00 01 mvi r3,1
8007030: 34 04 00 01 mvi r4,1
8007034: 34 05 01 28 mvi r5,296
8007038: 34 06 00 00 mvi r6,0
800703c: 34 07 00 08 mvi r7,8
_Thread_Heir = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
8007040: 59 4c 00 00 sw (r10+0),r12
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
8007044: 59 2b 00 00 sw (r9+0),r11
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
8007048: fb ff fa fb calli 8005c34 <_Objects_Initialize_information>
false, /* true if this is a global object class */
NULL /* Proxy extraction support callout */
#endif
);
}
800704c: 2b 9d 00 04 lw ra,(sp+4)
8007050: 2b 8b 00 0c lw r11,(sp+12)
8007054: 2b 8c 00 08 lw r12,(sp+8)
8007058: 37 9c 00 0c addi sp,sp,12
800705c: c3 a0 00 00 ret
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
8007060: 34 01 00 00 mvi r1,0
8007064: 34 02 00 01 mvi r2,1
8007068: 34 03 00 0e mvi r3,14
800706c: fb ff f9 0c calli 800549c <_Internal_error_Occurred>
080077f4 <_Thread_Stack_Free>:
#include <rtems/config.h>
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
80077f4: 37 9c ff fc addi sp,sp,-4
80077f8: 5b 9d 00 04 sw (sp+4),ra
#if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
80077fc: 40 23 00 b0 lbu r3,(r1+176)
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
8007800: 78 02 08 01 mvhi r2,0x801
8007804: 38 42 d2 6c ori r2,r2,0xd26c
8007808: 28 42 00 2c lw r2,(r2+44)
#if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
800780c: 44 60 00 03 be r3,r0,8007818 <_Thread_Stack_Free+0x24> <== NEVER TAKEN
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
(*stack_free_hook)( the_thread->Start.Initial_stack.area );
8007810: 28 21 00 b8 lw r1,(r1+184)
8007814: d8 40 00 00 call r2
}
8007818: 2b 9d 00 04 lw ra,(sp+4)
800781c: 37 9c 00 04 addi sp,sp,4
8007820: c3 a0 00 00 ret
0800afb8 <_Thread_blocking_operation_Cancel>:
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
800afb8: 37 9c ff f8 addi sp,sp,-8
800afbc: 5b 8b 00 08 sw (sp+8),r11
800afc0: 5b 9d 00 04 sw (sp+4),ra
800afc4: b8 40 58 00 mv r11,r2
/*
* 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 ) ) {
800afc8: 28 42 00 50 lw r2,(r2+80)
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
800afcc: 59 60 00 44 sw (r11+68),r0
/*
* 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 ) ) {
800afd0: 34 01 00 02 mvi r1,2
800afd4: 44 41 00 0b be r2,r1,800b000 <_Thread_blocking_operation_Cancel+0x48><== NEVER TAKEN
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
} else
_ISR_Enable( level );
800afd8: d0 03 00 00 wcsr IE,r3
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
800afdc: 78 01 08 01 mvhi r1,0x801
800afe0: 38 21 dc 0c ori r1,r1,0xdc0c
800afe4: 28 22 00 00 lw r2,(r1+0)
800afe8: b9 60 08 00 mv r1,r11
800afec: f8 00 00 0b calli 800b018 <_Thread_Clear_state>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
800aff0: 2b 9d 00 04 lw ra,(sp+4)
800aff4: 2b 8b 00 08 lw r11,(sp+8)
800aff8: 37 9c 00 08 addi sp,sp,8
800affc: c3 a0 00 00 ret
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
800b000: 34 01 00 03 mvi r1,3 <== NOT EXECUTED
800b004: 59 61 00 50 sw (r11+80),r1 <== NOT EXECUTED
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
800b008: d0 03 00 00 wcsr IE,r3 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
800b00c: 35 61 00 48 addi r1,r11,72 <== NOT EXECUTED
800b010: fb ff f3 30 calli 8007cd0 <_Watchdog_Remove> <== NOT EXECUTED
800b014: e3 ff ff f2 bi 800afdc <_Thread_blocking_operation_Cancel+0x24><== NOT EXECUTED
08007070 <_Thread_queue_Dequeue>:
#include <rtems/score/tqdata.h>
Thread_Control *_Thread_queue_Dequeue(
Thread_queue_Control *the_thread_queue
)
{
8007070: 37 9c ff f8 addi sp,sp,-8
8007074: 5b 8b 00 08 sw (sp+8),r11
8007078: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *(*dequeue_p)( Thread_queue_Control * );
Thread_Control *the_thread;
ISR_Level level;
Thread_blocking_operation_States sync_state;
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
800707c: 28 23 00 34 lw r3,(r1+52)
#include <rtems/score/tqdata.h>
Thread_Control *_Thread_queue_Dequeue(
Thread_queue_Control *the_thread_queue
)
{
8007080: b8 20 58 00 mv r11,r1
Thread_blocking_operation_States sync_state;
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
dequeue_p = _Thread_queue_Dequeue_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
dequeue_p = _Thread_queue_Dequeue_fifo;
8007084: 78 02 08 00 mvhi r2,0x800
Thread_Control *(*dequeue_p)( Thread_queue_Control * );
Thread_Control *the_thread;
ISR_Level level;
Thread_blocking_operation_States sync_state;
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
8007088: 34 01 00 01 mvi r1,1
dequeue_p = _Thread_queue_Dequeue_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
dequeue_p = _Thread_queue_Dequeue_fifo;
800708c: 38 42 b0 d4 ori r2,r2,0xb0d4
Thread_Control *(*dequeue_p)( Thread_queue_Control * );
Thread_Control *the_thread;
ISR_Level level;
Thread_blocking_operation_States sync_state;
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
8007090: 44 61 00 0d be r3,r1,80070c4 <_Thread_queue_Dequeue+0x54>
dequeue_p = _Thread_queue_Dequeue_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
dequeue_p = _Thread_queue_Dequeue_fifo;
the_thread = (*dequeue_p)( the_thread_queue );
8007094: b9 60 08 00 mv r1,r11
8007098: d8 40 00 00 call r2
_ISR_Disable( level );
800709c: 90 00 10 00 rcsr r2,IE
80070a0: 34 03 ff fe mvi r3,-2
80070a4: a0 43 18 00 and r3,r2,r3
80070a8: d0 03 00 00 wcsr IE,r3
if ( !the_thread ) {
80070ac: 44 20 00 0f be r1,r0,80070e8 <_Thread_queue_Dequeue+0x78>
(sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
the_thread = _Thread_Executing;
}
}
_ISR_Enable( level );
80070b0: d0 02 00 00 wcsr IE,r2
return the_thread;
}
80070b4: 2b 9d 00 04 lw ra,(sp+4)
80070b8: 2b 8b 00 08 lw r11,(sp+8)
80070bc: 37 9c 00 08 addi sp,sp,8
80070c0: c3 a0 00 00 ret
Thread_Control *the_thread;
ISR_Level level;
Thread_blocking_operation_States sync_state;
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
dequeue_p = _Thread_queue_Dequeue_priority;
80070c4: 78 02 08 00 mvhi r2,0x800
80070c8: 38 42 71 10 ori r2,r2,0x7110
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
dequeue_p = _Thread_queue_Dequeue_fifo;
the_thread = (*dequeue_p)( the_thread_queue );
80070cc: b9 60 08 00 mv r1,r11
80070d0: d8 40 00 00 call r2
_ISR_Disable( level );
80070d4: 90 00 10 00 rcsr r2,IE
80070d8: 34 03 ff fe mvi r3,-2
80070dc: a0 43 18 00 and r3,r2,r3
80070e0: d0 03 00 00 wcsr IE,r3
if ( !the_thread ) {
80070e4: 5c 20 ff f3 bne r1,r0,80070b0 <_Thread_queue_Dequeue+0x40>
sync_state = the_thread_queue->sync_state;
if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
80070e8: 29 64 00 30 lw r4,(r11+48)
80070ec: 34 03 00 01 mvi r3,1
80070f0: 34 84 ff ff addi r4,r4,-1
80070f4: 54 83 ff ef bgu r4,r3,80070b0 <_Thread_queue_Dequeue+0x40> <== ALWAYS TAKEN
(sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
the_thread = _Thread_Executing;
80070f8: 78 01 08 02 mvhi r1,0x802 <== NOT EXECUTED
80070fc: 38 21 0d e0 ori r1,r1,0xde0 <== NOT EXECUTED
_ISR_Disable( level );
if ( !the_thread ) {
sync_state = the_thread_queue->sync_state;
if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
8007100: 34 03 00 03 mvi r3,3 <== NOT EXECUTED
the_thread = _Thread_Executing;
8007104: 28 21 00 10 lw r1,(r1+16) <== NOT EXECUTED
_ISR_Disable( level );
if ( !the_thread ) {
sync_state = the_thread_queue->sync_state;
if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
8007108: 59 63 00 30 sw (r11+48),r3 <== NOT EXECUTED
800710c: e3 ff ff e9 bi 80070b0 <_Thread_queue_Dequeue+0x40> <== NOT EXECUTED
0800731c <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
800731c: 37 9c ff f4 addi sp,sp,-12
8007320: 5b 8b 00 0c sw (sp+12),r11
8007324: 5b 8c 00 08 sw (sp+8),r12
8007328: 5b 8d 00 04 sw (sp+4),r13
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
800732c: 28 45 00 14 lw r5,(r2+20)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
8007330: 34 47 00 3c addi r7,r2,60
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
8007334: 34 46 00 38 addi r6,r2,56
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
8007338: 00 a4 00 01 srui r4,r5,1
800733c: 78 0c 08 02 mvhi r12,0x802
8007340: 00 84 00 01 srui r4,r4,1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8007344: 58 47 00 38 sw (r2+56),r7
8007348: 00 84 00 01 srui r4,r4,1
head->previous = NULL;
tail->previous = head;
800734c: 58 46 00 40 sw (r2+64),r6
8007350: 00 84 00 01 srui r4,r4,1
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
8007354: 58 40 00 3c sw (r2+60),r0
8007358: 00 84 00 01 srui r4,r4,1
RTEMS_INLINE_ROUTINE bool _Thread_queue_Is_reverse_search (
Priority_Control the_priority
)
{
return ( the_priority & TASK_QUEUE_DATA_REVERSE_SEARCH_MASK );
800735c: 20 a8 00 20 andi r8,r5,0x20
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
8007360: 00 84 00 01 srui r4,r4,1
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
8007364: 28 27 00 38 lw r7,(r1+56)
8007368: b4 84 30 00 add r6,r4,r4
800736c: 39 8c 00 d8 ori r12,r12,0xd8
if ( _Thread_queue_Is_reverse_search( priority ) )
8007370: 5d 00 00 18 bne r8,r0,80073d0 <_Thread_queue_Enqueue_priority+0xb4>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
8007374: b4 c4 20 00 add r4,r6,r4
8007378: b4 84 20 00 add r4,r4,r4
800737c: b4 84 20 00 add r4,r4,r4
8007380: b4 24 60 00 add r12,r1,r4
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
8007384: 34 0d ff fe mvi r13,-2
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
8007388: 35 8b 00 04 addi r11,r12,4
800738c: 90 00 40 00 rcsr r8,IE
8007390: a1 0d 50 00 and r10,r8,r13
8007394: d0 0a 00 00 wcsr IE,r10
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
8007398: 29 84 00 00 lw r4,(r12+0)
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
800739c: 5c 8b 00 04 bne r4,r11,80073ac <_Thread_queue_Enqueue_priority+0x90>
80073a0: e0 00 00 24 bi 8007430 <_Thread_queue_Enqueue_priority+0x114>
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
80073a4: 28 84 00 00 lw r4,(r4+0)
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
80073a8: 44 8b 00 23 be r4,r11,8007434 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
80073ac: 28 86 00 14 lw r6,(r4+20)
if ( priority <= search_priority )
80073b0: 50 c5 00 21 bgeu r6,r5,8007434 <_Thread_queue_Enqueue_priority+0x118>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
80073b4: d0 08 00 00 wcsr IE,r8
80073b8: d0 0a 00 00 wcsr IE,r10
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
80073bc: 28 89 00 10 lw r9,(r4+16)
80073c0: a0 e9 48 00 and r9,r7,r9
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
80073c4: 5d 20 ff f8 bne r9,r0,80073a4 <_Thread_queue_Enqueue_priority+0x88>
_ISR_Enable( level );
80073c8: d0 08 00 00 wcsr IE,r8
goto restart_forward_search;
80073cc: e3 ff ff f0 bi 800738c <_Thread_queue_Enqueue_priority+0x70>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
80073d0: b4 c4 20 00 add r4,r6,r4
80073d4: b4 84 20 00 add r4,r4,r4
80073d8: b4 84 20 00 add r4,r4,r4
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
80073dc: 34 0d ff fe mvi r13,-2
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
80073e0: b4 24 50 00 add r10,r1,r4
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
80073e4: 41 86 00 00 lbu r6,(r12+0)
80073e8: 34 c6 00 01 addi r6,r6,1
_ISR_Disable( level );
80073ec: 90 00 40 00 rcsr r8,IE
80073f0: a1 0d 58 00 and r11,r8,r13
80073f4: d0 0b 00 00 wcsr IE,r11
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
80073f8: 29 44 00 08 lw r4,(r10+8)
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
80073fc: 5c 8a 00 04 bne r4,r10,800740c <_Thread_queue_Enqueue_priority+0xf0>
8007400: e0 00 00 18 bi 8007460 <_Thread_queue_Enqueue_priority+0x144>
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
8007404: 28 84 00 04 lw r4,(r4+4)
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
8007408: 44 8a 00 16 be r4,r10,8007460 <_Thread_queue_Enqueue_priority+0x144>
search_priority = search_thread->current_priority;
800740c: 28 86 00 14 lw r6,(r4+20)
if ( priority >= search_priority )
8007410: 50 a6 00 14 bgeu r5,r6,8007460 <_Thread_queue_Enqueue_priority+0x144>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
8007414: d0 08 00 00 wcsr IE,r8
8007418: d0 0b 00 00 wcsr IE,r11
800741c: 28 89 00 10 lw r9,(r4+16)
8007420: a0 e9 48 00 and r9,r7,r9
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
8007424: 5d 20 ff f8 bne r9,r0,8007404 <_Thread_queue_Enqueue_priority+0xe8>
_ISR_Enable( level );
8007428: d0 08 00 00 wcsr IE,r8
goto restart_reverse_search;
800742c: e3 ff ff ee bi 80073e4 <_Thread_queue_Enqueue_priority+0xc8>
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
8007430: 34 06 ff ff mvi r6,-1
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
8007434: 28 27 00 30 lw r7,(r1+48)
8007438: 34 0a 00 01 mvi r10,1
800743c: b9 00 48 00 mv r9,r8
8007440: 44 ea 00 1b be r7,r10,80074ac <_Thread_queue_Enqueue_priority+0x190><== ALWAYS TAKEN
* For example, the blocking thread could have been given
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
8007444: 58 69 00 00 sw (r3+0),r9 <== NOT EXECUTED
return the_thread_queue->sync_state;
}
8007448: b8 e0 08 00 mv r1,r7
800744c: 2b 8b 00 0c lw r11,(sp+12)
8007450: 2b 8c 00 08 lw r12,(sp+8)
8007454: 2b 8d 00 04 lw r13,(sp+4)
8007458: 37 9c 00 0c addi sp,sp,12
800745c: c3 a0 00 00 ret
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
8007460: 28 27 00 30 lw r7,(r1+48)
8007464: 34 0a 00 01 mvi r10,1
8007468: b9 00 48 00 mv r9,r8
800746c: 5c ea ff f6 bne r7,r10,8007444 <_Thread_queue_Enqueue_priority+0x128><== NEVER TAKEN
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
8007470: 58 20 00 30 sw (r1+48),r0
if ( priority == search_priority )
8007474: 44 a6 00 1d be r5,r6,80074e8 <_Thread_queue_Enqueue_priority+0x1cc>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
8007478: 28 83 00 00 lw r3,(r4+0)
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
800747c: 58 44 00 04 sw (r2+4),r4
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
8007480: 58 43 00 00 sw (r2+0),r3
the_node->previous = search_node;
search_node->next = the_node;
8007484: 58 82 00 00 sw (r4+0),r2
next_node->previous = the_node;
8007488: 58 62 00 04 sw (r3+4),r2
the_thread->Wait.queue = the_thread_queue;
800748c: 58 41 00 44 sw (r2+68),r1
_ISR_Enable( level );
8007490: d0 08 00 00 wcsr IE,r8
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
8007494: b8 e0 08 00 mv r1,r7
8007498: 2b 8b 00 0c lw r11,(sp+12)
800749c: 2b 8c 00 08 lw r12,(sp+8)
80074a0: 2b 8d 00 04 lw r13,(sp+4)
80074a4: 37 9c 00 0c addi sp,sp,12
80074a8: c3 a0 00 00 ret
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
80074ac: 58 20 00 30 sw (r1+48),r0
if ( priority == search_priority )
80074b0: 44 a6 00 0e be r5,r6,80074e8 <_Thread_queue_Enqueue_priority+0x1cc>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
80074b4: 28 83 00 04 lw r3,(r4+4)
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
80074b8: 58 44 00 00 sw (r2+0),r4
the_node->previous = previous_node;
80074bc: 58 43 00 04 sw (r2+4),r3
previous_node->next = the_node;
80074c0: 58 62 00 00 sw (r3+0),r2
search_node->previous = the_node;
80074c4: 58 82 00 04 sw (r4+4),r2
the_thread->Wait.queue = the_thread_queue;
80074c8: 58 41 00 44 sw (r2+68),r1
_ISR_Enable( level );
80074cc: d0 08 00 00 wcsr IE,r8
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
80074d0: b8 e0 08 00 mv r1,r7
80074d4: 2b 8b 00 0c lw r11,(sp+12)
80074d8: 2b 8c 00 08 lw r12,(sp+8)
80074dc: 2b 8d 00 04 lw r13,(sp+4)
80074e0: 37 9c 00 0c addi sp,sp,12
80074e4: c3 a0 00 00 ret
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
80074e8: 28 83 00 40 lw r3,(r4+64)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
80074ec: 34 85 00 3c addi r5,r4,60
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
80074f0: 58 45 00 00 sw (r2+0),r5
the_node->previous = previous_node;
80074f4: 58 43 00 04 sw (r2+4),r3
previous_node->next = the_node;
80074f8: 58 62 00 00 sw (r3+0),r2
search_node->previous = the_node;
80074fc: 58 82 00 40 sw (r4+64),r2
the_thread->Wait.queue = the_thread_queue;
8007500: 58 41 00 44 sw (r2+68),r1
_ISR_Enable( level );
8007504: d0 08 00 00 wcsr IE,r8
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8007508: 34 07 00 01 mvi r7,1
800750c: e3 ff ff cf bi 8007448 <_Thread_queue_Enqueue_priority+0x12c>
0800b32c <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
800b32c: 37 9c ff fc addi sp,sp,-4
800b330: 5b 9d 00 04 sw (sp+4),ra
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
800b334: 28 23 00 44 lw r3,(r1+68)
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
800b338: b8 20 20 00 mv r4,r1
* 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 &&
800b33c: 28 62 00 30 lw r2,(r3+48)
800b340: 44 40 00 05 be r2,r0,800b354 <_Thread_queue_Process_timeout+0x28>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
800b344: 78 01 08 02 mvhi r1,0x802
800b348: 38 21 0d e0 ori r1,r1,0xde0
800b34c: 28 21 00 10 lw r1,(r1+16)
800b350: 44 81 00 09 be r4,r1,800b374 <_Thread_queue_Process_timeout+0x48>
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
800b354: 28 65 00 3c lw r5,(r3+60)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
800b358: b8 60 08 00 mv r1,r3
800b35c: b8 80 10 00 mv r2,r4
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
800b360: 58 85 00 34 sw (r4+52),r5
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
800b364: fb ff ff a4 calli 800b1f4 <_Thread_queue_Extract>
}
}
800b368: 2b 9d 00 04 lw ra,(sp+4)
800b36c: 37 9c 00 04 addi sp,sp,4
800b370: c3 a0 00 00 ret
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
800b374: 34 01 00 03 mvi r1,3
800b378: 44 41 ff fc be r2,r1,800b368 <_Thread_queue_Process_timeout+0x3c><== NEVER TAKEN
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
800b37c: 28 61 00 3c lw r1,(r3+60)
800b380: 58 81 00 34 sw (r4+52),r1
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
800b384: 34 01 00 02 mvi r1,2
800b388: 58 61 00 30 sw (r3+48),r1
800b38c: e3 ff ff f7 bi 800b368 <_Thread_queue_Process_timeout+0x3c>
080075bc <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
80075bc: 37 9c ff ec addi sp,sp,-20
80075c0: 5b 8b 00 10 sw (sp+16),r11
80075c4: 5b 8c 00 0c sw (sp+12),r12
80075c8: 5b 8d 00 08 sw (sp+8),r13
80075cc: 5b 9d 00 04 sw (sp+4),ra
80075d0: b8 20 58 00 mv r11,r1
80075d4: b8 40 60 00 mv r12,r2
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
80075d8: 44 20 00 04 be r1,r0,80075e8 <_Thread_queue_Requeue+0x2c> <== 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 ) {
80075dc: 28 22 00 34 lw r2,(r1+52)
80075e0: 34 01 00 01 mvi r1,1
80075e4: 44 41 00 07 be r2,r1,8007600 <_Thread_queue_Requeue+0x44> <== ALWAYS TAKEN
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
80075e8: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80075ec: 2b 8b 00 10 lw r11,(sp+16) <== NOT EXECUTED
80075f0: 2b 8c 00 0c lw r12,(sp+12) <== NOT EXECUTED
80075f4: 2b 8d 00 08 lw r13,(sp+8) <== NOT EXECUTED
80075f8: 37 9c 00 14 addi sp,sp,20 <== NOT EXECUTED
80075fc: c3 a0 00 00 ret <== NOT EXECUTED
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
8007600: 90 00 68 00 rcsr r13,IE
8007604: 34 01 ff fe mvi r1,-2
8007608: a1 a1 08 00 and r1,r13,r1
800760c: d0 01 00 00 wcsr IE,r1
8007610: 78 03 08 01 mvhi r3,0x801
8007614: 38 63 dc 04 ori r3,r3,0xdc04
8007618: 29 82 00 10 lw r2,(r12+16)
800761c: 28 61 00 00 lw r1,(r3+0)
8007620: a0 41 08 00 and r1,r2,r1
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
8007624: 5c 20 00 08 bne r1,r0,8007644 <_Thread_queue_Requeue+0x88> <== ALWAYS TAKEN
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
8007628: d0 0d 00 00 wcsr IE,r13 <== NOT EXECUTED
}
}
800762c: 2b 9d 00 04 lw ra,(sp+4)
8007630: 2b 8b 00 10 lw r11,(sp+16)
8007634: 2b 8c 00 0c lw r12,(sp+12)
8007638: 2b 8d 00 08 lw r13,(sp+8)
800763c: 37 9c 00 14 addi sp,sp,20
8007640: c3 a0 00 00 ret
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;
8007644: 34 01 00 01 mvi r1,1
8007648: 59 61 00 30 sw (r11+48),r1
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
800764c: b9 80 10 00 mv r2,r12
8007650: b9 60 08 00 mv r1,r11
8007654: 34 03 00 01 mvi r3,1
8007658: f8 00 0e f5 calli 800b22c <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
800765c: b9 60 08 00 mv r1,r11
8007660: b9 80 10 00 mv r2,r12
8007664: 37 83 00 14 addi r3,sp,20
8007668: fb ff ff 2d calli 800731c <_Thread_queue_Enqueue_priority>
}
_ISR_Enable( level );
800766c: d0 0d 00 00 wcsr IE,r13
8007670: e3 ff ff ef bi 800762c <_Thread_queue_Requeue+0x70>
08007674 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
8007674: 37 9c ff f8 addi sp,sp,-8
8007678: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
800767c: 37 82 00 08 addi r2,sp,8
8007680: fb ff fd 79 calli 8006c64 <_Thread_Get>
switch ( location ) {
8007684: 2b 82 00 08 lw r2,(sp+8)
8007688: 5c 40 00 07 bne r2,r0,80076a4 <_Thread_queue_Timeout+0x30> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
800768c: f8 00 0f 28 calli 800b32c <_Thread_queue_Process_timeout>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8007690: 78 01 08 02 mvhi r1,0x802
8007694: 38 21 09 58 ori r1,r1,0x958
8007698: 28 22 00 00 lw r2,(r1+0)
--level;
800769c: 34 42 ff ff addi r2,r2,-1
_Thread_Dispatch_disable_level = level;
80076a0: 58 22 00 00 sw (r1+0),r2
_Thread_Unnest_dispatch();
break;
}
}
80076a4: 2b 9d 00 04 lw ra,(sp+4)
80076a8: 37 9c 00 08 addi sp,sp,8
80076ac: c3 a0 00 00 ret
080159cc <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
80159cc: 37 9c ff a4 addi sp,sp,-92
80159d0: 5b 8b 00 44 sw (sp+68),r11
80159d4: 5b 8c 00 40 sw (sp+64),r12
80159d8: 5b 8d 00 3c sw (sp+60),r13
80159dc: 5b 8e 00 38 sw (sp+56),r14
80159e0: 5b 8f 00 34 sw (sp+52),r15
80159e4: 5b 90 00 30 sw (sp+48),r16
80159e8: 5b 91 00 2c sw (sp+44),r17
80159ec: 5b 92 00 28 sw (sp+40),r18
80159f0: 5b 93 00 24 sw (sp+36),r19
80159f4: 5b 94 00 20 sw (sp+32),r20
80159f8: 5b 95 00 1c sw (sp+28),r21
80159fc: 5b 96 00 18 sw (sp+24),r22
8015a00: 5b 97 00 14 sw (sp+20),r23
8015a04: 5b 98 00 10 sw (sp+16),r24
8015a08: 5b 99 00 0c sw (sp+12),r25
8015a0c: 5b 9b 00 08 sw (sp+8),fp
8015a10: 5b 9d 00 04 sw (sp+4),ra
8015a14: 78 13 08 03 mvhi r19,0x803
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8015a18: 37 96 00 54 addi r22,sp,84
8015a1c: 37 95 00 58 addi r21,sp,88
8015a20: 37 8f 00 48 addi r15,sp,72
8015a24: 37 94 00 4c addi r20,sp,76
8015a28: 78 0e 08 03 mvhi r14,0x803
8015a2c: 78 17 08 03 mvhi r23,0x803
8015a30: b8 20 58 00 mv r11,r1
8015a34: 5b 95 00 54 sw (sp+84),r21
head->previous = NULL;
8015a38: 5b 80 00 58 sw (sp+88),r0
tail->previous = head;
8015a3c: 5b 96 00 5c sw (sp+92),r22
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8015a40: 5b 94 00 48 sw (sp+72),r20
head->previous = NULL;
8015a44: 5b 80 00 4c sw (sp+76),r0
tail->previous = head;
8015a48: 5b 8f 00 50 sw (sp+80),r15
8015a4c: 3a 73 fe 38 ori r19,r19,0xfe38
8015a50: 34 31 00 30 addi r17,r1,48
8015a54: 39 ce fc d0 ori r14,r14,0xfcd0
8015a58: 34 30 00 68 addi r16,r1,104
8015a5c: 3a f7 fd 50 ori r23,r23,0xfd50
8015a60: 34 3b 00 08 addi fp,r1,8
8015a64: 34 39 00 40 addi r25,r1,64
Timer_Control *timer
)
{
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 ) {
8015a68: 34 0d 00 03 mvi r13,3
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
8015a6c: 34 12 ff fe mvi r18,-2
_Thread_Set_state( ts->thread, STATES_DELAYING );
_Timer_server_Reset_interval_system_watchdog( ts );
_Timer_server_Reset_tod_system_watchdog( ts );
_Thread_Enable_dispatch();
ts->active = true;
8015a70: 34 18 00 01 mvi r24,1
{
/*
* 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;
8015a74: 59 76 00 78 sw (r11+120),r22
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
8015a78: 2a 64 00 00 lw r4,(r19+0)
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
8015a7c: 29 62 00 3c lw r2,(r11+60)
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
8015a80: ba 20 08 00 mv r1,r17
8015a84: b9 e0 18 00 mv r3,r15
8015a88: c8 82 10 00 sub r2,r4,r2
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
8015a8c: 59 64 00 3c sw (r11+60),r4
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
8015a90: f8 00 15 40 calli 801af90 <_Watchdog_Adjust_to_chain>
8015a94: 78 03 08 03 mvhi r3,0x803
8015a98: 38 63 90 8c ori r3,r3,0x908c
8015a9c: 28 64 00 00 lw r4,(r3+0)
8015aa0: 29 c1 00 00 lw r1,(r14+0)
8015aa4: 29 c2 00 04 lw r2,(r14+4)
8015aa8: 34 03 00 00 mvi r3,0
8015aac: f8 00 56 d6 calli 802b604 <__divdi3>
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
8015ab0: 29 64 00 74 lw r4,(r11+116)
8015ab4: b8 40 60 00 mv r12,r2
/*
* 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 ) {
8015ab8: 50 82 00 1c bgeu r4,r2,8015b28 <_Timer_server_Body+0x15c>
/*
* 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 );
8015abc: ba 00 08 00 mv r1,r16
8015ac0: c8 44 10 00 sub r2,r2,r4
8015ac4: b9 e0 18 00 mv r3,r15
8015ac8: f8 00 15 32 calli 801af90 <_Watchdog_Adjust_to_chain>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
8015acc: 59 6c 00 74 sw (r11+116),r12
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
8015ad0: 34 0c 00 01 mvi r12,1
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
8015ad4: 29 61 00 78 lw r1,(r11+120)
8015ad8: f8 00 03 5c calli 8016848 <_Chain_Get>
8015adc: b8 20 10 00 mv r2,r1
if ( timer == NULL ) {
8015ae0: 44 20 00 0b be r1,r0,8015b0c <_Timer_server_Body+0x140>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
8015ae4: 28 24 00 38 lw r4,(r1+56)
8015ae8: 44 8c 00 16 be r4,r12,8015b40 <_Timer_server_Body+0x174>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
8015aec: 5c 8d ff fa bne r4,r13,8015ad4 <_Timer_server_Body+0x108> <== NEVER TAKEN
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
8015af0: 34 42 00 10 addi r2,r2,16
8015af4: ba 00 08 00 mv r1,r16
8015af8: f8 00 15 4a calli 801b020 <_Watchdog_Insert>
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
8015afc: 29 61 00 78 lw r1,(r11+120)
8015b00: f8 00 03 52 calli 8016848 <_Chain_Get>
8015b04: b8 20 10 00 mv r2,r1
if ( timer == NULL ) {
8015b08: 5c 20 ff f7 bne r1,r0,8015ae4 <_Timer_server_Body+0x118> <== NEVER TAKEN
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
8015b0c: 90 00 10 00 rcsr r2,IE
8015b10: a0 52 18 00 and r3,r2,r18
8015b14: d0 03 00 00 wcsr IE,r3
if ( _Chain_Is_empty( insert_chain ) ) {
8015b18: 2b 83 00 54 lw r3,(sp+84)
8015b1c: 44 75 00 0d be r3,r21,8015b50 <_Timer_server_Body+0x184> <== ALWAYS TAKEN
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
8015b20: d0 02 00 00 wcsr IE,r2 <== NOT EXECUTED
8015b24: e3 ff ff d5 bi 8015a78 <_Timer_server_Body+0xac> <== NOT EXECUTED
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
8015b28: 50 44 ff e9 bgeu r2,r4,8015acc <_Timer_server_Body+0x100>
/*
* 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 );
8015b2c: ba 00 08 00 mv r1,r16
8015b30: 34 02 00 01 mvi r2,1
8015b34: c8 8c 18 00 sub r3,r4,r12
8015b38: f8 00 14 d8 calli 801ae98 <_Watchdog_Adjust>
8015b3c: e3 ff ff e4 bi 8015acc <_Timer_server_Body+0x100>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
8015b40: ba 20 08 00 mv r1,r17
8015b44: 34 42 00 10 addi r2,r2,16
8015b48: f8 00 15 36 calli 801b020 <_Watchdog_Insert>
8015b4c: e3 ff ff e2 bi 8015ad4 <_Timer_server_Body+0x108>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
8015b50: 59 60 00 78 sw (r11+120),r0
_ISR_Enable( level );
8015b54: d0 02 00 00 wcsr IE,r2
_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 ) ) {
8015b58: 2b 82 00 48 lw r2,(sp+72)
8015b5c: 5c 54 00 0b bne r2,r20,8015b88 <_Timer_server_Body+0x1bc>
8015b60: e0 00 00 11 bi 8015ba4 <_Timer_server_Body+0x1d8>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
8015b64: 28 43 00 00 lw r3,(r2+0)
head->next = new_first;
new_first->previous = head;
8015b68: 58 6f 00 04 sw (r3+4),r15
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
8015b6c: 5b 83 00 48 sw (sp+72),r3
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
8015b70: 58 40 00 08 sw (r2+8),r0
_ISR_Enable( level );
8015b74: d0 04 00 00 wcsr IE,r4
/*
* 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 );
8015b78: 28 43 00 1c lw r3,(r2+28)
8015b7c: 28 41 00 20 lw r1,(r2+32)
8015b80: 28 42 00 24 lw r2,(r2+36)
8015b84: d8 60 00 00 call r3
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
8015b88: 90 00 20 00 rcsr r4,IE
8015b8c: a0 92 10 00 and r2,r4,r18
8015b90: d0 02 00 00 wcsr IE,r2
initialized = false;
}
#endif
return status;
}
8015b94: 2b 82 00 48 lw r2,(sp+72)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
8015b98: 5c 54 ff f3 bne r2,r20,8015b64 <_Timer_server_Body+0x198>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
8015b9c: d0 04 00 00 wcsr IE,r4
8015ba0: e3 ff ff b5 bi 8015a74 <_Timer_server_Body+0xa8>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
8015ba4: 31 60 00 7c sb (r11+124),r0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8015ba8: 2a e1 00 00 lw r1,(r23+0)
++level;
8015bac: 34 21 00 01 addi r1,r1,1
_Thread_Dispatch_disable_level = level;
8015bb0: 5a e1 00 00 sw (r23+0),r1
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
8015bb4: 29 61 00 00 lw r1,(r11+0)
8015bb8: 34 02 00 08 mvi r2,8
8015bbc: f8 00 13 9f calli 801aa38 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
8015bc0: b9 60 08 00 mv r1,r11
8015bc4: fb ff ff 40 calli 80158c4 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
8015bc8: b9 60 08 00 mv r1,r11
8015bcc: fb ff ff 5f calli 8015948 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
8015bd0: f8 00 10 be calli 8019ec8 <_Thread_Enable_dispatch>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
8015bd4: bb 60 08 00 mv r1,fp
_Thread_Set_state( ts->thread, STATES_DELAYING );
_Timer_server_Reset_interval_system_watchdog( ts );
_Timer_server_Reset_tod_system_watchdog( ts );
_Thread_Enable_dispatch();
ts->active = true;
8015bd8: 31 78 00 7c sb (r11+124),r24
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
8015bdc: f8 00 15 77 calli 801b1b8 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
8015be0: bb 20 08 00 mv r1,r25
8015be4: f8 00 15 75 calli 801b1b8 <_Watchdog_Remove>
8015be8: e3 ff ff a3 bi 8015a74 <_Timer_server_Body+0xa8>
08015bec <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
8015bec: 37 9c ff f0 addi sp,sp,-16
8015bf0: 5b 8b 00 10 sw (sp+16),r11
8015bf4: 5b 8c 00 0c sw (sp+12),r12
8015bf8: 5b 8d 00 08 sw (sp+8),r13
8015bfc: 5b 9d 00 04 sw (sp+4),ra
8015c00: b8 20 58 00 mv r11,r1
if ( ts->insert_chain == NULL ) {
8015c04: 28 21 00 78 lw r1,(r1+120)
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
8015c08: b8 40 60 00 mv r12,r2
if ( ts->insert_chain == NULL ) {
8015c0c: 44 20 00 09 be r1,r0,8015c30 <_Timer_server_Schedule_operation_method+0x44>
* 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 );
8015c10: 29 61 00 78 lw r1,(r11+120)
8015c14: f8 00 03 01 calli 8016818 <_Chain_Append>
}
}
8015c18: 2b 9d 00 04 lw ra,(sp+4)
8015c1c: 2b 8b 00 10 lw r11,(sp+16)
8015c20: 2b 8c 00 0c lw r12,(sp+12)
8015c24: 2b 8d 00 08 lw r13,(sp+8)
8015c28: 37 9c 00 10 addi sp,sp,16
8015c2c: c3 a0 00 00 ret
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8015c30: 78 01 08 03 mvhi r1,0x803
8015c34: 38 21 fd 50 ori r1,r1,0xfd50
8015c38: 28 22 00 00 lw r2,(r1+0)
++level;
8015c3c: 34 42 00 01 addi r2,r2,1
_Thread_Dispatch_disable_level = level;
8015c40: 58 22 00 00 sw (r1+0),r2
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
8015c44: 29 81 00 38 lw r1,(r12+56)
8015c48: 34 02 00 01 mvi r2,1
8015c4c: 44 22 00 30 be r1,r2,8015d0c <_Timer_server_Schedule_operation_method+0x120>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
if ( !ts->active ) {
_Timer_server_Reset_interval_system_watchdog( ts );
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
8015c50: 34 02 00 03 mvi r2,3
8015c54: 44 22 00 08 be r1,r2,8015c74 <_Timer_server_Schedule_operation_method+0x88>
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
8015c58: f8 00 10 9c calli 8019ec8 <_Thread_Enable_dispatch>
* 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 );
}
}
8015c5c: 2b 9d 00 04 lw ra,(sp+4)
8015c60: 2b 8b 00 10 lw r11,(sp+16)
8015c64: 2b 8c 00 0c lw r12,(sp+12)
8015c68: 2b 8d 00 08 lw r13,(sp+8)
8015c6c: 37 9c 00 10 addi sp,sp,16
8015c70: c3 a0 00 00 ret
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
8015c74: 90 00 68 00 rcsr r13,IE
8015c78: 34 01 ff fe mvi r1,-2
8015c7c: a1 a1 08 00 and r1,r13,r1
8015c80: d0 01 00 00 wcsr IE,r1
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
8015c84: 78 02 08 03 mvhi r2,0x803
8015c88: 78 03 08 03 mvhi r3,0x803
8015c8c: 38 42 fc d0 ori r2,r2,0xfcd0
8015c90: 38 63 90 8c ori r3,r3,0x908c
8015c94: 28 64 00 00 lw r4,(r3+0)
8015c98: 28 41 00 00 lw r1,(r2+0)
8015c9c: 28 42 00 04 lw r2,(r2+4)
8015ca0: 34 03 00 00 mvi r3,0
8015ca4: f8 00 56 58 calli 802b604 <__divdi3>
initialized = false;
}
#endif
return status;
}
8015ca8: 29 61 00 68 lw r1,(r11+104)
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
8015cac: 29 63 00 74 lw r3,(r11+116)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8015cb0: 35 64 00 6c addi r4,r11,108
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
8015cb4: 44 24 00 0a be r1,r4,8015cdc <_Timer_server_Schedule_operation_method+0xf0>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
8015cb8: 28 25 00 10 lw r5,(r1+16)
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
8015cbc: b4 a3 20 00 add r4,r5,r3
delta_interval += delta;
8015cc0: c8 82 20 00 sub r4,r4,r2
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
8015cc4: 50 62 00 05 bgeu r3,r2,8015cd8 <_Timer_server_Schedule_operation_method+0xec>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
8015cc8: c8 43 18 00 sub r3,r2,r3
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
8015ccc: 34 04 00 00 mvi r4,0
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
8015cd0: 50 65 00 02 bgeu r3,r5,8015cd8 <_Timer_server_Schedule_operation_method+0xec><== NEVER TAKEN
delta_interval -= delta;
8015cd4: c8 a3 20 00 sub r4,r5,r3
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
8015cd8: 58 24 00 10 sw (r1+16),r4
}
ts->TOD_watchdogs.last_snapshot = snapshot;
8015cdc: 59 62 00 74 sw (r11+116),r2
_ISR_Enable( level );
8015ce0: d0 0d 00 00 wcsr IE,r13
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
8015ce4: 35 61 00 68 addi r1,r11,104
8015ce8: 35 82 00 10 addi r2,r12,16
8015cec: f8 00 14 cd calli 801b020 <_Watchdog_Insert>
if ( !ts->active ) {
8015cf0: 41 61 00 7c lbu r1,(r11+124)
8015cf4: 20 21 00 ff andi r1,r1,0xff
8015cf8: 5c 20 ff d8 bne r1,r0,8015c58 <_Timer_server_Schedule_operation_method+0x6c><== NEVER TAKEN
_Timer_server_Reset_tod_system_watchdog( ts );
8015cfc: b9 60 08 00 mv r1,r11
8015d00: fb ff ff 12 calli 8015948 <_Timer_server_Reset_tod_system_watchdog>
}
}
_Thread_Enable_dispatch();
8015d04: f8 00 10 71 calli 8019ec8 <_Thread_Enable_dispatch>
8015d08: e3 ff ff d5 bi 8015c5c <_Timer_server_Schedule_operation_method+0x70>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
8015d0c: 90 00 18 00 rcsr r3,IE
8015d10: 34 01 ff fe mvi r1,-2
8015d14: a0 61 08 00 and r1,r3,r1
8015d18: d0 01 00 00 wcsr IE,r1
snapshot = _Watchdog_Ticks_since_boot;
8015d1c: 78 01 08 03 mvhi r1,0x803
8015d20: 38 21 fe 38 ori r1,r1,0xfe38
initialized = false;
}
#endif
return status;
}
8015d24: 29 62 00 30 lw r2,(r11+48)
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
8015d28: 28 21 00 00 lw r1,(r1+0)
last_snapshot = ts->Interval_watchdogs.last_snapshot;
8015d2c: 29 65 00 3c lw r5,(r11+60)
8015d30: 35 64 00 34 addi r4,r11,52
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
8015d34: 44 44 00 07 be r2,r4,8015d50 <_Timer_server_Schedule_operation_method+0x164>
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
8015d38: 28 46 00 10 lw r6,(r2+16)
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
8015d3c: c8 25 28 00 sub r5,r1,r5
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
8015d40: 34 04 00 00 mvi r4,0
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
8015d44: 50 a6 00 02 bgeu r5,r6,8015d4c <_Timer_server_Schedule_operation_method+0x160>
delta_interval -= delta;
8015d48: c8 c5 20 00 sub r4,r6,r5
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
8015d4c: 58 44 00 10 sw (r2+16),r4
}
ts->Interval_watchdogs.last_snapshot = snapshot;
8015d50: 59 61 00 3c sw (r11+60),r1
_ISR_Enable( level );
8015d54: d0 03 00 00 wcsr IE,r3
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
8015d58: 35 61 00 30 addi r1,r11,48
8015d5c: 35 82 00 10 addi r2,r12,16
8015d60: f8 00 14 b0 calli 801b020 <_Watchdog_Insert>
if ( !ts->active ) {
8015d64: 41 61 00 7c lbu r1,(r11+124)
8015d68: 20 21 00 ff andi r1,r1,0xff
8015d6c: 5c 20 ff bb bne r1,r0,8015c58 <_Timer_server_Schedule_operation_method+0x6c>
_Timer_server_Reset_interval_system_watchdog( ts );
8015d70: b9 60 08 00 mv r1,r11
8015d74: fb ff fe d4 calli 80158c4 <_Timer_server_Reset_interval_system_watchdog>
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
8015d78: f8 00 10 54 calli 8019ec8 <_Thread_Enable_dispatch>
8015d7c: e3 ff ff b8 bi 8015c5c <_Timer_server_Schedule_operation_method+0x70>
08009290 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
8009290: b8 20 20 00 mv r4,r1
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
8009294: 28 83 00 00 lw r3,(r4+0)
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
uint32_t seconds = add->tv_sec;
8009298: 28 41 00 00 lw r1,(r2+0)
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
800929c: 28 86 00 04 lw r6,(r4+4)
80092a0: 28 42 00 04 lw r2,(r2+4)
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
80092a4: 78 07 08 01 mvhi r7,0x801
80092a8: 38 e7 8c 98 ori r7,r7,0x8c98
80092ac: 28 e5 00 00 lw r5,(r7+0)
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
80092b0: b4 61 18 00 add r3,r3,r1
time->tv_nsec += add->tv_nsec;
80092b4: b4 46 10 00 add r2,r2,r6
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
80092b8: 58 83 00 00 sw (r4+0),r3
time->tv_nsec += add->tv_nsec;
80092bc: 58 82 00 04 sw (r4+4),r2
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
80092c0: 50 a2 00 0a bgeu r5,r2,80092e8 <_Timespec_Add_to+0x58>
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
80092c4: 78 07 08 01 mvhi r7,0x801
80092c8: 38 e7 8c 9c ori r7,r7,0x8c9c
80092cc: 28 e6 00 00 lw r6,(r7+0)
80092d0: b4 46 10 00 add r2,r2,r6
#include <sys/types.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
uint32_t _Timespec_Add_to(
80092d4: 34 63 00 01 addi r3,r3,1
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
time->tv_sec++;
seconds++;
80092d8: 34 21 00 01 addi r1,r1,1
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
80092dc: 54 45 ff fd bgu r2,r5,80092d0 <_Timespec_Add_to+0x40> <== NEVER TAKEN
80092e0: 58 82 00 04 sw (r4+4),r2
80092e4: 58 83 00 00 sw (r4+0),r3
time->tv_sec++;
seconds++;
}
return seconds;
}
80092e8: c3 a0 00 00 ret
08007aec <_User_extensions_Handler_initialization>:
}
}
void _User_extensions_Handler_initialization(void)
{
8007aec: 37 9c ff f8 addi sp,sp,-8
8007af0: 5b 9d 00 04 sw (sp+4),ra
uint32_t number_of_initial_extensions =
8007af4: 78 01 08 01 mvhi r1,0x801
8007af8: 38 21 d2 6c ori r1,r1,0xd26c
8007afc: 28 21 00 40 lw r1,(r1+64)
rtems_configuration_get_number_of_initial_extensions();
if ( number_of_initial_extensions > 0 ) {
8007b00: 44 20 00 0b be r1,r0,8007b2c <_User_extensions_Handler_initialization+0x40><== NEVER TAKEN
User_extensions_Switch_control *initial_extension_switch_controls =
_Workspace_Allocate_or_fatal_error(
number_of_initial_extensions
* sizeof( *initial_extension_switch_controls )
8007b04: b4 21 10 00 add r2,r1,r1
8007b08: b4 41 08 00 add r1,r2,r1
8007b0c: b4 21 08 00 add r1,r1,r1
8007b10: b4 21 08 00 add r1,r1,r1
uint32_t number_of_initial_extensions =
rtems_configuration_get_number_of_initial_extensions();
if ( number_of_initial_extensions > 0 ) {
User_extensions_Switch_control *initial_extension_switch_controls =
_Workspace_Allocate_or_fatal_error(
8007b14: f8 00 01 50 calli 8008054 <_Workspace_Allocate_or_fatal_error>
number_of_initial_extensions
* sizeof( *initial_extension_switch_controls )
);
User_extensions_Switch_context ctx = { initial_extension_switch_controls };
_User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
8007b18: 78 02 08 00 mvhi r2,0x800
User_extensions_Switch_control *initial_extension_switch_controls =
_Workspace_Allocate_or_fatal_error(
number_of_initial_extensions
* sizeof( *initial_extension_switch_controls )
);
User_extensions_Switch_context ctx = { initial_extension_switch_controls };
8007b1c: 5b 81 00 08 sw (sp+8),r1
_User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
8007b20: 38 42 7a ac ori r2,r2,0x7aac
8007b24: 37 81 00 08 addi r1,sp,8
8007b28: fb ff ff b0 calli 80079e8 <_User_extensions_Iterate>
}
}
8007b2c: 2b 9d 00 04 lw ra,(sp+4)
8007b30: 37 9c 00 08 addi sp,sp,8
8007b34: c3 a0 00 00 ret
080079e8 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
80079e8: 37 9c ff e8 addi sp,sp,-24
80079ec: 5b 8b 00 18 sw (sp+24),r11
80079f0: 5b 8c 00 14 sw (sp+20),r12
80079f4: 5b 8d 00 10 sw (sp+16),r13
80079f8: 5b 8e 00 0c sw (sp+12),r14
80079fc: 5b 8f 00 08 sw (sp+8),r15
8007a00: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *executing = _Thread_Executing;
const User_extensions_Table *callouts_current =
8007a04: 78 04 08 01 mvhi r4,0x801
8007a08: 38 84 d2 6c ori r4,r4,0xd26c
rtems_configuration_get_user_extension_table();
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
8007a0c: 28 83 00 40 lw r3,(r4+64)
void *arg,
User_extensions_Visitor visitor
)
{
Thread_Control *executing = _Thread_Executing;
const User_extensions_Table *callouts_current =
8007a10: 28 8b 00 44 lw r11,(r4+68)
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
Thread_Control *executing = _Thread_Executing;
8007a14: 78 04 08 02 mvhi r4,0x802
const User_extensions_Table *callouts_current =
rtems_configuration_get_user_extension_table();
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
8007a18: b4 63 18 00 add r3,r3,r3
8007a1c: b4 63 18 00 add r3,r3,r3
8007a20: b4 63 18 00 add r3,r3,r3
8007a24: b4 63 18 00 add r3,r3,r3
8007a28: b4 63 18 00 add r3,r3,r3
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
Thread_Control *executing = _Thread_Executing;
8007a2c: 38 84 0d e0 ori r4,r4,0xde0
const User_extensions_Table *callouts_current =
rtems_configuration_get_user_extension_table();
const User_extensions_Table *callouts_end =
8007a30: b5 63 78 00 add r15,r11,r3
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor
)
{
8007a34: b8 20 68 00 mv r13,r1
8007a38: b8 40 70 00 mv r14,r2
Thread_Control *executing = _Thread_Executing;
8007a3c: 28 8c 00 10 lw r12,(r4+16)
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
const Chain_Node *node;
const Chain_Node *tail;
while ( callouts_current != callouts_end ) {
8007a40: 45 6f 00 07 be r11,r15,8007a5c <_User_extensions_Iterate+0x74><== NEVER TAKEN
(*visitor)( executing, arg, callouts_current );
8007a44: b9 60 18 00 mv r3,r11
8007a48: b9 80 08 00 mv r1,r12
++callouts_current;
8007a4c: 35 6b 00 20 addi r11,r11,32
callouts_current + rtems_configuration_get_number_of_initial_extensions();
const Chain_Node *node;
const Chain_Node *tail;
while ( callouts_current != callouts_end ) {
(*visitor)( executing, arg, callouts_current );
8007a50: b9 a0 10 00 mv r2,r13
8007a54: d9 c0 00 00 call r14
const User_extensions_Table *callouts_end =
callouts_current + rtems_configuration_get_number_of_initial_extensions();
const Chain_Node *node;
const Chain_Node *tail;
while ( callouts_current != callouts_end ) {
8007a58: 5d eb ff fb bne r15,r11,8007a44 <_User_extensions_Iterate+0x5c>
(*visitor)( executing, arg, &extension->Callouts );
node = _Chain_Immutable_next( node );
}
}
8007a5c: 78 01 08 02 mvhi r1,0x802
8007a60: 38 21 01 94 ori r1,r1,0x194
8007a64: 28 2b 00 00 lw r11,(r1+0)
++callouts_current;
}
node = _Chain_Immutable_first( &_User_extensions_List );
tail = _Chain_Immutable_tail( &_User_extensions_List );
while ( node != tail ) {
8007a68: 78 0f 08 02 mvhi r15,0x802
8007a6c: 39 ef 01 98 ori r15,r15,0x198
8007a70: 45 6f 00 07 be r11,r15,8007a8c <_User_extensions_Iterate+0xa4>
const User_extensions_Control *extension =
(const User_extensions_Control *) node;
(*visitor)( executing, arg, &extension->Callouts );
8007a74: 35 63 00 14 addi r3,r11,20
8007a78: b9 80 08 00 mv r1,r12
8007a7c: b9 a0 10 00 mv r2,r13
8007a80: d9 c0 00 00 call r14
node = _Chain_Immutable_next( node );
}
}
8007a84: 29 6b 00 00 lw r11,(r11+0)
++callouts_current;
}
node = _Chain_Immutable_first( &_User_extensions_List );
tail = _Chain_Immutable_tail( &_User_extensions_List );
while ( node != tail ) {
8007a88: 5d 6f ff fb bne r11,r15,8007a74 <_User_extensions_Iterate+0x8c>
(*visitor)( executing, arg, &extension->Callouts );
node = _Chain_Immutable_next( node );
}
}
8007a8c: 2b 9d 00 04 lw ra,(sp+4)
8007a90: 2b 8b 00 18 lw r11,(sp+24)
8007a94: 2b 8c 00 14 lw r12,(sp+20)
8007a98: 2b 8d 00 10 lw r13,(sp+16)
8007a9c: 2b 8e 00 0c lw r14,(sp+12)
8007aa0: 2b 8f 00 08 lw r15,(sp+8)
8007aa4: 37 9c 00 18 addi sp,sp,24
8007aa8: c3 a0 00 00 ret
08009a64 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
8009a64: 37 9c ff e4 addi sp,sp,-28
8009a68: 5b 8b 00 1c sw (sp+28),r11
8009a6c: 5b 8c 00 18 sw (sp+24),r12
8009a70: 5b 8d 00 14 sw (sp+20),r13
8009a74: 5b 8e 00 10 sw (sp+16),r14
8009a78: 5b 8f 00 0c sw (sp+12),r15
8009a7c: 5b 90 00 08 sw (sp+8),r16
8009a80: 5b 9d 00 04 sw (sp+4),ra
8009a84: b8 20 60 00 mv r12,r1
8009a88: b8 60 58 00 mv r11,r3
ISR_Level level;
_ISR_Disable( level );
8009a8c: 90 00 18 00 rcsr r3,IE
8009a90: 34 01 ff fe mvi r1,-2
8009a94: a0 61 08 00 and r1,r3,r1
8009a98: d0 01 00 00 wcsr IE,r1
}
}
_ISR_Enable( level );
}
8009a9c: 29 81 00 00 lw r1,(r12+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8009aa0: 35 8e 00 04 addi r14,r12,4
Watchdog_Interval units
)
{
ISR_Level level;
_ISR_Disable( level );
8009aa4: b8 60 20 00 mv r4,r3
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
8009aa8: 44 2e 00 04 be r1,r14,8009ab8 <_Watchdog_Adjust+0x54>
switch ( direction ) {
8009aac: 44 40 00 11 be r2,r0,8009af0 <_Watchdog_Adjust+0x8c>
8009ab0: 34 03 00 01 mvi r3,1
8009ab4: 44 43 00 0b be r2,r3,8009ae0 <_Watchdog_Adjust+0x7c> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
8009ab8: d0 04 00 00 wcsr IE,r4
}
8009abc: 2b 9d 00 04 lw ra,(sp+4)
8009ac0: 2b 8b 00 1c lw r11,(sp+28)
8009ac4: 2b 8c 00 18 lw r12,(sp+24)
8009ac8: 2b 8d 00 14 lw r13,(sp+20)
8009acc: 2b 8e 00 10 lw r14,(sp+16)
8009ad0: 2b 8f 00 0c lw r15,(sp+12)
8009ad4: 2b 90 00 08 lw r16,(sp+8)
8009ad8: 37 9c 00 1c addi sp,sp,28
8009adc: c3 a0 00 00 ret
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
8009ae0: 28 22 00 10 lw r2,(r1+16)
8009ae4: b4 4b 58 00 add r11,r2,r11
8009ae8: 58 2b 00 10 sw (r1+16),r11
break;
8009aec: e3 ff ff f3 bi 8009ab8 <_Watchdog_Adjust+0x54>
case WATCHDOG_FORWARD:
while ( units ) {
8009af0: b8 60 20 00 mv r4,r3
8009af4: 45 62 ff f1 be r11,r2,8009ab8 <_Watchdog_Adjust+0x54> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
8009af8: 28 2d 00 10 lw r13,(r1+16)
8009afc: 55 ab 00 13 bgu r13,r11,8009b48 <_Watchdog_Adjust+0xe4> <== NEVER TAKEN
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
8009b00: 34 10 00 01 mvi r16,1
_ISR_Enable( level );
_Watchdog_Tickle( header );
_ISR_Disable( level );
8009b04: 34 0f ff fe mvi r15,-2
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
8009b08: 58 30 00 10 sw (r1+16),r16
_ISR_Enable( level );
8009b0c: d0 03 00 00 wcsr IE,r3
_Watchdog_Tickle( header );
8009b10: b9 80 08 00 mv r1,r12
8009b14: f8 00 00 ad calli 8009dc8 <_Watchdog_Tickle>
_ISR_Disable( level );
8009b18: 90 00 10 00 rcsr r2,IE
8009b1c: a0 4f 08 00 and r1,r2,r15
8009b20: d0 01 00 00 wcsr IE,r1
}
}
_ISR_Enable( level );
}
8009b24: 29 84 00 00 lw r4,(r12+0)
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
8009b28: c9 6d 58 00 sub r11,r11,r13
_ISR_Enable( level );
_Watchdog_Tickle( header );
_ISR_Disable( level );
8009b2c: b8 40 18 00 mv r3,r2
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
8009b30: b8 80 08 00 mv r1,r4
if ( _Chain_Is_empty( header ) )
8009b34: 45 c4 00 08 be r14,r4,8009b54 <_Watchdog_Adjust+0xf0>
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
8009b38: 45 60 00 07 be r11,r0,8009b54 <_Watchdog_Adjust+0xf0> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
8009b3c: 28 2d 00 10 lw r13,(r1+16)
8009b40: 51 6d ff f2 bgeu r11,r13,8009b08 <_Watchdog_Adjust+0xa4>
_ISR_Enable( level );
_Watchdog_Tickle( header );
_ISR_Disable( level );
8009b44: b8 40 20 00 mv r4,r2
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
8009b48: c9 ab 58 00 sub r11,r13,r11
8009b4c: 58 2b 00 10 sw (r1+16),r11
break;
8009b50: e3 ff ff da bi 8009ab8 <_Watchdog_Adjust+0x54>
_ISR_Enable( level );
_Watchdog_Tickle( header );
_ISR_Disable( level );
8009b54: b8 40 20 00 mv r4,r2
8009b58: e3 ff ff d8 bi 8009ab8 <_Watchdog_Adjust+0x54>
08007b38 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
8007b38: 37 9c ff f8 addi sp,sp,-8
8007b3c: 5b 8b 00 08 sw (sp+8),r11
8007b40: 5b 8c 00 04 sw (sp+4),r12
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
8007b44: 78 03 08 02 mvhi r3,0x802
8007b48: 38 63 0d e0 ori r3,r3,0xde0
8007b4c: 28 69 00 08 lw r9,(r3+8)
_ISR_Disable( level );
8007b50: 90 00 30 00 rcsr r6,IE
8007b54: 34 08 ff fe mvi r8,-2
8007b58: a0 c8 40 00 and r8,r6,r8
8007b5c: d0 08 00 00 wcsr IE,r8
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
8007b60: 28 43 00 08 lw r3,(r2+8)
8007b64: 5c 60 00 32 bne r3,r0,8007c2c <_Watchdog_Insert+0xf4>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
8007b68: 78 0c 08 02 mvhi r12,0x802
8007b6c: 39 8c 0a 3c ori r12,r12,0xa3c
8007b70: 29 83 00 00 lw r3,(r12+0)
8007b74: 78 07 08 02 mvhi r7,0x802
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
8007b78: 34 04 00 01 mvi r4,1
_Watchdog_Sync_count++;
8007b7c: 34 63 00 01 addi r3,r3,1
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
8007b80: 58 44 00 08 sw (r2+8),r4
_Watchdog_Sync_count++;
8007b84: 59 83 00 00 sw (r12+0),r3
8007b88: 38 e7 09 dc ori r7,r7,0x9dc
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
8007b8c: 34 0a 00 01 mvi r10,1
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
restart:
delta_interval = the_watchdog->initial;
8007b90: 28 44 00 0c lw r4,(r2+12)
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
8007b94: 28 23 00 00 lw r3,(r1+0)
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
8007b98: 44 80 00 14 be r4,r0,8007be8 <_Watchdog_Insert+0xb0>
8007b9c: 28 65 00 00 lw r5,(r3+0)
8007ba0: 44 a0 00 12 be r5,r0,8007be8 <_Watchdog_Insert+0xb0>
break;
if ( delta_interval < after->delta_interval ) {
8007ba4: 28 65 00 10 lw r5,(r3+16)
8007ba8: 54 a4 00 0e bgu r5,r4,8007be0 <_Watchdog_Insert+0xa8>
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
8007bac: d0 06 00 00 wcsr IE,r6
8007bb0: d0 08 00 00 wcsr IE,r8
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
8007bb4: 28 4b 00 08 lw r11,(r2+8)
8007bb8: 5d 6a 00 19 bne r11,r10,8007c1c <_Watchdog_Insert+0xe4>
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
8007bbc: 28 eb 00 00 lw r11,(r7+0)
8007bc0: 55 69 00 28 bgu r11,r9,8007c60 <_Watchdog_Insert+0x128>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
8007bc4: c8 85 20 00 sub r4,r4,r5
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
8007bc8: 28 63 00 00 lw r3,(r3+0)
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
8007bcc: 44 80 00 07 be r4,r0,8007be8 <_Watchdog_Insert+0xb0>
8007bd0: 28 65 00 00 lw r5,(r3+0)
8007bd4: 44 a0 00 05 be r5,r0,8007be8 <_Watchdog_Insert+0xb0>
break;
if ( delta_interval < after->delta_interval ) {
8007bd8: 28 65 00 10 lw r5,(r3+16)
8007bdc: 50 85 00 19 bgeu r4,r5,8007c40 <_Watchdog_Insert+0x108>
after->delta_interval -= delta_interval;
8007be0: c8 a4 28 00 sub r5,r5,r4
8007be4: 58 65 00 10 sw (r3+16),r5
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
8007be8: 28 63 00 04 lw r3,(r3+4)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
8007bec: 78 01 08 02 mvhi r1,0x802
8007bf0: 38 21 0a 40 ori r1,r1,0xa40
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
8007bf4: 28 65 00 00 lw r5,(r3+0)
8007bf8: 28 28 00 00 lw r8,(r1+0)
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
8007bfc: 34 01 00 02 mvi r1,2
8007c00: 58 41 00 08 sw (r2+8),r1
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
8007c04: 58 44 00 10 sw (r2+16),r4
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
8007c08: 58 43 00 04 sw (r2+4),r3
before_node = after_node->next;
after_node->next = the_node;
8007c0c: 58 62 00 00 sw (r3+0),r2
the_node->next = before_node;
before_node->previous = the_node;
8007c10: 58 a2 00 04 sw (r5+4),r2
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
8007c14: 58 45 00 00 sw (r2+0),r5
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
8007c18: 58 48 00 14 sw (r2+20),r8
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
8007c1c: 58 e9 00 00 sw (r7+0),r9
_Watchdog_Sync_count--;
8007c20: 29 81 00 00 lw r1,(r12+0)
8007c24: 34 21 ff ff addi r1,r1,-1
8007c28: 59 81 00 00 sw (r12+0),r1
_ISR_Enable( level );
8007c2c: d0 06 00 00 wcsr IE,r6
}
8007c30: 2b 8b 00 08 lw r11,(sp+8)
8007c34: 2b 8c 00 04 lw r12,(sp+4)
8007c38: 37 9c 00 08 addi sp,sp,8
8007c3c: c3 a0 00 00 ret
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
8007c40: d0 06 00 00 wcsr IE,r6
8007c44: d0 08 00 00 wcsr IE,r8
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
8007c48: 28 4b 00 08 lw r11,(r2+8)
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
8007c4c: c8 85 20 00 sub r4,r4,r5
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
8007c50: 5d 6a ff f3 bne r11,r10,8007c1c <_Watchdog_Insert+0xe4> <== NEVER TAKEN
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
8007c54: 28 e5 00 00 lw r5,(r7+0)
8007c58: 54 a9 00 02 bgu r5,r9,8007c60 <_Watchdog_Insert+0x128> <== NEVER TAKEN
8007c5c: e3 ff ff db bi 8007bc8 <_Watchdog_Insert+0x90>
_Watchdog_Sync_level = insert_isr_nest_level;
8007c60: 58 e9 00 00 sw (r7+0),r9
goto restart;
8007c64: e3 ff ff cb bi 8007b90 <_Watchdog_Insert+0x58>
08007cd0 <_Watchdog_Remove>:
{
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
8007cd0: 90 00 20 00 rcsr r4,IE
8007cd4: 34 02 ff fe mvi r2,-2
8007cd8: a0 82 10 00 and r2,r4,r2
8007cdc: d0 02 00 00 wcsr IE,r2
previous_state = the_watchdog->state;
8007ce0: 28 22 00 08 lw r2,(r1+8)
switch ( previous_state ) {
8007ce4: 34 03 00 01 mvi r3,1
8007ce8: 44 43 00 27 be r2,r3,8007d84 <_Watchdog_Remove+0xb4>
8007cec: 5c 40 00 08 bne r2,r0,8007d0c <_Watchdog_Remove+0x3c>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
8007cf0: 78 03 08 02 mvhi r3,0x802
8007cf4: 38 63 0a 40 ori r3,r3,0xa40
8007cf8: 28 63 00 00 lw r3,(r3+0)
8007cfc: 58 23 00 18 sw (r1+24),r3
_ISR_Enable( level );
8007d00: d0 04 00 00 wcsr IE,r4
return( previous_state );
}
8007d04: b8 40 08 00 mv r1,r2
8007d08: c3 a0 00 00 ret
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
8007d0c: 34 03 00 03 mvi r3,3
8007d10: 54 43 ff f8 bgu r2,r3,8007cf0 <_Watchdog_Remove+0x20> <== NEVER TAKEN
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
8007d14: 28 23 00 00 lw r3,(r1+0)
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
8007d18: 58 20 00 08 sw (r1+8),r0
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
8007d1c: 28 65 00 00 lw r5,(r3+0)
8007d20: 44 a0 00 05 be r5,r0,8007d34 <_Watchdog_Remove+0x64>
next_watchdog->delta_interval += the_watchdog->delta_interval;
8007d24: 28 66 00 10 lw r6,(r3+16)
8007d28: 28 25 00 10 lw r5,(r1+16)
8007d2c: b4 c5 28 00 add r5,r6,r5
8007d30: 58 65 00 10 sw (r3+16),r5
if ( _Watchdog_Sync_count )
8007d34: 78 05 08 02 mvhi r5,0x802
8007d38: 38 a5 0a 3c ori r5,r5,0xa3c
8007d3c: 28 a5 00 00 lw r5,(r5+0)
8007d40: 44 a0 00 07 be r5,r0,8007d5c <_Watchdog_Remove+0x8c>
_Watchdog_Sync_level = _ISR_Nest_level;
8007d44: 78 05 08 02 mvhi r5,0x802
8007d48: 38 a5 0d e0 ori r5,r5,0xde0
8007d4c: 28 a6 00 08 lw r6,(r5+8)
8007d50: 78 05 08 02 mvhi r5,0x802
8007d54: 38 a5 09 dc ori r5,r5,0x9dc
8007d58: 58 a6 00 00 sw (r5+0),r6
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
8007d5c: 28 25 00 04 lw r5,(r1+4)
next->previous = previous;
8007d60: 58 65 00 04 sw (r3+4),r5
previous->next = next;
8007d64: 58 a3 00 00 sw (r5+0),r3
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
8007d68: 78 03 08 02 mvhi r3,0x802
8007d6c: 38 63 0a 40 ori r3,r3,0xa40
8007d70: 28 63 00 00 lw r3,(r3+0)
8007d74: 58 23 00 18 sw (r1+24),r3
_ISR_Enable( level );
8007d78: d0 04 00 00 wcsr IE,r4
return( previous_state );
}
8007d7c: b8 40 08 00 mv r1,r2
8007d80: c3 a0 00 00 ret
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
8007d84: 78 03 08 02 mvhi r3,0x802
8007d88: 38 63 0a 40 ori r3,r3,0xa40
8007d8c: 28 63 00 00 lw r3,(r3+0)
/*
* 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;
8007d90: 58 20 00 08 sw (r1+8),r0
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
8007d94: 58 23 00 18 sw (r1+24),r3
_ISR_Enable( level );
8007d98: d0 04 00 00 wcsr IE,r4
return( previous_state );
}
8007d9c: b8 40 08 00 mv r1,r2
8007da0: c3 a0 00 00 ret
080095ec <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
80095ec: 37 9c ff ec addi sp,sp,-20
80095f0: 5b 8b 00 14 sw (sp+20),r11
80095f4: 5b 8c 00 10 sw (sp+16),r12
80095f8: 5b 8d 00 0c sw (sp+12),r13
80095fc: 5b 8e 00 08 sw (sp+8),r14
8009600: 5b 9d 00 04 sw (sp+4),ra
8009604: b8 20 70 00 mv r14,r1
8009608: b8 40 60 00 mv r12,r2
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
800960c: 90 00 68 00 rcsr r13,IE
8009610: 34 01 ff fe mvi r1,-2
8009614: a1 a1 08 00 and r1,r13,r1
8009618: d0 01 00 00 wcsr IE,r1
printk( "Watchdog Chain: %s %p\n", name, header );
800961c: 78 01 08 02 mvhi r1,0x802
8009620: b9 80 18 00 mv r3,r12
8009624: 38 21 00 2c ori r1,r1,0x2c
8009628: b9 c0 10 00 mv r2,r14
800962c: fb ff e6 cd calli 8003160 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
8009630: 29 8b 00 00 lw r11,(r12+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8009634: 35 8c 00 04 addi r12,r12,4
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
8009638: 45 6c 00 12 be r11,r12,8009680 <_Watchdog_Report_chain+0x94>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
800963c: b9 60 10 00 mv r2,r11
8009640: 34 01 00 00 mvi r1,0
8009644: f8 00 00 13 calli 8009690 <_Watchdog_Report>
_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 )
8009648: 29 6b 00 00 lw r11,(r11+0)
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
800964c: 5d 6c ff fc bne r11,r12,800963c <_Watchdog_Report_chain+0x50><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
8009650: 78 01 08 02 mvhi r1,0x802
8009654: 38 21 00 44 ori r1,r1,0x44
8009658: b9 c0 10 00 mv r2,r14
800965c: fb ff e6 c1 calli 8003160 <printk>
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
8009660: d0 0d 00 00 wcsr IE,r13
}
8009664: 2b 9d 00 04 lw ra,(sp+4)
8009668: 2b 8b 00 14 lw r11,(sp+20)
800966c: 2b 8c 00 10 lw r12,(sp+16)
8009670: 2b 8d 00 0c lw r13,(sp+12)
8009674: 2b 8e 00 08 lw r14,(sp+8)
8009678: 37 9c 00 14 addi sp,sp,20
800967c: c3 a0 00 00 ret
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
8009680: 78 01 08 02 mvhi r1,0x802
8009684: 38 21 00 54 ori r1,r1,0x54
8009688: fb ff e6 b6 calli 8003160 <printk>
800968c: e3 ff ff f5 bi 8009660 <_Watchdog_Report_chain+0x74>
08007da4 <_Watchdog_Tickle>:
#include <rtems/score/watchdog.h>
void _Watchdog_Tickle(
Chain_Control *header
)
{
8007da4: 37 9c ff e4 addi sp,sp,-28
8007da8: 5b 8b 00 1c sw (sp+28),r11
8007dac: 5b 8c 00 18 sw (sp+24),r12
8007db0: 5b 8d 00 14 sw (sp+20),r13
8007db4: 5b 8e 00 10 sw (sp+16),r14
8007db8: 5b 8f 00 0c sw (sp+12),r15
8007dbc: 5b 90 00 08 sw (sp+8),r16
8007dc0: 5b 9d 00 04 sw (sp+4),ra
8007dc4: b8 20 60 00 mv r12,r1
* 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 );
8007dc8: 90 00 68 00 rcsr r13,IE
8007dcc: 34 01 ff fe mvi r1,-2
8007dd0: a1 a1 08 00 and r1,r13,r1
8007dd4: d0 01 00 00 wcsr IE,r1
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
8007dd8: 29 8b 00 00 lw r11,(r12+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8007ddc: 35 8e 00 04 addi r14,r12,4
* 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 );
8007de0: b9 a0 10 00 mv r2,r13
if ( _Chain_Is_empty( header ) )
8007de4: 45 6e 00 1e be r11,r14,8007e5c <_Watchdog_Tickle+0xb8>
* 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) {
8007de8: 29 61 00 10 lw r1,(r11+16)
8007dec: 5c 20 00 26 bne r1,r0,8007e84 <_Watchdog_Tickle+0xe0> <== ALWAYS TAKEN
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
_ISR_Enable( level );
switch( watchdog_state ) {
8007df0: 34 10 00 02 mvi r16,2
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
8007df4: 34 0f ff fe mvi r15,-2
8007df8: e0 00 00 0a bi 8007e20 <_Watchdog_Tickle+0x7c>
8007dfc: 90 00 10 00 rcsr r2,IE <== NOT EXECUTED
8007e00: a0 4f 08 00 and r1,r2,r15 <== NOT EXECUTED
8007e04: d0 01 00 00 wcsr IE,r1 <== NOT EXECUTED
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
8007e08: 29 81 00 00 lw r1,(r12+0) <== NOT EXECUTED
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
8007e0c: b8 40 68 00 mv r13,r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
8007e10: b8 20 58 00 mv r11,r1 <== NOT EXECUTED
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
8007e14: 44 2e 00 12 be r1,r14,8007e5c <_Watchdog_Tickle+0xb8> <== NOT EXECUTED
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
8007e18: 28 21 00 10 lw r1,(r1+16)
8007e1c: 5c 20 00 10 bne r1,r0,8007e5c <_Watchdog_Tickle+0xb8>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
8007e20: b9 60 08 00 mv r1,r11
8007e24: fb ff ff ab calli 8007cd0 <_Watchdog_Remove>
_ISR_Enable( level );
8007e28: d0 0d 00 00 wcsr IE,r13
switch( watchdog_state ) {
8007e2c: 5c 30 ff f4 bne r1,r16,8007dfc <_Watchdog_Tickle+0x58> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
8007e30: 29 63 00 1c lw r3,(r11+28)
8007e34: 29 61 00 20 lw r1,(r11+32)
8007e38: 29 62 00 24 lw r2,(r11+36)
8007e3c: d8 60 00 00 call r3
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
8007e40: 90 00 10 00 rcsr r2,IE
8007e44: a0 4f 08 00 and r1,r2,r15
8007e48: d0 01 00 00 wcsr IE,r1
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
8007e4c: 29 81 00 00 lw r1,(r12+0)
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
8007e50: b8 40 68 00 mv r13,r2
8007e54: b8 20 58 00 mv r11,r1
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
8007e58: 5c 2e ff f0 bne r1,r14,8007e18 <_Watchdog_Tickle+0x74>
leave:
_ISR_Enable(level);
8007e5c: d0 02 00 00 wcsr IE,r2
}
8007e60: 2b 9d 00 04 lw ra,(sp+4)
8007e64: 2b 8b 00 1c lw r11,(sp+28)
8007e68: 2b 8c 00 18 lw r12,(sp+24)
8007e6c: 2b 8d 00 14 lw r13,(sp+20)
8007e70: 2b 8e 00 10 lw r14,(sp+16)
8007e74: 2b 8f 00 0c lw r15,(sp+12)
8007e78: 2b 90 00 08 lw r16,(sp+8)
8007e7c: 37 9c 00 1c addi sp,sp,28
8007e80: c3 a0 00 00 ret
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
the_watchdog->delta_interval--;
8007e84: 34 21 ff ff addi r1,r1,-1
8007e88: 59 61 00 10 sw (r11+16),r1
if ( the_watchdog->delta_interval != 0 )
8007e8c: 44 20 ff d9 be r1,r0,8007df0 <_Watchdog_Tickle+0x4c>
8007e90: e3 ff ff f3 bi 8007e5c <_Watchdog_Tickle+0xb8>
08007e94 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
8007e94: 37 9c ff d0 addi sp,sp,-48
8007e98: 5b 8b 00 30 sw (sp+48),r11
8007e9c: 5b 8c 00 2c sw (sp+44),r12
8007ea0: 5b 8d 00 28 sw (sp+40),r13
8007ea4: 5b 8e 00 24 sw (sp+36),r14
8007ea8: 5b 8f 00 20 sw (sp+32),r15
8007eac: 5b 90 00 1c sw (sp+28),r16
8007eb0: 5b 91 00 18 sw (sp+24),r17
8007eb4: 5b 92 00 14 sw (sp+20),r18
8007eb8: 5b 93 00 10 sw (sp+16),r19
8007ebc: 5b 94 00 0c sw (sp+12),r20
8007ec0: 5b 95 00 08 sw (sp+8),r21
8007ec4: 5b 9d 00 04 sw (sp+4),ra
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
8007ec8: 78 04 08 01 mvhi r4,0x801
8007ecc: 38 84 d2 6c ori r4,r4,0xd26c
8007ed0: 40 85 00 32 lbu r5,(r4+50)
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
8007ed4: b8 40 80 00 mv r16,r2
8007ed8: b8 60 a0 00 mv r20,r3
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t remaining = rtems_configuration_get_work_space_size();
8007edc: 28 8e 00 00 lw r14,(r4+0)
8007ee0: 34 02 00 00 mvi r2,0
8007ee4: 5c a0 00 02 bne r5,r0,8007eec <_Workspace_Handler_initialization+0x58>
8007ee8: 28 82 00 04 lw r2,(r4+4)
8007eec: b4 4e 70 00 add r14,r2,r14
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
8007ef0: 40 92 00 30 lbu r18,(r4+48)
bool unified = rtems_configuration_get_unified_work_area();
8007ef4: 40 95 00 31 lbu r21,(r4+49)
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
8007ef8: 46 00 00 21 be r16,r0,8007f7c <_Workspace_Handler_initialization+0xe8><== NEVER TAKEN
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
8007efc: 78 0f 08 00 mvhi r15,0x800
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
8007f00: 78 11 08 02 mvhi r17,0x802
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
8007f04: b8 20 58 00 mv r11,r1
8007f08: 34 0d 00 00 mvi r13,0
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
8007f0c: 39 ef 51 d8 ori r15,r15,0x51d8
if ( do_zero ) {
memset( area->begin, 0, area->size );
}
if ( area->size > overhead ) {
8007f10: 34 13 00 0e mvi r19,14
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
8007f14: 3a 31 09 68 ori r17,r17,0x968
size_t i;
for (i = 0; i < area_count; ++i) {
Heap_Area *area = &areas [i];
if ( do_zero ) {
8007f18: 5e 40 00 28 bne r18,r0,8007fb8 <_Workspace_Handler_initialization+0x124>
memset( area->begin, 0, area->size );
}
if ( area->size > overhead ) {
8007f1c: 29 6c 00 04 lw r12,(r11+4)
8007f20: 52 6c 00 14 bgeu r19,r12,8007f70 <_Workspace_Handler_initialization+0xdc>
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
8007f24: 5e a0 00 05 bne r21,r0,8007f38 <_Workspace_Handler_initialization+0xa4>
size = area->size;
} else {
if ( remaining > 0 ) {
8007f28: 45 d5 00 29 be r14,r21,8007fcc <_Workspace_Handler_initialization+0x138><== NEVER TAKEN
size = remaining < area->size - overhead ?
8007f2c: 35 81 ff f2 addi r1,r12,-14
remaining + overhead : area->size;
8007f30: 51 c1 00 02 bgeu r14,r1,8007f38 <_Workspace_Handler_initialization+0xa4><== NEVER TAKEN
8007f34: 35 cc 00 0e addi r12,r14,14
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
8007f38: 29 62 00 00 lw r2,(r11+0)
8007f3c: b9 80 18 00 mv r3,r12
8007f40: ba 20 08 00 mv r1,r17
8007f44: 34 04 00 04 mvi r4,4
8007f48: d9 e0 00 00 call r15
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
8007f4c: 29 62 00 00 lw r2,(r11+0)
area->size -= size;
8007f50: 29 63 00 04 lw r3,(r11+4)
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
8007f54: b4 4c 10 00 add r2,r2,r12
area->size -= size;
8007f58: c8 6c 60 00 sub r12,r3,r12
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
8007f5c: 59 62 00 00 sw (r11+0),r2
area->size -= size;
8007f60: 59 6c 00 04 sw (r11+4),r12
if ( space_available < remaining ) {
8007f64: 50 2e 00 21 bgeu r1,r14,8007fe8 <_Workspace_Handler_initialization+0x154><== ALWAYS TAKEN
remaining -= space_available;
8007f68: c9 c1 70 00 sub r14,r14,r1 <== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
8007f6c: ba 80 78 00 mv r15,r20 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
8007f70: 35 ad 00 01 addi r13,r13,1
8007f74: 35 6b 00 08 addi r11,r11,8
8007f78: 56 0d ff e8 bgu r16,r13,8007f18 <_Workspace_Handler_initialization+0x84><== NEVER TAKEN
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
8007f7c: 5d c0 00 1e bne r14,r0,8007ff4 <_Workspace_Handler_initialization+0x160>
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
}
8007f80: 2b 9d 00 04 lw ra,(sp+4)
8007f84: 2b 8b 00 30 lw r11,(sp+48)
8007f88: 2b 8c 00 2c lw r12,(sp+44)
8007f8c: 2b 8d 00 28 lw r13,(sp+40)
8007f90: 2b 8e 00 24 lw r14,(sp+36)
8007f94: 2b 8f 00 20 lw r15,(sp+32)
8007f98: 2b 90 00 1c lw r16,(sp+28)
8007f9c: 2b 91 00 18 lw r17,(sp+24)
8007fa0: 2b 92 00 14 lw r18,(sp+20)
8007fa4: 2b 93 00 10 lw r19,(sp+16)
8007fa8: 2b 94 00 0c lw r20,(sp+12)
8007fac: 2b 95 00 08 lw r21,(sp+8)
8007fb0: 37 9c 00 30 addi sp,sp,48
8007fb4: c3 a0 00 00 ret
for (i = 0; i < area_count; ++i) {
Heap_Area *area = &areas [i];
if ( do_zero ) {
memset( area->begin, 0, area->size );
8007fb8: 29 61 00 00 lw r1,(r11+0)
8007fbc: 29 63 00 04 lw r3,(r11+4)
8007fc0: 34 02 00 00 mvi r2,0
8007fc4: f8 00 17 e7 calli 800df60 <memset>
8007fc8: e3 ff ff d5 bi 8007f1c <_Workspace_Handler_initialization+0x88>
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
8007fcc: 29 62 00 00 lw r2,(r11+0) <== NOT EXECUTED
8007fd0: ba 20 08 00 mv r1,r17 <== NOT EXECUTED
8007fd4: 34 03 00 00 mvi r3,0 <== NOT EXECUTED
8007fd8: 34 04 00 04 mvi r4,4 <== NOT EXECUTED
8007fdc: d9 e0 00 00 call r15 <== NOT EXECUTED
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
8007fe0: ba 80 78 00 mv r15,r20 <== NOT EXECUTED
8007fe4: e3 ff ff e3 bi 8007f70 <_Workspace_Handler_initialization+0xdc><== NOT EXECUTED
8007fe8: ba 80 78 00 mv r15,r20
area->size -= size;
if ( space_available < remaining ) {
remaining -= space_available;
} else {
remaining = 0;
8007fec: 34 0e 00 00 mvi r14,0
8007ff0: e3 ff ff e0 bi 8007f70 <_Workspace_Handler_initialization+0xdc>
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
_Internal_error_Occurred(
8007ff4: 34 01 00 00 mvi r1,0
8007ff8: 34 02 00 01 mvi r2,1
8007ffc: 34 03 00 02 mvi r3,2
8008000: fb ff f5 27 calli 800549c <_Internal_error_Occurred>
08003c84 <adjtime>:
*/
int adjtime(
const struct timeval *delta,
struct timeval *olddelta
)
{
8003c84: 37 9c ff dc addi sp,sp,-36
8003c88: 5b 8b 00 1c sw (sp+28),r11
8003c8c: 5b 8c 00 18 sw (sp+24),r12
8003c90: 5b 8d 00 14 sw (sp+20),r13
8003c94: 5b 8e 00 10 sw (sp+16),r14
8003c98: 5b 8f 00 0c sw (sp+12),r15
8003c9c: 5b 90 00 08 sw (sp+8),r16
8003ca0: 5b 9d 00 04 sw (sp+4),ra
8003ca4: b8 20 60 00 mv r12,r1
8003ca8: b8 40 70 00 mv r14,r2
long adjustment;
/*
* Simple validations
*/
if ( !delta )
8003cac: 44 20 00 06 be r1,r0,8003cc4 <adjtime+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
8003cb0: 78 03 08 01 mvhi r3,0x801
8003cb4: 38 63 6e 00 ori r3,r3,0x6e00
8003cb8: 28 22 00 04 lw r2,(r1+4)
8003cbc: 28 61 00 00 lw r1,(r3+0)
8003cc0: 50 22 00 0e bgeu r1,r2,8003cf8 <adjtime+0x74>
rtems_set_errno_and_return_minus_one( EINVAL );
8003cc4: f8 00 29 1e calli 800e13c <__errno>
8003cc8: 34 02 00 16 mvi r2,22
8003ccc: 58 22 00 00 sw (r1+0),r2
8003cd0: 34 01 ff ff mvi r1,-1
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
8003cd4: 2b 9d 00 04 lw ra,(sp+4)
8003cd8: 2b 8b 00 1c lw r11,(sp+28)
8003cdc: 2b 8c 00 18 lw r12,(sp+24)
8003ce0: 2b 8d 00 14 lw r13,(sp+20)
8003ce4: 2b 8e 00 10 lw r14,(sp+16)
8003ce8: 2b 8f 00 0c lw r15,(sp+12)
8003cec: 2b 90 00 08 lw r16,(sp+8)
8003cf0: 37 9c 00 24 addi sp,sp,36
8003cf4: c3 a0 00 00 ret
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
8003cf8: 45 c0 00 04 be r14,r0,8003d08 <adjtime+0x84>
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
8003cfc: 59 c0 00 04 sw (r14+4),r0
8003d00: 29 82 00 04 lw r2,(r12+4)
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
olddelta->tv_sec = 0;
8003d04: 59 c0 00 00 sw (r14+0),r0
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
8003d08: 29 83 00 00 lw r3,(r12+0)
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
8003d0c: 78 01 08 01 mvhi r1,0x801
8003d10: 38 21 6a 00 ori r1,r1,0x6a00
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
8003d14: b4 63 20 00 add r4,r3,r3
8003d18: b4 84 20 00 add r4,r4,r4
8003d1c: b4 84 20 00 add r4,r4,r4
8003d20: b4 84 28 00 add r5,r4,r4
8003d24: b4 a5 28 00 add r5,r5,r5
8003d28: b4 a5 28 00 add r5,r5,r5
8003d2c: b4 a5 28 00 add r5,r5,r5
8003d30: b4 a5 28 00 add r5,r5,r5
8003d34: c8 a4 28 00 sub r5,r5,r4
8003d38: b4 a5 20 00 add r4,r5,r5
8003d3c: b4 84 20 00 add r4,r4,r4
8003d40: b4 84 20 00 add r4,r4,r4
8003d44: b4 84 20 00 add r4,r4,r4
8003d48: b4 84 20 00 add r4,r4,r4
8003d4c: b4 84 20 00 add r4,r4,r4
8003d50: c8 85 20 00 sub r4,r4,r5
8003d54: b4 83 18 00 add r3,r4,r3
8003d58: b4 63 18 00 add r3,r3,r3
8003d5c: b4 63 18 00 add r3,r3,r3
8003d60: b4 63 18 00 add r3,r3,r3
8003d64: b4 63 18 00 add r3,r3,r3
8003d68: b4 63 18 00 add r3,r3,r3
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
8003d6c: 28 24 00 0c lw r4,(r1+12)
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
8003d70: b4 63 18 00 add r3,r3,r3
adjustment += delta->tv_usec;
8003d74: b4 43 18 00 add r3,r2,r3
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
return 0;
8003d78: 34 01 00 00 mvi r1,0
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
8003d7c: 54 83 ff d6 bgu r4,r3,8003cd4 <adjtime+0x50>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8003d80: 78 01 08 01 mvhi r1,0x801
8003d84: 38 21 8a 20 ori r1,r1,0x8a20
8003d88: 28 22 00 00 lw r2,(r1+0)
++level;
8003d8c: 34 42 00 01 addi r2,r2,1
_Thread_Dispatch_disable_level = level;
8003d90: 58 22 00 00 sw (r1+0),r2
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
8003d94: 78 02 08 01 mvhi r2,0x801
_TOD_Get_with_nanoseconds( &tod_as_timestamp, &_TOD.now );
8003d98: 37 8f 00 20 addi r15,sp,32
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
8003d9c: 38 42 89 a0 ori r2,r2,0x89a0
8003da0: b9 e0 08 00 mv r1,r15
8003da4: f8 00 07 06 calli 80059bc <_TOD_Get_with_nanoseconds>
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
8003da8: 28 30 00 00 lw r16,(r1+0)
8003dac: 28 2d 00 04 lw r13,(r1+4)
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
8003db0: 78 01 08 01 mvhi r1,0x801
8003db4: 38 21 6d fc ori r1,r1,0x6dfc
8003db8: 28 24 00 00 lw r4,(r1+0)
8003dbc: 34 03 00 00 mvi r3,0
8003dc0: ba 00 08 00 mv r1,r16
8003dc4: b9 a0 10 00 mv r2,r13
8003dc8: f8 00 3f 0e calli 8013a00 <__divdi3>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
8003dcc: 78 03 08 01 mvhi r3,0x801
8003dd0: 38 63 6d fc ori r3,r3,0x6dfc
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
8003dd4: 29 8b 00 00 lw r11,(r12+0)
8003dd8: 28 64 00 00 lw r4,(r3+0)
8003ddc: ba 00 08 00 mv r1,r16
8003de0: 34 03 00 00 mvi r3,0
8003de4: b5 62 58 00 add r11,r11,r2
8003de8: b9 a0 10 00 mv r2,r13
8003dec: f8 00 41 07 calli 8014208 <__moddi3>
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
8003df0: 29 83 00 04 lw r3,(r12+4)
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
8003df4: 78 01 08 01 mvhi r1,0x801
8003df8: 38 21 70 04 ori r1,r1,0x7004
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
8003dfc: b4 63 18 00 add r3,r3,r3
8003e00: b4 63 18 00 add r3,r3,r3
8003e04: b4 63 18 00 add r3,r3,r3
8003e08: b4 63 28 00 add r5,r3,r3
8003e0c: b4 a5 28 00 add r5,r5,r5
8003e10: b4 65 18 00 add r3,r3,r5
8003e14: b4 63 28 00 add r5,r3,r3
8003e18: b4 a5 28 00 add r5,r5,r5
8003e1c: b4 65 18 00 add r3,r3,r5
8003e20: b4 63 28 00 add r5,r3,r3
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
8003e24: 28 24 00 00 lw r4,(r1+0)
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
8003e28: b4 a5 28 00 add r5,r5,r5
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
8003e2c: 78 01 08 01 mvhi r1,0x801
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
8003e30: b4 65 18 00 add r3,r3,r5
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
8003e34: 38 21 70 08 ori r1,r1,0x7008
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
8003e38: b4 43 18 00 add r3,r2,r3
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
8003e3c: 28 22 00 00 lw r2,(r1+0)
8003e40: 54 62 00 bc bgu r3,r2,8004130 <adjtime+0x4ac> <== NEVER TAKEN
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
8003e44: b8 60 68 00 mv r13,r3
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
8003e48: 78 01 08 01 mvhi r1,0x801
8003e4c: 38 21 70 04 ori r1,r1,0x7004
8003e50: 28 22 00 00 lw r2,(r1+0)
8003e54: 54 62 00 08 bgu r3,r2,8003e74 <adjtime+0x1f0> <== NEVER TAKEN
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
8003e58: 78 01 08 01 mvhi r1,0x801
8003e5c: 38 21 6d fc ori r1,r1,0x6dfc
8003e60: 28 24 00 00 lw r4,(r1+0)
8003e64: b4 64 18 00 add r3,r3,r4
8003e68: b8 60 68 00 mv r13,r3
ts.tv_sec--;
8003e6c: 35 6b ff ff addi r11,r11,-1
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
8003e70: 50 43 ff fd bgeu r2,r3,8003e64 <adjtime+0x1e0>
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
8003e74: 34 02 00 1f mvi r2,31
8003e78: b9 60 08 00 mv r1,r11
8003e7c: f8 00 46 ce calli 80159b4 <__ashrsi3>
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
8003e80: b5 6b 10 00 add r2,r11,r11
8003e84: f5 62 28 00 cmpgu r5,r11,r2
8003e88: b8 20 18 00 mv r3,r1
8003e8c: b4 42 20 00 add r4,r2,r2
8003e90: b4 21 08 00 add r1,r1,r1
8003e94: b4 a1 28 00 add r5,r5,r1
8003e98: f4 44 08 00 cmpgu r1,r2,r4
8003e9c: b4 a5 28 00 add r5,r5,r5
8003ea0: b4 84 10 00 add r2,r4,r4
8003ea4: b4 25 08 00 add r1,r1,r5
8003ea8: f4 82 20 00 cmpgu r4,r4,r2
8003eac: b4 42 28 00 add r5,r2,r2
8003eb0: b4 21 08 00 add r1,r1,r1
8003eb4: b4 81 20 00 add r4,r4,r1
8003eb8: f4 45 08 00 cmpgu r1,r2,r5
8003ebc: b4 84 20 00 add r4,r4,r4
8003ec0: c8 ab 10 00 sub r2,r5,r11
8003ec4: b4 24 08 00 add r1,r1,r4
8003ec8: f4 45 28 00 cmpgu r5,r2,r5
8003ecc: b4 42 20 00 add r4,r2,r2
8003ed0: c8 23 08 00 sub r1,r1,r3
8003ed4: c8 25 28 00 sub r5,r1,r5
8003ed8: f4 44 08 00 cmpgu r1,r2,r4
8003edc: b4 a5 28 00 add r5,r5,r5
8003ee0: b4 84 10 00 add r2,r4,r4
8003ee4: f4 82 20 00 cmpgu r4,r4,r2
8003ee8: b4 25 08 00 add r1,r1,r5
8003eec: b4 21 08 00 add r1,r1,r1
8003ef0: b4 42 28 00 add r5,r2,r2
8003ef4: b4 81 30 00 add r6,r4,r1
8003ef8: f4 45 08 00 cmpgu r1,r2,r5
8003efc: c8 ab 20 00 sub r4,r5,r11
8003f00: b4 c6 30 00 add r6,r6,r6
8003f04: f4 85 28 00 cmpgu r5,r4,r5
8003f08: b4 26 08 00 add r1,r1,r6
8003f0c: b4 84 10 00 add r2,r4,r4
8003f10: c8 23 08 00 sub r1,r1,r3
8003f14: c8 25 08 00 sub r1,r1,r5
8003f18: f4 82 20 00 cmpgu r4,r4,r2
8003f1c: b4 42 28 00 add r5,r2,r2
8003f20: b4 21 08 00 add r1,r1,r1
8003f24: b4 81 20 00 add r4,r4,r1
8003f28: f4 45 08 00 cmpgu r1,r2,r5
8003f2c: b4 84 20 00 add r4,r4,r4
8003f30: b4 ab 10 00 add r2,r5,r11
8003f34: b4 24 08 00 add r1,r1,r4
8003f38: f4 a2 28 00 cmpgu r5,r5,r2
8003f3c: b4 42 20 00 add r4,r2,r2
8003f40: b4 23 08 00 add r1,r1,r3
8003f44: b4 a1 28 00 add r5,r5,r1
8003f48: f4 44 08 00 cmpgu r1,r2,r4
8003f4c: b4 a5 28 00 add r5,r5,r5
8003f50: b4 84 10 00 add r2,r4,r4
8003f54: f4 82 20 00 cmpgu r4,r4,r2
8003f58: b4 25 08 00 add r1,r1,r5
8003f5c: b4 21 08 00 add r1,r1,r1
8003f60: b4 42 28 00 add r5,r2,r2
8003f64: b4 81 30 00 add r6,r4,r1
8003f68: f4 45 08 00 cmpgu r1,r2,r5
8003f6c: c8 ab 20 00 sub r4,r5,r11
8003f70: b4 c6 30 00 add r6,r6,r6
8003f74: f4 85 28 00 cmpgu r5,r4,r5
8003f78: b4 26 08 00 add r1,r1,r6
8003f7c: b4 84 10 00 add r2,r4,r4
8003f80: c8 23 08 00 sub r1,r1,r3
8003f84: f4 82 20 00 cmpgu r4,r4,r2
8003f88: c8 25 08 00 sub r1,r1,r5
8003f8c: b4 21 08 00 add r1,r1,r1
8003f90: b4 42 28 00 add r5,r2,r2
8003f94: b4 81 30 00 add r6,r4,r1
8003f98: f4 45 08 00 cmpgu r1,r2,r5
8003f9c: c8 ab 20 00 sub r4,r5,r11
8003fa0: b4 c6 30 00 add r6,r6,r6
8003fa4: f4 85 28 00 cmpgu r5,r4,r5
8003fa8: b4 26 08 00 add r1,r1,r6
8003fac: b4 84 10 00 add r2,r4,r4
8003fb0: c8 23 08 00 sub r1,r1,r3
8003fb4: c8 25 08 00 sub r1,r1,r5
8003fb8: f4 82 20 00 cmpgu r4,r4,r2
8003fbc: b4 42 28 00 add r5,r2,r2
8003fc0: b4 21 08 00 add r1,r1,r1
8003fc4: b4 81 20 00 add r4,r4,r1
8003fc8: f4 45 08 00 cmpgu r1,r2,r5
8003fcc: b4 84 20 00 add r4,r4,r4
8003fd0: c8 ab 10 00 sub r2,r5,r11
8003fd4: b4 24 08 00 add r1,r1,r4
8003fd8: f4 45 28 00 cmpgu r5,r2,r5
8003fdc: b4 42 20 00 add r4,r2,r2
8003fe0: c8 23 08 00 sub r1,r1,r3
8003fe4: c8 25 28 00 sub r5,r1,r5
8003fe8: f4 44 08 00 cmpgu r1,r2,r4
8003fec: b4 a5 28 00 add r5,r5,r5
8003ff0: b4 84 10 00 add r2,r4,r4
8003ff4: f4 82 20 00 cmpgu r4,r4,r2
8003ff8: b4 25 08 00 add r1,r1,r5
8003ffc: b4 21 08 00 add r1,r1,r1
8004000: b4 42 28 00 add r5,r2,r2
8004004: b4 81 30 00 add r6,r4,r1
8004008: f4 45 08 00 cmpgu r1,r2,r5
800400c: b4 ab 20 00 add r4,r5,r11
8004010: b4 c6 30 00 add r6,r6,r6
8004014: b4 26 08 00 add r1,r1,r6
8004018: f4 a4 28 00 cmpgu r5,r5,r4
800401c: b4 84 10 00 add r2,r4,r4
8004020: b4 23 08 00 add r1,r1,r3
8004024: b4 a1 08 00 add r1,r5,r1
8004028: f4 82 20 00 cmpgu r4,r4,r2
800402c: b4 42 28 00 add r5,r2,r2
8004030: b4 21 08 00 add r1,r1,r1
8004034: b4 81 20 00 add r4,r4,r1
8004038: f4 45 10 00 cmpgu r2,r2,r5
800403c: b4 ab 58 00 add r11,r5,r11
8004040: b4 84 20 00 add r4,r4,r4
8004044: b4 44 10 00 add r2,r2,r4
8004048: f4 ab 28 00 cmpgu r5,r5,r11
800404c: b5 6b 20 00 add r4,r11,r11
8004050: b4 43 18 00 add r3,r2,r3
8004054: b4 a3 18 00 add r3,r5,r3
8004058: f5 64 58 00 cmpgu r11,r11,r4
800405c: b4 84 10 00 add r2,r4,r4
8004060: b4 63 18 00 add r3,r3,r3
8004064: f4 82 20 00 cmpgu r4,r4,r2
8004068: b5 63 58 00 add r11,r11,r3
800406c: b5 6b 58 00 add r11,r11,r11
8004070: b4 42 18 00 add r3,r2,r2
8004074: b4 8b 28 00 add r5,r4,r11
8004078: f4 43 20 00 cmpgu r4,r2,r3
800407c: b4 a5 28 00 add r5,r5,r5
8004080: b4 63 10 00 add r2,r3,r3
8004084: f4 62 08 00 cmpgu r1,r3,r2
8004088: b4 85 20 00 add r4,r4,r5
800408c: b4 42 18 00 add r3,r2,r2
8004090: b4 84 20 00 add r4,r4,r4
8004094: f4 43 28 00 cmpgu r5,r2,r3
8004098: b4 24 08 00 add r1,r1,r4
800409c: b4 63 10 00 add r2,r3,r3
80040a0: b4 21 08 00 add r1,r1,r1
80040a4: f4 62 20 00 cmpgu r4,r3,r2
80040a8: b4 a1 28 00 add r5,r5,r1
80040ac: b4 a5 28 00 add r5,r5,r5
80040b0: b4 42 18 00 add r3,r2,r2
80040b4: b4 85 20 00 add r4,r4,r5
80040b8: f4 43 08 00 cmpgu r1,r2,r3
80040bc: b4 84 20 00 add r4,r4,r4
80040c0: b4 63 10 00 add r2,r3,r3
80040c4: b4 24 08 00 add r1,r1,r4
80040c8: f4 62 18 00 cmpgu r3,r3,r2
80040cc: b4 42 58 00 add r11,r2,r2
80040d0: b4 21 08 00 add r1,r1,r1
80040d4: f4 4b 80 00 cmpgu r16,r2,r11
80040d8: b4 61 18 00 add r3,r3,r1
80040dc: b4 63 18 00 add r3,r3,r3
80040e0: 34 02 00 1f mvi r2,31
80040e4: b9 a0 08 00 mv r1,r13
80040e8: b5 6d 68 00 add r13,r11,r13
80040ec: b6 03 80 00 add r16,r16,r3
80040f0: f5 6d 58 00 cmpgu r11,r11,r13
80040f4: f8 00 46 30 calli 80159b4 <__ashrsi3>
80040f8: b6 01 08 00 add r1,r16,r1
80040fc: b5 61 58 00 add r11,r11,r1
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
8004100: b9 e0 08 00 mv r1,r15
8004104: 5b 8b 00 20 sw (sp+32),r11
8004108: 5b 8d 00 24 sw (sp+36),r13
800410c: f8 00 06 56 calli 8005a64 <_TOD_Set_with_timestamp>
ts.tv_sec--;
}
_TOD_Set( &ts );
_Thread_Enable_dispatch();
8004110: f8 00 0d 6d calli 80076c4 <_Thread_Enable_dispatch>
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
8004114: 34 01 00 00 mvi r1,0
_TOD_Set( &ts );
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
8004118: 45 c0 fe ef be r14,r0,8003cd4 <adjtime+0x50> <== NEVER TAKEN
*olddelta = *delta;
800411c: 29 82 00 00 lw r2,(r12+0)
8004120: 59 c2 00 00 sw (r14+0),r2
8004124: 29 82 00 04 lw r2,(r12+4)
8004128: 59 c2 00 04 sw (r14+4),r2
800412c: e3 ff fe ea bi 8003cd4 <adjtime+0x50>
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
8004130: b4 64 18 00 add r3,r3,r4
8004134: b8 60 68 00 mv r13,r3
ts.tv_sec++;
8004138: 35 6b 00 01 addi r11,r11,1
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
800413c: 54 62 ff fd bgu r3,r2,8004130 <adjtime+0x4ac> <== NEVER TAKEN
8004140: e3 ff ff 42 bi 8003e48 <adjtime+0x1c4>
08003f6c <aio_cancel>:
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
8003f6c: 37 9c ff ec addi sp,sp,-20
8003f70: 5b 8b 00 14 sw (sp+20),r11
8003f74: 5b 8c 00 10 sw (sp+16),r12
8003f78: 5b 8d 00 0c sw (sp+12),r13
8003f7c: 5b 8e 00 08 sw (sp+8),r14
8003f80: 5b 9d 00 04 sw (sp+4),ra
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
8003f84: 78 0b 08 01 mvhi r11,0x801
8003f88: 39 6b 88 40 ori r11,r11,0x8840
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
8003f8c: b8 20 68 00 mv r13,r1
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
8003f90: b9 60 08 00 mv r1,r11
#include <stdlib.h>
#include <rtems/system.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
8003f94: b8 40 60 00 mv r12,r2
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
8003f98: f8 00 05 2c calli 8005448 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
8003f9c: b9 a0 08 00 mv r1,r13
8003fa0: 34 02 00 01 mvi r2,1
8003fa4: f8 00 1d 4c calli 800b4d4 <fcntl>
8003fa8: 4c 20 00 08 bge r1,r0,8003fc8 <aio_cancel+0x5c>
pthread_mutex_unlock(&aio_request_queue.mutex);
8003fac: b9 60 08 00 mv r1,r11
8003fb0: f8 00 05 56 calli 8005508 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
8003fb4: f8 00 2d f2 calli 800f77c <__errno>
8003fb8: 34 02 00 09 mvi r2,9
8003fbc: 58 22 00 00 sw (r1+0),r2
8003fc0: 34 0c ff ff mvi r12,-1
8003fc4: e0 00 00 16 bi 800401c <aio_cancel+0xb0>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
8003fc8: 45 80 00 40 be r12,r0,80040c8 <aio_cancel+0x15c> <== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
8003fcc: 29 8e 00 00 lw r14,(r12+0)
8003fd0: 5d cd 00 37 bne r14,r13,80040ac <aio_cancel+0x140> <== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
8003fd4: 78 01 08 01 mvhi r1,0x801
8003fd8: 38 21 88 88 ori r1,r1,0x8888
8003fdc: b9 c0 10 00 mv r2,r14
8003fe0: 34 03 00 00 mvi r3,0
8003fe4: f8 00 01 b5 calli 80046b8 <rtems_aio_search_fd>
8003fe8: b8 20 68 00 mv r13,r1
if (r_chain == NULL) {
8003fec: 44 20 00 14 be r1,r0,800403c <aio_cancel+0xd0>
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
8003ff0: 34 2e 00 1c addi r14,r1,28
8003ff4: b9 c0 08 00 mv r1,r14
8003ff8: f8 00 05 14 calli 8005448 <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
8003ffc: b9 80 10 00 mv r2,r12
8004000: 35 a1 00 08 addi r1,r13,8
8004004: f8 00 02 00 calli 8004804 <rtems_aio_remove_req>
8004008: b8 20 60 00 mv r12,r1
pthread_mutex_unlock (&r_chain->mutex);
800400c: b9 c0 08 00 mv r1,r14
8004010: f8 00 05 3e calli 8005508 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
8004014: b9 60 08 00 mv r1,r11
8004018: f8 00 05 3c calli 8005508 <pthread_mutex_unlock>
return result;
}
return AIO_ALLDONE;
}
800401c: b9 80 08 00 mv r1,r12
8004020: 2b 9d 00 04 lw ra,(sp+4)
8004024: 2b 8b 00 14 lw r11,(sp+20)
8004028: 2b 8c 00 10 lw r12,(sp+16)
800402c: 2b 8d 00 0c lw r13,(sp+12)
8004030: 2b 8e 00 08 lw r14,(sp+8)
8004034: 37 9c 00 14 addi sp,sp,20
8004038: c3 a0 00 00 ret
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
800403c: 29 62 00 54 lw r2,(r11+84)
8004040: 78 01 08 01 mvhi r1,0x801
8004044: 38 21 88 98 ori r1,r1,0x8898
8004048: 44 41 00 15 be r2,r1,800409c <aio_cancel+0x130> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
800404c: 78 01 08 01 mvhi r1,0x801
8004050: 38 21 88 94 ori r1,r1,0x8894
8004054: b9 c0 10 00 mv r2,r14
8004058: 34 03 00 00 mvi r3,0
800405c: f8 00 01 97 calli 80046b8 <rtems_aio_search_fd>
if (r_chain == NULL) {
8004060: 44 20 00 13 be r1,r0,80040ac <aio_cancel+0x140>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
8004064: b9 80 10 00 mv r2,r12
8004068: 34 21 00 08 addi r1,r1,8
800406c: f8 00 01 e6 calli 8004804 <rtems_aio_remove_req>
8004070: b8 20 60 00 mv r12,r1
pthread_mutex_unlock (&aio_request_queue.mutex);
8004074: b9 60 08 00 mv r1,r11
8004078: f8 00 05 24 calli 8005508 <pthread_mutex_unlock>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
return AIO_ALLDONE;
}
800407c: b9 80 08 00 mv r1,r12
8004080: 2b 9d 00 04 lw ra,(sp+4)
8004084: 2b 8b 00 14 lw r11,(sp+20)
8004088: 2b 8c 00 10 lw r12,(sp+16)
800408c: 2b 8d 00 0c lw r13,(sp+12)
8004090: 2b 8e 00 08 lw r14,(sp+8)
8004094: 37 9c 00 14 addi sp,sp,20
8004098: c3 a0 00 00 ret
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
800409c: b9 60 08 00 mv r1,r11
80040a0: f8 00 05 1a calli 8005508 <pthread_mutex_unlock>
return AIO_ALLDONE;
80040a4: 34 0c 00 02 mvi r12,2
80040a8: e3 ff ff dd bi 800401c <aio_cancel+0xb0>
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock (&aio_request_queue.mutex);
80040ac: b9 60 08 00 mv r1,r11
80040b0: f8 00 05 16 calli 8005508 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
80040b4: f8 00 2d b2 calli 800f77c <__errno>
80040b8: 34 02 00 16 mvi r2,22
80040bc: 58 22 00 00 sw (r1+0),r2
80040c0: 34 0c ff ff mvi r12,-1
80040c4: e3 ff ff d6 bi 800401c <aio_cancel+0xb0>
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
80040c8: 78 01 08 01 mvhi r1,0x801
80040cc: 38 21 88 88 ori r1,r1,0x8888
80040d0: b9 a0 10 00 mv r2,r13
80040d4: 34 03 00 00 mvi r3,0
80040d8: f8 00 01 78 calli 80046b8 <rtems_aio_search_fd>
80040dc: b8 20 70 00 mv r14,r1
if (r_chain == NULL) {
80040e0: 44 2c 00 0e be r1,r12,8004118 <aio_cancel+0x1ac>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
80040e4: 34 2c 00 1c addi r12,r1,28
80040e8: b9 80 08 00 mv r1,r12
80040ec: f8 00 04 d7 calli 8005448 <pthread_mutex_lock>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
80040f0: b9 c0 08 00 mv r1,r14
80040f4: f8 00 0b 07 calli 8006d10 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
80040f8: b9 c0 08 00 mv r1,r14
80040fc: f8 00 01 a7 calli 8004798 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
8004100: b9 80 08 00 mv r1,r12
8004104: f8 00 05 01 calli 8005508 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
8004108: b9 60 08 00 mv r1,r11
800410c: f8 00 04 ff calli 8005508 <pthread_mutex_unlock>
return AIO_CANCELED;
8004110: 34 0c 00 00 mvi r12,0
8004114: e3 ff ff c2 bi 800401c <aio_cancel+0xb0>
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
8004118: 29 62 00 54 lw r2,(r11+84)
800411c: 78 01 08 01 mvhi r1,0x801
8004120: 38 21 88 98 ori r1,r1,0x8898
8004124: 44 41 ff de be r2,r1,800409c <aio_cancel+0x130> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
8004128: 78 01 08 01 mvhi r1,0x801
800412c: 38 21 88 94 ori r1,r1,0x8894
8004130: b9 a0 10 00 mv r2,r13
8004134: 34 03 00 00 mvi r3,0
8004138: f8 00 01 60 calli 80046b8 <rtems_aio_search_fd>
800413c: b8 20 60 00 mv r12,r1
if (r_chain == NULL) {
8004140: 44 2e ff d7 be r1,r14,800409c <aio_cancel+0x130>
8004144: f8 00 0a f3 calli 8006d10 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
8004148: b9 80 08 00 mv r1,r12
pthread_mutex_destroy (&r_chain->mutex);
800414c: 35 8d 00 1c addi r13,r12,28
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
8004150: f8 00 01 92 calli 8004798 <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
8004154: b9 a0 08 00 mv r1,r13
8004158: f8 00 03 f4 calli 8005128 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
800415c: b9 a0 08 00 mv r1,r13
8004160: f8 00 02 e1 calli 8004ce4 <pthread_cond_destroy>
free (r_chain);
8004164: b9 80 08 00 mv r1,r12
8004168: fb ff f6 20 calli 80019e8 <free>
pthread_mutex_unlock (&aio_request_queue.mutex);
800416c: b9 60 08 00 mv r1,r11
8004170: f8 00 04 e6 calli 8005508 <pthread_mutex_unlock>
return AIO_CANCELED;
8004174: 34 0c 00 00 mvi r12,0
8004178: e3 ff ff a9 bi 800401c <aio_cancel+0xb0>
08004184 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
8004184: 37 9c ff f4 addi sp,sp,-12
8004188: 5b 8b 00 0c sw (sp+12),r11
800418c: 5b 8c 00 08 sw (sp+8),r12
8004190: 5b 9d 00 04 sw (sp+4),ra
8004194: b8 40 58 00 mv r11,r2
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
8004198: 34 02 20 00 mvi r2,8192
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
800419c: 34 0c 00 16 mvi r12,22
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
80041a0: 5c 22 00 09 bne r1,r2,80041c4 <aio_fsync+0x40>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
80041a4: 29 61 00 00 lw r1,(r11+0)
80041a8: 34 02 00 03 mvi r2,3
80041ac: f8 00 1c ca calli 800b4d4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
80041b0: 20 21 00 03 andi r1,r1,0x3
80041b4: 34 21 ff ff addi r1,r1,-1
80041b8: 34 02 00 01 mvi r2,1
80041bc: 50 41 00 0d bgeu r2,r1,80041f0 <aio_fsync+0x6c>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
80041c0: 34 0c 00 09 mvi r12,9
80041c4: 34 01 ff ff mvi r1,-1
80041c8: 59 6c 00 2c sw (r11+44),r12
80041cc: 59 61 00 30 sw (r11+48),r1
80041d0: f8 00 2d 6b calli 800f77c <__errno>
80041d4: 58 2c 00 00 sw (r1+0),r12
80041d8: 34 01 ff ff mvi r1,-1
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
80041dc: 2b 9d 00 04 lw ra,(sp+4)
80041e0: 2b 8b 00 0c lw r11,(sp+12)
80041e4: 2b 8c 00 08 lw r12,(sp+8)
80041e8: 37 9c 00 0c addi sp,sp,12
80041ec: c3 a0 00 00 ret
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
80041f0: 34 01 00 18 mvi r1,24
80041f4: fb ff f7 6b calli 8001fa0 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
80041f8: 34 0c 00 0b mvi r12,11
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
80041fc: 44 20 ff f2 be r1,r0,80041c4 <aio_fsync+0x40> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
8004200: 34 03 00 03 mvi r3,3
8004204: 59 63 00 28 sw (r11+40),r3
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
8004208: 58 2b 00 14 sw (r1+20),r11
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
800420c: f8 00 01 9d calli 8004880 <rtems_aio_enqueue>
}
8004210: 2b 9d 00 04 lw ra,(sp+4)
8004214: 2b 8b 00 0c lw r11,(sp+12)
8004218: 2b 8c 00 08 lw r12,(sp+8)
800421c: 37 9c 00 0c addi sp,sp,12
8004220: c3 a0 00 00 ret
08004a90 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
8004a90: 37 9c ff f4 addi sp,sp,-12
8004a94: 5b 8b 00 0c sw (sp+12),r11
8004a98: 5b 8c 00 08 sw (sp+8),r12
8004a9c: 5b 9d 00 04 sw (sp+4),ra
8004aa0: b8 20 58 00 mv r11,r1
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
8004aa4: 28 21 00 00 lw r1,(r1+0)
8004aa8: 34 02 00 03 mvi r2,3
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
8004aac: 34 0c 00 09 mvi r12,9
aio_read (struct aiocb *aiocbp)
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
8004ab0: f8 00 1a 89 calli 800b4d4 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
8004ab4: 20 21 00 03 andi r1,r1,0x3
8004ab8: 7c 22 00 02 cmpnei r2,r1,2
8004abc: 7c 21 00 00 cmpnei r1,r1,0
8004ac0: a0 41 08 00 and r1,r2,r1
8004ac4: 5c 20 00 06 bne r1,r0,8004adc <aio_read+0x4c>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
8004ac8: 29 6c 00 10 lw r12,(r11+16)
8004acc: 5d 81 00 03 bne r12,r1,8004ad8 <aio_read+0x48>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
8004ad0: 29 61 00 04 lw r1,(r11+4)
8004ad4: 4c 2c 00 09 bge r1,r12,8004af8 <aio_read+0x68>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
8004ad8: 34 0c 00 16 mvi r12,22
8004adc: 34 01 ff ff mvi r1,-1
8004ae0: 59 6c 00 2c sw (r11+44),r12
8004ae4: 59 61 00 30 sw (r11+48),r1
8004ae8: f8 00 2b 25 calli 800f77c <__errno>
8004aec: 58 2c 00 00 sw (r1+0),r12
8004af0: 34 01 ff ff mvi r1,-1
8004af4: e0 00 00 08 bi 8004b14 <aio_read+0x84>
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
8004af8: 34 01 00 18 mvi r1,24
8004afc: fb ff f5 29 calli 8001fa0 <malloc>
if (req == NULL)
8004b00: 44 2c 00 0a be r1,r12,8004b28 <aio_read+0x98> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
8004b04: 34 03 00 01 mvi r3,1
8004b08: 59 63 00 28 sw (r11+40),r3
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
8004b0c: 58 2b 00 14 sw (r1+20),r11
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
8004b10: fb ff ff 5c calli 8004880 <rtems_aio_enqueue>
}
8004b14: 2b 9d 00 04 lw ra,(sp+4)
8004b18: 2b 8b 00 0c lw r11,(sp+12)
8004b1c: 2b 8c 00 08 lw r12,(sp+8)
8004b20: 37 9c 00 0c addi sp,sp,12
8004b24: c3 a0 00 00 ret
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
8004b28: 34 0c 00 0b mvi r12,11 <== NOT EXECUTED
8004b2c: e3 ff ff ec bi 8004adc <aio_read+0x4c> <== NOT EXECUTED
08004b38 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
8004b38: 37 9c ff f4 addi sp,sp,-12
8004b3c: 5b 8b 00 0c sw (sp+12),r11
8004b40: 5b 8c 00 08 sw (sp+8),r12
8004b44: 5b 9d 00 04 sw (sp+4),ra
8004b48: b8 20 58 00 mv r11,r1
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
8004b4c: 28 21 00 00 lw r1,(r1+0)
8004b50: 34 02 00 03 mvi r2,3
8004b54: f8 00 1a 60 calli 800b4d4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
8004b58: 20 21 00 03 andi r1,r1,0x3
8004b5c: 34 21 ff ff addi r1,r1,-1
8004b60: 34 02 00 01 mvi r2,1
8004b64: 50 41 00 09 bgeu r2,r1,8004b88 <aio_write+0x50>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
8004b68: 34 0c 00 09 mvi r12,9
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
8004b6c: 34 01 ff ff mvi r1,-1
8004b70: 59 6c 00 2c sw (r11+44),r12
8004b74: 59 61 00 30 sw (r11+48),r1
8004b78: f8 00 2b 01 calli 800f77c <__errno>
8004b7c: 58 2c 00 00 sw (r1+0),r12
8004b80: 34 01 ff ff mvi r1,-1
8004b84: e0 00 00 0f bi 8004bc0 <aio_write+0x88>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
8004b88: 29 61 00 10 lw r1,(r11+16)
8004b8c: 5c 20 00 03 bne r1,r0,8004b98 <aio_write+0x60>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
8004b90: 29 62 00 04 lw r2,(r11+4)
8004b94: 4c 41 00 03 bge r2,r1,8004ba0 <aio_write+0x68>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
8004b98: 34 0c 00 16 mvi r12,22
8004b9c: e3 ff ff f4 bi 8004b6c <aio_write+0x34>
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
8004ba0: 34 01 00 18 mvi r1,24
8004ba4: fb ff f4 ff calli 8001fa0 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
8004ba8: 34 0c 00 0b mvi r12,11
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
8004bac: 44 20 ff f0 be r1,r0,8004b6c <aio_write+0x34> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
8004bb0: 34 03 00 02 mvi r3,2
8004bb4: 59 63 00 28 sw (r11+40),r3
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
8004bb8: 58 2b 00 14 sw (r1+20),r11
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
8004bbc: fb ff ff 31 calli 8004880 <rtems_aio_enqueue>
}
8004bc0: 2b 9d 00 04 lw ra,(sp+4)
8004bc4: 2b 8b 00 0c lw r11,(sp+12)
8004bc8: 2b 8c 00 08 lw r12,(sp+8)
8004bcc: 37 9c 00 0c addi sp,sp,12
8004bd0: c3 a0 00 00 ret
080049f4 <check_and_merge>:
rtems_chain_control *free_chain,
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
80049f4: 37 9c ff fc addi sp,sp,-4
80049f8: 5b 9d 00 04 sw (sp+4),ra
80049fc: b8 20 28 00 mv r5,r1
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
8004a00: 34 01 ff f8 mvi r1,-8
8004a04: 44 81 00 15 be r4,r1,8004a58 <check_and_merge+0x64>
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
if (chunk != NULL) {
rtems_rbheap_add_to_spare_descriptor_chain(control, chunk);
}
}
8004a08: 28 86 00 00 lw r6,(r4+0)
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
8004a0c: 44 c0 00 1b be r6,r0,8004a78 <check_and_merge+0x84>
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
if (b->begin < a->begin) {
8004a10: 28 81 00 18 lw r1,(r4+24)
8004a14: 28 67 00 18 lw r7,(r3+24)
8004a18: 54 e1 00 13 bgu r7,r1,8004a64 <check_and_merge+0x70>
a = b;
b = t;
}
a->size += b->size;
8004a1c: 28 69 00 1c lw r9,(r3+28)
8004a20: 28 88 00 1c lw r8,(r4+28)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
8004a24: 28 87 00 04 lw r7,(r4+4)
rtems_chain_extract_unprotected(&b->chain_node);
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
8004a28: b8 40 08 00 mv r1,r2
a = b;
b = t;
}
a->size += b->size;
8004a2c: b5 28 10 00 add r2,r9,r8
8004a30: 58 62 00 1c sw (r3+28),r2
next->previous = previous;
previous->next = next;
8004a34: 58 e6 00 00 sw (r7+0),r6
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
8004a38: 28 a2 00 00 lw r2,(r5+0)
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
8004a3c: 58 c7 00 04 sw (r6+4),r7
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
8004a40: 58 85 00 04 sw (r4+4),r5
before_node = after_node->next;
after_node->next = the_node;
8004a44: 58 a4 00 00 sw (r5+0),r4
the_node->next = before_node;
8004a48: 58 82 00 00 sw (r4+0),r2
before_node->previous = the_node;
8004a4c: 58 44 00 04 sw (r2+4),r4
rtems_chain_extract_unprotected(&b->chain_node);
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
8004a50: 34 82 00 08 addi r2,r4,8
8004a54: f8 00 07 b2 calli 800691c <_RBTree_Extract_unprotected>
}
}
8004a58: 2b 9d 00 04 lw ra,(sp+4)
8004a5c: 37 9c 00 04 addi sp,sp,4
8004a60: c3 a0 00 00 ret
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
if (b->begin < a->begin) {
8004a64: b8 60 08 00 mv r1,r3
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
8004a68: 28 66 00 00 lw r6,(r3+0)
8004a6c: b8 80 18 00 mv r3,r4
8004a70: b8 20 20 00 mv r4,r1
8004a74: e3 ff ff ea bi 8004a1c <check_and_merge+0x28>
8004a78: 28 81 00 04 lw r1,(r4+4)
8004a7c: 5c 26 ff e5 bne r1,r6,8004a10 <check_and_merge+0x1c> <== NEVER TAKEN
8004a80: e3 ff ff f6 bi 8004a58 <check_and_merge+0x64>
08003a90 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
8003a90: 37 9c ff e8 addi sp,sp,-24
8003a94: 5b 8b 00 10 sw (sp+16),r11
8003a98: 5b 8c 00 0c sw (sp+12),r12
8003a9c: 5b 8d 00 08 sw (sp+8),r13
8003aa0: 5b 9d 00 04 sw (sp+4),ra
8003aa4: b8 40 58 00 mv r11,r2
if ( !tp )
8003aa8: 44 40 00 09 be r2,r0,8003acc <clock_gettime+0x3c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
8003aac: 34 02 00 01 mvi r2,1
8003ab0: 44 22 00 24 be r1,r2,8003b40 <clock_gettime+0xb0>
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
8003ab4: 34 02 00 04 mvi r2,4
8003ab8: 44 22 00 19 be r1,r2,8003b1c <clock_gettime+0x8c> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
8003abc: 34 02 00 02 mvi r2,2
8003ac0: 44 22 00 17 be r1,r2,8003b1c <clock_gettime+0x8c>
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
8003ac4: 34 02 00 03 mvi r2,3
8003ac8: 44 22 00 0b be r1,r2,8003af4 <clock_gettime+0x64>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
8003acc: f8 00 2a 39 calli 800e3b0 <__errno>
8003ad0: 34 02 00 16 mvi r2,22
8003ad4: 58 22 00 00 sw (r1+0),r2
8003ad8: 34 01 ff ff mvi r1,-1
return 0;
}
8003adc: 2b 9d 00 04 lw ra,(sp+4)
8003ae0: 2b 8b 00 10 lw r11,(sp+16)
8003ae4: 2b 8c 00 0c lw r12,(sp+12)
8003ae8: 2b 8d 00 08 lw r13,(sp+8)
8003aec: 37 9c 00 18 addi sp,sp,24
8003af0: c3 a0 00 00 ret
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
8003af4: f8 00 2a 2f calli 800e3b0 <__errno>
8003af8: 34 02 00 58 mvi r2,88
8003afc: 58 22 00 00 sw (r1+0),r2
8003b00: 34 01 ff ff mvi r1,-1
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
8003b04: 2b 9d 00 04 lw ra,(sp+4)
8003b08: 2b 8b 00 10 lw r11,(sp+16)
8003b0c: 2b 8c 00 0c lw r12,(sp+12)
8003b10: 2b 8d 00 08 lw r13,(sp+8)
8003b14: 37 9c 00 18 addi sp,sp,24
8003b18: c3 a0 00 00 ret
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
_TOD_Get_uptime_as_timespec( tp );
8003b1c: b9 60 08 00 mv r1,r11
8003b20: f8 00 08 67 calli 8005cbc <_TOD_Get_uptime_as_timespec>
return 0;
8003b24: 34 01 00 00 mvi r1,0
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
8003b28: 2b 9d 00 04 lw ra,(sp+4)
8003b2c: 2b 8b 00 10 lw r11,(sp+16)
8003b30: 2b 8c 00 0c lw r12,(sp+12)
8003b34: 2b 8d 00 08 lw r13,(sp+8)
8003b38: 37 9c 00 18 addi sp,sp,24
8003b3c: c3 a0 00 00 ret
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
8003b40: 78 02 08 01 mvhi r2,0x801
8003b44: 38 42 98 b8 ori r2,r2,0x98b8
8003b48: 37 81 00 14 addi r1,sp,20
8003b4c: f8 00 08 3e calli 8005c44 <_TOD_Get_with_nanoseconds>
8003b50: 28 2d 00 00 lw r13,(r1+0)
8003b54: 28 2c 00 04 lw r12,(r1+4)
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
8003b58: 78 01 08 01 mvhi r1,0x801
8003b5c: 38 21 79 10 ori r1,r1,0x7910
8003b60: 28 24 00 00 lw r4,(r1+0)
8003b64: 34 03 00 00 mvi r3,0
8003b68: b9 a0 08 00 mv r1,r13
8003b6c: b9 80 10 00 mv r2,r12
8003b70: f8 00 42 71 calli 8014534 <__divdi3>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
8003b74: 78 01 08 01 mvhi r1,0x801
8003b78: 38 21 79 10 ori r1,r1,0x7910
8003b7c: 28 24 00 00 lw r4,(r1+0)
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
8003b80: 59 62 00 00 sw (r11+0),r2
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
8003b84: b9 a0 08 00 mv r1,r13
8003b88: b9 80 10 00 mv r2,r12
8003b8c: 34 03 00 00 mvi r3,0
8003b90: f8 00 44 6b calli 8014d3c <__moddi3>
8003b94: 59 62 00 04 sw (r11+4),r2
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
return 0;
8003b98: 34 01 00 00 mvi r1,0
8003b9c: e3 ff ff d0 bi 8003adc <clock_gettime+0x4c>
08027d78 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
8027d78: 37 9c ff e8 addi sp,sp,-24
8027d7c: 5b 8b 00 10 sw (sp+16),r11
8027d80: 5b 8c 00 0c sw (sp+12),r12
8027d84: 5b 8d 00 08 sw (sp+8),r13
8027d88: 5b 9d 00 04 sw (sp+4),ra
8027d8c: b8 40 60 00 mv r12,r2
if ( !tp )
8027d90: 44 40 00 07 be r2,r0,8027dac <clock_settime+0x34> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
8027d94: 34 02 00 01 mvi r2,1
8027d98: 44 22 00 0f be r1,r2,8027dd4 <clock_settime+0x5c>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
8027d9c: 34 02 00 02 mvi r2,2
8027da0: 44 22 00 c8 be r1,r2,80280c0 <clock_settime+0x348>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
8027da4: 34 02 00 03 mvi r2,3
8027da8: 44 22 00 c6 be r1,r2,80280c0 <clock_settime+0x348>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
8027dac: f8 00 56 9c calli 803d81c <__errno>
8027db0: 34 02 00 16 mvi r2,22
8027db4: 58 22 00 00 sw (r1+0),r2
8027db8: 34 01 ff ff mvi r1,-1
return 0;
}
8027dbc: 2b 9d 00 04 lw ra,(sp+4)
8027dc0: 2b 8b 00 10 lw r11,(sp+16)
8027dc4: 2b 8c 00 0c lw r12,(sp+12)
8027dc8: 2b 8d 00 08 lw r13,(sp+8)
8027dcc: 37 9c 00 18 addi sp,sp,24
8027dd0: c3 a0 00 00 ret
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
8027dd4: 78 03 08 06 mvhi r3,0x806
8027dd8: 38 63 4e 10 ori r3,r3,0x4e10
8027ddc: 29 82 00 00 lw r2,(r12+0)
8027de0: 28 61 00 00 lw r1,(r3+0)
8027de4: 54 41 00 02 bgu r2,r1,8027dec <clock_settime+0x74>
8027de8: e3 ff ff f1 bi 8027dac <clock_settime+0x34>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8027dec: 78 01 08 06 mvhi r1,0x806
8027df0: 38 21 f0 60 ori r1,r1,0xf060
8027df4: 28 22 00 00 lw r2,(r1+0)
++level;
8027df8: 34 42 00 01 addi r2,r2,1
_Thread_Dispatch_disable_level = level;
8027dfc: 58 22 00 00 sw (r1+0),r2
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
8027e00: 29 8b 00 00 lw r11,(r12+0)
8027e04: 34 02 00 1f mvi r2,31
8027e08: b9 60 08 00 mv r1,r11
8027e0c: f8 00 d4 a4 calli 805d09c <__ashrsi3>
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
8027e10: b5 6b 10 00 add r2,r11,r11
8027e14: f5 62 28 00 cmpgu r5,r11,r2
8027e18: b4 42 18 00 add r3,r2,r2
8027e1c: b4 21 20 00 add r4,r1,r1
8027e20: b4 a4 20 00 add r4,r5,r4
8027e24: f4 43 28 00 cmpgu r5,r2,r3
8027e28: b4 84 20 00 add r4,r4,r4
8027e2c: b4 63 10 00 add r2,r3,r3
8027e30: b4 a4 28 00 add r5,r5,r4
8027e34: f4 62 18 00 cmpgu r3,r3,r2
8027e38: b4 42 20 00 add r4,r2,r2
8027e3c: b4 a5 28 00 add r5,r5,r5
8027e40: b4 65 18 00 add r3,r3,r5
8027e44: f4 44 28 00 cmpgu r5,r2,r4
8027e48: b4 63 18 00 add r3,r3,r3
8027e4c: c8 8b 10 00 sub r2,r4,r11
8027e50: b4 a3 28 00 add r5,r5,r3
8027e54: f4 44 20 00 cmpgu r4,r2,r4
8027e58: b4 42 18 00 add r3,r2,r2
8027e5c: c8 a1 28 00 sub r5,r5,r1
8027e60: c8 a4 20 00 sub r4,r5,r4
8027e64: f4 43 28 00 cmpgu r5,r2,r3
8027e68: b4 84 20 00 add r4,r4,r4
8027e6c: b4 63 10 00 add r2,r3,r3
8027e70: f4 62 18 00 cmpgu r3,r3,r2
8027e74: b4 a4 28 00 add r5,r5,r4
8027e78: b4 a5 28 00 add r5,r5,r5
8027e7c: b4 42 20 00 add r4,r2,r2
8027e80: b4 65 30 00 add r6,r3,r5
8027e84: f4 44 28 00 cmpgu r5,r2,r4
8027e88: c8 8b 18 00 sub r3,r4,r11
8027e8c: b4 c6 30 00 add r6,r6,r6
8027e90: f4 64 20 00 cmpgu r4,r3,r4
8027e94: b4 a6 28 00 add r5,r5,r6
8027e98: b4 63 10 00 add r2,r3,r3
8027e9c: c8 a1 28 00 sub r5,r5,r1
8027ea0: c8 a4 28 00 sub r5,r5,r4
8027ea4: f4 62 18 00 cmpgu r3,r3,r2
8027ea8: b4 42 20 00 add r4,r2,r2
8027eac: b4 a5 28 00 add r5,r5,r5
8027eb0: b4 65 18 00 add r3,r3,r5
8027eb4: f4 44 28 00 cmpgu r5,r2,r4
8027eb8: b4 63 18 00 add r3,r3,r3
8027ebc: b4 8b 10 00 add r2,r4,r11
8027ec0: b4 a3 28 00 add r5,r5,r3
8027ec4: f4 82 20 00 cmpgu r4,r4,r2
8027ec8: b4 42 18 00 add r3,r2,r2
8027ecc: b4 a1 28 00 add r5,r5,r1
8027ed0: b4 85 20 00 add r4,r4,r5
8027ed4: f4 43 28 00 cmpgu r5,r2,r3
8027ed8: b4 84 20 00 add r4,r4,r4
8027edc: b4 63 10 00 add r2,r3,r3
8027ee0: f4 62 18 00 cmpgu r3,r3,r2
8027ee4: b4 a4 28 00 add r5,r5,r4
8027ee8: b4 a5 28 00 add r5,r5,r5
8027eec: b4 42 20 00 add r4,r2,r2
8027ef0: b4 65 30 00 add r6,r3,r5
8027ef4: f4 44 28 00 cmpgu r5,r2,r4
8027ef8: c8 8b 18 00 sub r3,r4,r11
8027efc: b4 c6 30 00 add r6,r6,r6
8027f00: f4 64 20 00 cmpgu r4,r3,r4
8027f04: b4 a6 28 00 add r5,r5,r6
8027f08: b4 63 10 00 add r2,r3,r3
8027f0c: c8 a1 28 00 sub r5,r5,r1
8027f10: f4 62 18 00 cmpgu r3,r3,r2
8027f14: c8 a4 28 00 sub r5,r5,r4
8027f18: b4 a5 28 00 add r5,r5,r5
8027f1c: b4 42 20 00 add r4,r2,r2
8027f20: b4 65 30 00 add r6,r3,r5
8027f24: f4 44 28 00 cmpgu r5,r2,r4
8027f28: c8 8b 18 00 sub r3,r4,r11
8027f2c: b4 c6 30 00 add r6,r6,r6
8027f30: f4 64 20 00 cmpgu r4,r3,r4
8027f34: b4 a6 28 00 add r5,r5,r6
8027f38: b4 63 10 00 add r2,r3,r3
8027f3c: c8 a1 28 00 sub r5,r5,r1
8027f40: c8 a4 28 00 sub r5,r5,r4
8027f44: f4 62 18 00 cmpgu r3,r3,r2
8027f48: b4 42 20 00 add r4,r2,r2
8027f4c: b4 a5 28 00 add r5,r5,r5
8027f50: b4 65 18 00 add r3,r3,r5
8027f54: f4 44 28 00 cmpgu r5,r2,r4
8027f58: b4 63 18 00 add r3,r3,r3
8027f5c: c8 8b 10 00 sub r2,r4,r11
8027f60: b4 a3 28 00 add r5,r5,r3
8027f64: f4 44 20 00 cmpgu r4,r2,r4
8027f68: b4 42 18 00 add r3,r2,r2
8027f6c: c8 a1 28 00 sub r5,r5,r1
8027f70: c8 a4 20 00 sub r4,r5,r4
8027f74: f4 43 28 00 cmpgu r5,r2,r3
8027f78: b4 84 20 00 add r4,r4,r4
8027f7c: b4 63 10 00 add r2,r3,r3
8027f80: f4 62 18 00 cmpgu r3,r3,r2
8027f84: b4 a4 28 00 add r5,r5,r4
8027f88: b4 a5 28 00 add r5,r5,r5
8027f8c: b4 42 20 00 add r4,r2,r2
8027f90: b4 65 30 00 add r6,r3,r5
8027f94: f4 44 28 00 cmpgu r5,r2,r4
8027f98: b4 c6 30 00 add r6,r6,r6
8027f9c: b4 8b 18 00 add r3,r4,r11
8027fa0: b4 a6 28 00 add r5,r5,r6
8027fa4: f4 83 20 00 cmpgu r4,r4,r3
8027fa8: b4 63 10 00 add r2,r3,r3
8027fac: b4 a1 28 00 add r5,r5,r1
8027fb0: b4 85 28 00 add r5,r4,r5
8027fb4: f4 62 18 00 cmpgu r3,r3,r2
8027fb8: b4 42 20 00 add r4,r2,r2
8027fbc: b4 a5 28 00 add r5,r5,r5
8027fc0: f4 44 10 00 cmpgu r2,r2,r4
8027fc4: b4 65 18 00 add r3,r3,r5
8027fc8: b4 8b 58 00 add r11,r4,r11
8027fcc: b4 63 18 00 add r3,r3,r3
8027fd0: b4 43 18 00 add r3,r2,r3
8027fd4: f4 8b 20 00 cmpgu r4,r4,r11
8027fd8: b5 6b 10 00 add r2,r11,r11
8027fdc: b4 61 08 00 add r1,r3,r1
8027fe0: f5 62 58 00 cmpgu r11,r11,r2
8027fe4: b4 81 20 00 add r4,r4,r1
8027fe8: b4 42 18 00 add r3,r2,r2
8027fec: b4 84 20 00 add r4,r4,r4
8027ff0: b5 64 08 00 add r1,r11,r4
8027ff4: f4 43 58 00 cmpgu r11,r2,r3
8027ff8: b4 21 08 00 add r1,r1,r1
8027ffc: b4 63 10 00 add r2,r3,r3
8028000: f4 62 18 00 cmpgu r3,r3,r2
8028004: b5 61 58 00 add r11,r11,r1
8028008: b5 6b 58 00 add r11,r11,r11
802800c: b4 42 08 00 add r1,r2,r2
8028010: b4 6b 20 00 add r4,r3,r11
8028014: f4 41 18 00 cmpgu r3,r2,r1
8028018: b4 84 20 00 add r4,r4,r4
802801c: b4 21 10 00 add r2,r1,r1
8028020: f4 22 28 00 cmpgu r5,r1,r2
8028024: b4 64 18 00 add r3,r3,r4
8028028: b4 42 08 00 add r1,r2,r2
802802c: b4 63 18 00 add r3,r3,r3
8028030: f4 41 10 00 cmpgu r2,r2,r1
8028034: b4 a3 28 00 add r5,r5,r3
8028038: b4 a5 28 00 add r5,r5,r5
802803c: b4 21 18 00 add r3,r1,r1
8028040: b4 45 20 00 add r4,r2,r5
8028044: f4 23 08 00 cmpgu r1,r1,r3
8028048: b4 63 10 00 add r2,r3,r3
802804c: b4 84 20 00 add r4,r4,r4
8028050: 29 8c 00 04 lw r12,(r12+4)
8028054: b4 24 08 00 add r1,r1,r4
8028058: f4 62 18 00 cmpgu r3,r3,r2
802805c: b4 42 58 00 add r11,r2,r2
8028060: b4 21 08 00 add r1,r1,r1
8028064: f4 4b 68 00 cmpgu r13,r2,r11
8028068: b4 61 18 00 add r3,r3,r1
802806c: b4 63 18 00 add r3,r3,r3
8028070: 34 02 00 1f mvi r2,31
8028074: b9 80 08 00 mv r1,r12
8028078: b5 a3 68 00 add r13,r13,r3
802807c: f8 00 d4 08 calli 805d09c <__ashrsi3>
8028080: b5 6c 20 00 add r4,r11,r12
8028084: f5 64 58 00 cmpgu r11,r11,r4
8028088: b5 a1 08 00 add r1,r13,r1
802808c: b5 61 58 00 add r11,r11,r1
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
8028090: 37 81 00 14 addi r1,sp,20
8028094: 5b 84 00 18 sw (sp+24),r4
8028098: 5b 8b 00 14 sw (sp+20),r11
802809c: f8 00 06 5f calli 8029a18 <_TOD_Set_with_timestamp>
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
80280a0: fb ff 78 16 calli 80060f8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
80280a4: 34 01 00 00 mvi r1,0
}
80280a8: 2b 9d 00 04 lw ra,(sp+4)
80280ac: 2b 8b 00 10 lw r11,(sp+16)
80280b0: 2b 8c 00 0c lw r12,(sp+12)
80280b4: 2b 8d 00 08 lw r13,(sp+8)
80280b8: 37 9c 00 18 addi sp,sp,24
80280bc: c3 a0 00 00 ret
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
rtems_set_errno_and_return_minus_one( ENOSYS );
80280c0: f8 00 55 d7 calli 803d81c <__errno>
80280c4: 34 02 00 58 mvi r2,88
80280c8: 58 22 00 00 sw (r1+0),r2
80280cc: 34 01 ff ff mvi r1,-1
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
80280d0: 2b 9d 00 04 lw ra,(sp+4)
80280d4: 2b 8b 00 10 lw r11,(sp+16)
80280d8: 2b 8c 00 0c lw r12,(sp+12)
80280dc: 2b 8d 00 08 lw r13,(sp+8)
80280e0: 37 9c 00 18 addi sp,sp,24
80280e4: c3 a0 00 00 ret
0801c764 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
801c764: 37 9c ff d8 addi sp,sp,-40
801c768: 5b 8b 00 1c sw (sp+28),r11
801c76c: 5b 8c 00 18 sw (sp+24),r12
801c770: 5b 8d 00 14 sw (sp+20),r13
801c774: 5b 8e 00 10 sw (sp+16),r14
801c778: 5b 8f 00 0c sw (sp+12),r15
801c77c: 5b 90 00 08 sw (sp+8),r16
801c780: 5b 9d 00 04 sw (sp+4),ra
801c784: b8 20 58 00 mv r11,r1
801c788: b8 40 60 00 mv r12,r2
801c78c: b8 60 70 00 mv r14,r3
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
801c790: fb ff fe f0 calli 801c350 <getpid>
801c794: 5c 2b 00 a8 bne r1,r11,801ca34 <killinfo+0x2d0>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
801c798: 45 80 00 04 be r12,r0,801c7a8 <killinfo+0x44>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
801c79c: 35 82 ff ff addi r2,r12,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
801c7a0: 34 01 00 1f mvi r1,31
801c7a4: 50 22 00 0e bgeu r1,r2,801c7dc <killinfo+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
801c7a8: fb ff c2 b3 calli 800d274 <__errno>
801c7ac: 34 02 00 16 mvi r2,22
801c7b0: 58 22 00 00 sw (r1+0),r2
801c7b4: 34 01 ff ff mvi r1,-1
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
801c7b8: 2b 9d 00 04 lw ra,(sp+4)
801c7bc: 2b 8b 00 1c lw r11,(sp+28)
801c7c0: 2b 8c 00 18 lw r12,(sp+24)
801c7c4: 2b 8d 00 14 lw r13,(sp+20)
801c7c8: 2b 8e 00 10 lw r14,(sp+16)
801c7cc: 2b 8f 00 0c lw r15,(sp+12)
801c7d0: 2b 90 00 08 lw r16,(sp+8)
801c7d4: 37 9c 00 28 addi sp,sp,40
801c7d8: c3 a0 00 00 ret
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
801c7dc: b5 8c 80 00 add r16,r12,r12
801c7e0: b6 0c 08 00 add r1,r16,r12
801c7e4: 78 0d 08 02 mvhi r13,0x802
801c7e8: b4 21 08 00 add r1,r1,r1
801c7ec: 39 ad 0e 68 ori r13,r13,0xe68
801c7f0: b4 21 08 00 add r1,r1,r1
801c7f4: b5 a1 08 00 add r1,r13,r1
801c7f8: 28 23 00 08 lw r3,(r1+8)
801c7fc: 34 0f 00 01 mvi r15,1
return 0;
801c800: 34 01 00 00 mvi r1,0
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
801c804: 44 6f ff ed be r3,r15,801c7b8 <killinfo+0x54>
/*
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
801c808: 65 83 00 04 cmpei r3,r12,4
801c80c: 65 81 00 08 cmpei r1,r12,8
801c810: b8 61 08 00 or r1,r3,r1
801c814: 5c 20 00 42 bne r1,r0,801c91c <killinfo+0x1b8>
801c818: 34 01 00 0b mvi r1,11
801c81c: 45 81 00 40 be r12,r1,801c91c <killinfo+0x1b8>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
801c820: 34 01 00 01 mvi r1,1
801c824: fb ff fd 1f calli 801bca0 <__ashlsi3>
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
801c828: 5b 8c 00 20 sw (sp+32),r12
siginfo->si_code = SI_USER;
801c82c: 5b 8f 00 24 sw (sp+36),r15
801c830: b8 20 58 00 mv r11,r1
if ( !value ) {
801c834: 45 c0 00 3e be r14,r0,801c92c <killinfo+0x1c8>
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
801c838: 29 c1 00 00 lw r1,(r14+0)
801c83c: 5b 81 00 28 sw (sp+40),r1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
801c840: 78 01 08 02 mvhi r1,0x802
801c844: 38 21 09 58 ori r1,r1,0x958
801c848: 28 22 00 00 lw r2,(r1+0)
++level;
801c84c: 34 42 00 01 addi r2,r2,1
_Thread_Dispatch_disable_level = level;
801c850: 58 22 00 00 sw (r1+0),r2
*/
void _POSIX_signals_Manager_Initialization(void);
static inline void _POSIX_signals_Add_post_switch_extension(void)
{
_API_extensions_Add_post_switch( &_POSIX_signals_Post_switch );
801c854: 78 01 08 02 mvhi r1,0x802
801c858: 38 21 01 bc ori r1,r1,0x1bc
801c85c: fb ff 9f b8 calli 800473c <_API_extensions_Add_post_switch>
/*
* Is the currently executing thread interested? If so then it will
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Thread_Executing;
801c860: 78 01 08 02 mvhi r1,0x802
801c864: 38 21 0d e0 ori r1,r1,0xde0
801c868: 28 21 00 10 lw r1,(r1+16)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
801c86c: 28 22 01 1c lw r2,(r1+284)
801c870: 28 42 00 d0 lw r2,(r2+208)
801c874: a4 40 10 00 not r2,r2
801c878: a1 62 10 00 and r2,r11,r2
801c87c: 5c 40 00 18 bne r2,r0,801c8dc <killinfo+0x178>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
801c880: 78 01 08 02 mvhi r1,0x802
801c884: 38 21 0f f4 ori r1,r1,0xff4
801c888: 28 23 00 00 lw r3,(r1+0)
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
801c88c: 78 04 08 02 mvhi r4,0x802
801c890: 38 84 0f f8 ori r4,r4,0xff8
801c894: 44 64 00 28 be r3,r4,801c934 <killinfo+0x1d0>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
801c898: 28 62 00 30 lw r2,(r3+48)
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
801c89c: b8 60 08 00 mv r1,r3
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
801c8a0: 28 65 01 1c lw r5,(r3+284)
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
801c8a4: a1 62 10 00 and r2,r11,r2
801c8a8: 44 40 00 09 be r2,r0,801c8cc <killinfo+0x168>
801c8ac: e0 00 00 0c bi 801c8dc <killinfo+0x178>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
801c8b0: 28 63 00 00 lw r3,(r3+0)
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
801c8b4: 44 64 00 20 be r3,r4,801c934 <killinfo+0x1d0> <== ALWAYS TAKEN
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
801c8b8: 28 62 00 30 lw r2,(r3+48) <== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
801c8bc: 28 65 01 1c lw r5,(r3+284) <== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
801c8c0: b8 60 08 00 mv r1,r3 <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
801c8c4: a1 62 10 00 and r2,r11,r2 <== NOT EXECUTED
801c8c8: 5c 40 00 05 bne r2,r0,801c8dc <killinfo+0x178> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
801c8cc: 28 a5 00 d0 lw r5,(r5+208)
801c8d0: a4 a0 28 00 not r5,r5
801c8d4: a1 65 28 00 and r5,r11,r5
801c8d8: 44 a2 ff f6 be r5,r2,801c8b0 <killinfo+0x14c>
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
801c8dc: b9 80 10 00 mv r2,r12
801c8e0: 37 83 00 20 addi r3,sp,32
801c8e4: f8 00 00 6a calli 801ca8c <_POSIX_signals_Unblock_thread>
801c8e8: 5c 20 00 0a bne r1,r0,801c910 <killinfo+0x1ac>
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
801c8ec: b9 60 08 00 mv r1,r11
801c8f0: f8 00 00 5c calli 801ca60 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
801c8f4: b6 0c 60 00 add r12,r16,r12
801c8f8: b5 8c 08 00 add r1,r12,r12
801c8fc: b4 21 08 00 add r1,r1,r1
801c900: b5 a1 68 00 add r13,r13,r1
801c904: 29 a2 00 00 lw r2,(r13+0)
801c908: 34 01 00 02 mvi r1,2
801c90c: 44 41 00 38 be r2,r1,801c9ec <killinfo+0x288>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
801c910: fb ff a8 c9 calli 8006c34 <_Thread_Enable_dispatch>
return 0;
801c914: 34 01 00 00 mvi r1,0
801c918: e3 ff ff a8 bi 801c7b8 <killinfo+0x54>
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
return pthread_kill( pthread_self(), sig );
801c91c: f8 00 01 0b calli 801cd48 <pthread_self>
801c920: b9 80 10 00 mv r2,r12
801c924: f8 00 00 bd calli 801cc18 <pthread_kill>
801c928: e3 ff ff a4 bi 801c7b8 <killinfo+0x54>
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
801c92c: 5b 80 00 28 sw (sp+40),r0
801c930: e3 ff ff c4 bi 801c840 <killinfo+0xdc>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
801c934: 78 01 08 02 mvhi r1,0x802
801c938: 38 21 00 d8 ori r1,r1,0xd8
801c93c: 40 26 00 00 lbu r6,(r1+0)
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
801c940: 78 01 08 02 mvhi r1,0x802
801c944: 38 21 08 f4 ori r1,r1,0x8f4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
801c948: 78 08 08 02 mvhi r8,0x802
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
801c94c: 34 2a 00 10 addi r10,r1,16
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
801c950: 34 c6 00 01 addi r6,r6,1
801c954: 39 08 08 fc ori r8,r8,0x8fc
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
801c958: 34 01 00 00 mvi r1,0
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
801c95c: 78 0f 10 00 mvhi r15,0x1000
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
801c960: 29 02 00 00 lw r2,(r8+0)
801c964: 44 40 00 1e be r2,r0,801c9dc <killinfo+0x278> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
801c968: 28 42 00 04 lw r2,(r2+4)
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
801c96c: 2c 47 00 10 lhu r7,(r2+16)
object_table = the_info->local_table;
801c970: 28 44 00 1c lw r4,(r2+28)
for ( index = 1 ; index <= maximum ; index++ ) {
801c974: 44 e0 00 1a be r7,r0,801c9dc <killinfo+0x278>
801c978: 34 03 00 01 mvi r3,1
the_thread = (Thread_Control *) object_table[ index ];
801c97c: 28 82 00 04 lw r2,(r4+4)
if ( !the_thread )
801c980: 44 40 00 14 be r2,r0,801c9d0 <killinfo+0x26c>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
801c984: 28 45 00 14 lw r5,(r2+20)
801c988: 54 a6 00 12 bgu r5,r6,801c9d0 <killinfo+0x26c>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
801c98c: 28 49 01 1c lw r9,(r2+284)
801c990: 29 29 00 d0 lw r9,(r9+208)
801c994: a5 20 48 00 not r9,r9
801c998: a1 69 48 00 and r9,r11,r9
801c99c: 45 20 00 0d be r9,r0,801c9d0 <killinfo+0x26c>
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
801c9a0: 54 c5 00 0a bgu r6,r5,801c9c8 <killinfo+0x264>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
801c9a4: 44 20 00 0b be r1,r0,801c9d0 <killinfo+0x26c> <== NEVER TAKEN
801c9a8: 28 29 00 10 lw r9,(r1+16)
801c9ac: 45 20 00 09 be r9,r0,801c9d0 <killinfo+0x26c> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
801c9b0: 28 4e 00 10 lw r14,(r2+16)
801c9b4: 45 c0 00 05 be r14,r0,801c9c8 <killinfo+0x264>
801c9b8: a1 2f 48 00 and r9,r9,r15
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
801c9bc: 5d 20 00 05 bne r9,r0,801c9d0 <killinfo+0x26c>
801c9c0: a1 cf 70 00 and r14,r14,r15
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
801c9c4: 45 c9 00 03 be r14,r9,801c9d0 <killinfo+0x26c>
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
801c9c8: b8 a0 30 00 mv r6,r5
801c9cc: b8 40 08 00 mv r1,r2
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
801c9d0: 34 63 00 01 addi r3,r3,1
801c9d4: 34 84 00 04 addi r4,r4,4
801c9d8: 50 e3 ff e9 bgeu r7,r3,801c97c <killinfo+0x218>
801c9dc: 35 08 00 04 addi r8,r8,4
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
801c9e0: 5d 0a ff e0 bne r8,r10,801c960 <killinfo+0x1fc>
}
}
}
}
if ( interested ) {
801c9e4: 5c 20 ff be bne r1,r0,801c8dc <killinfo+0x178>
801c9e8: e3 ff ff c1 bi 801c8ec <killinfo+0x188>
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
801c9ec: 78 01 08 02 mvhi r1,0x802
801c9f0: 38 21 0f e8 ori r1,r1,0xfe8
801c9f4: fb ff 9f ce calli 800492c <_Chain_Get>
801c9f8: b8 20 10 00 mv r2,r1
if ( !psiginfo ) {
801c9fc: 44 20 00 13 be r1,r0,801ca48 <killinfo+0x2e4>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
801ca00: 2b 83 00 20 lw r3,(sp+32)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
801ca04: b5 8c 60 00 add r12,r12,r12
801ca08: 78 01 08 02 mvhi r1,0x802
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
801ca0c: 58 43 00 08 sw (r2+8),r3
801ca10: 2b 83 00 24 lw r3,(sp+36)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
801ca14: b5 8c 60 00 add r12,r12,r12
801ca18: 38 21 10 60 ori r1,r1,0x1060
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
801ca1c: 58 43 00 0c sw (r2+12),r3
801ca20: 2b 83 00 28 lw r3,(sp+40)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
801ca24: b5 81 08 00 add r1,r12,r1
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
801ca28: 58 43 00 10 sw (r2+16),r3
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
801ca2c: fb ff 9f b4 calli 80048fc <_Chain_Append>
801ca30: e3 ff ff b8 bi 801c910 <killinfo+0x1ac>
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
801ca34: fb ff c2 10 calli 800d274 <__errno>
801ca38: 34 02 00 03 mvi r2,3
801ca3c: 58 22 00 00 sw (r1+0),r2
801ca40: 34 01 ff ff mvi r1,-1
801ca44: e3 ff ff 5d bi 801c7b8 <killinfo+0x54>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
_Thread_Enable_dispatch();
801ca48: fb ff a8 7b calli 8006c34 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
801ca4c: fb ff c2 0a calli 800d274 <__errno>
801ca50: 34 02 00 0b mvi r2,11
801ca54: 58 22 00 00 sw (r1+0),r2
801ca58: 34 01 ff ff mvi r1,-1
801ca5c: e3 ff ff 57 bi 801c7b8 <killinfo+0x54>
08004374 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
8004374: 37 9c ff b0 addi sp,sp,-80
8004378: 5b 8b 00 24 sw (sp+36),r11
800437c: 5b 8c 00 20 sw (sp+32),r12
8004380: 5b 8d 00 1c sw (sp+28),r13
8004384: 5b 8e 00 18 sw (sp+24),r14
8004388: 5b 8f 00 14 sw (sp+20),r15
800438c: 5b 90 00 10 sw (sp+16),r16
8004390: 5b 91 00 0c sw (sp+12),r17
8004394: 5b 92 00 08 sw (sp+8),r18
8004398: 5b 9d 00 04 sw (sp+4),ra
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
800439c: 78 09 08 02 mvhi r9,0x802
80043a0: 39 29 53 28 ori r9,r9,0x5328
80043a4: 29 2a 00 00 lw r10,(r9+0)
80043a8: b8 20 88 00 mv r17,r1
80043ac: 5b 82 00 38 sw (sp+56),r2
++level;
80043b0: 35 4a 00 01 addi r10,r10,1
80043b4: 5b 83 00 3c sw (sp+60),r3
80043b8: 5b 84 00 40 sw (sp+64),r4
80043bc: 5b 85 00 44 sw (sp+68),r5
80043c0: 5b 86 00 48 sw (sp+72),r6
80043c4: 5b 87 00 4c sw (sp+76),r7
80043c8: 5b 88 00 50 sw (sp+80),r8
80043cc: b8 40 70 00 mv r14,r2
_Thread_Dispatch_disable_level = level;
80043d0: 59 2a 00 00 sw (r9+0),r10
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
80043d4: 20 50 02 00 andi r16,r2,0x200
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
80043d8: 34 12 00 00 mvi r18,0
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
80043dc: 5e 00 00 3c bne r16,r0,80044cc <mq_open+0x158>
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
_Objects_Allocate( &_POSIX_Message_queue_Information_fds );
80043e0: 78 0c 08 02 mvhi r12,0x802
80043e4: 39 8c 57 70 ori r12,r12,0x5770
80043e8: b9 80 08 00 mv r1,r12
80043ec: f8 00 0c df calli 8007768 <_Objects_Allocate>
80043f0: b8 20 58 00 mv r11,r1
attr = va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
80043f4: 44 20 00 3d be r1,r0,80044e8 <mq_open+0x174> <== NEVER TAKEN
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Message_queue_Information, name, id, len );
80043f8: 78 0d 08 02 mvhi r13,0x802
80043fc: 39 ad 55 e4 ori r13,r13,0x55e4
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
8004400: 58 2e 00 14 sw (r1+20),r14
8004404: ba 20 10 00 mv r2,r17
8004408: b9 a0 08 00 mv r1,r13
800440c: 37 83 00 34 addi r3,sp,52
8004410: 37 84 00 28 addi r4,sp,40
8004414: f8 00 01 78 calli 80049f4 <_POSIX_Name_to_id>
8004418: b8 20 78 00 mv r15,r1
* If the name to id translation worked, then the message queue exists
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "message queue does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
800441c: 5c 20 00 22 bne r1,r0,80044a4 <mq_open+0x130>
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
8004420: 21 ce 0a 00 andi r14,r14,0xa00
8004424: 34 01 0a 00 mvi r1,2560
8004428: 45 c1 00 36 be r14,r1,8004500 <mq_open+0x18c>
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
_Objects_Get( &_POSIX_Message_queue_Information, id, location );
800442c: 2b 82 00 34 lw r2,(sp+52)
8004430: 37 83 00 2c addi r3,sp,44
8004434: b9 a0 08 00 mv r1,r13
8004438: f8 00 0e 50 calli 8007d78 <_Objects_Get>
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
the_mq->open_count += 1;
800443c: 28 24 00 18 lw r4,(r1+24)
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
8004440: 2d 62 00 0a lhu r2,(r11+10)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8004444: 29 83 00 1c lw r3,(r12+28)
8004448: 34 84 00 01 addi r4,r4,1
800444c: b4 42 10 00 add r2,r2,r2
8004450: 58 24 00 18 sw (r1+24),r4
8004454: b4 42 10 00 add r2,r2,r2
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
8004458: 5b 81 00 30 sw (sp+48),r1
the_mq->open_count += 1;
the_mq_fd->Queue = the_mq;
800445c: 59 61 00 10 sw (r11+16),r1
8004460: b4 62 10 00 add r2,r3,r2
8004464: 58 4b 00 00 sw (r2+0),r11
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
8004468: 59 60 00 0c sw (r11+12),r0
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
800446c: f8 00 12 58 calli 8008dcc <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
8004470: f8 00 12 57 calli 8008dcc <_Thread_Enable_dispatch>
return (mqd_t)the_mq_fd->Object.id;
8004474: 29 61 00 08 lw r1,(r11+8)
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
8004478: 2b 9d 00 04 lw ra,(sp+4)
800447c: 2b 8b 00 24 lw r11,(sp+36)
8004480: 2b 8c 00 20 lw r12,(sp+32)
8004484: 2b 8d 00 1c lw r13,(sp+28)
8004488: 2b 8e 00 18 lw r14,(sp+24)
800448c: 2b 8f 00 14 lw r15,(sp+20)
8004490: 2b 90 00 10 lw r16,(sp+16)
8004494: 2b 91 00 0c lw r17,(sp+12)
8004498: 2b 92 00 08 lw r18,(sp+8)
800449c: 37 9c 00 50 addi sp,sp,80
80044a0: c3 a0 00 00 ret
if ( status ) {
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
80044a4: 34 01 00 02 mvi r1,2
80044a8: 45 e1 00 1f be r15,r1,8004524 <mq_open+0x1b0>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
80044ac: b9 80 08 00 mv r1,r12
80044b0: b9 60 10 00 mv r2,r11
80044b4: f8 00 0d b8 calli 8007b94 <_Objects_Free>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
80044b8: f8 00 12 45 calli 8008dcc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
80044bc: f8 00 2c bf calli 800f7b8 <__errno>
80044c0: 58 2f 00 00 sw (r1+0),r15
80044c4: 34 01 ff ff mvi r1,-1
80044c8: e3 ff ff ec bi 8004478 <mq_open+0x104>
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
_Objects_Allocate( &_POSIX_Message_queue_Information_fds );
80044cc: 78 0c 08 02 mvhi r12,0x802
80044d0: 39 8c 57 70 ori r12,r12,0x5770
80044d4: b9 80 08 00 mv r1,r12
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
attr = va_arg( arg, struct mq_attr * );
80044d8: 2b 92 00 40 lw r18,(sp+64)
80044dc: f8 00 0c a3 calli 8007768 <_Objects_Allocate>
80044e0: b8 20 58 00 mv r11,r1
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
80044e4: 5c 20 ff c5 bne r1,r0,80043f8 <mq_open+0x84>
_Thread_Enable_dispatch();
80044e8: f8 00 12 39 calli 8008dcc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
80044ec: f8 00 2c b3 calli 800f7b8 <__errno>
80044f0: 34 02 00 17 mvi r2,23
80044f4: 58 22 00 00 sw (r1+0),r2
80044f8: 34 01 ff ff mvi r1,-1
80044fc: e3 ff ff df bi 8004478 <mq_open+0x104>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
8004500: b9 60 10 00 mv r2,r11
8004504: b9 80 08 00 mv r1,r12
8004508: f8 00 0d a3 calli 8007b94 <_Objects_Free>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
800450c: f8 00 12 30 calli 8008dcc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
8004510: f8 00 2c aa calli 800f7b8 <__errno>
8004514: 34 02 00 11 mvi r2,17
8004518: 58 22 00 00 sw (r1+0),r2
800451c: 34 01 ff ff mvi r1,-1
8004520: e3 ff ff d6 bi 8004478 <mq_open+0x104>
if ( status ) {
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
8004524: 46 00 ff e2 be r16,r0,80044ac <mq_open+0x138>
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
8004528: 2b 82 00 28 lw r2,(sp+40)
800452c: ba 20 08 00 mv r1,r17
8004530: 34 03 00 01 mvi r3,1
8004534: ba 40 20 00 mv r4,r18
8004538: 37 85 00 30 addi r5,sp,48
800453c: f8 00 1e 18 calli 800bd9c <_POSIX_Message_queue_Create_support>
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
8004540: 34 02 ff ff mvi r2,-1
8004544: 44 22 00 0d be r1,r2,8004578 <mq_open+0x204>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
8004548: 2d 61 00 0a lhu r1,(r11+10)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
800454c: 29 82 00 1c lw r2,(r12+28)
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
return (mqd_t) -1;
}
the_mq_fd->Queue = the_mq;
8004550: 2b 83 00 30 lw r3,(sp+48)
8004554: b4 21 08 00 add r1,r1,r1
8004558: b4 21 08 00 add r1,r1,r1
800455c: b4 41 08 00 add r1,r2,r1
8004560: 59 63 00 10 sw (r11+16),r3
8004564: 58 2b 00 00 sw (r1+0),r11
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
8004568: 59 60 00 0c sw (r11+12),r0
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
800456c: f8 00 12 18 calli 8008dcc <_Thread_Enable_dispatch>
return (mqd_t) the_mq_fd->Object.id;
8004570: 29 61 00 08 lw r1,(r11+8)
8004574: e3 ff ff c1 bi 8004478 <mq_open+0x104>
8004578: b9 80 08 00 mv r1,r12
800457c: b9 60 10 00 mv r2,r11
8004580: f8 00 0d 85 calli 8007b94 <_Objects_Free>
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
8004584: f8 00 12 12 calli 8008dcc <_Thread_Enable_dispatch>
return (mqd_t) -1;
8004588: 34 01 ff ff mvi r1,-1
800458c: e3 ff ff bb bi 8004478 <mq_open+0x104>
08008b64 <pthread_attr_setschedpolicy>:
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
8008b64: 34 03 00 16 mvi r3,22
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
8008b68: 44 20 00 09 be r1,r0,8008b8c <pthread_attr_setschedpolicy+0x28>
8008b6c: 28 24 00 00 lw r4,(r1+0)
8008b70: 44 80 00 07 be r4,r0,8008b8c <pthread_attr_setschedpolicy+0x28>
return EINVAL;
switch ( policy ) {
8008b74: 48 02 00 05 bg r0,r2,8008b88 <pthread_attr_setschedpolicy+0x24>
8008b78: 34 03 00 02 mvi r3,2
8008b7c: 4c 62 00 06 bge r3,r2,8008b94 <pthread_attr_setschedpolicy+0x30>
8008b80: 34 03 00 04 mvi r3,4
8008b84: 44 43 00 04 be r2,r3,8008b94 <pthread_attr_setschedpolicy+0x30><== ALWAYS TAKEN
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
8008b88: 34 03 00 86 mvi r3,134
}
}
8008b8c: b8 60 08 00 mv r1,r3
8008b90: c3 a0 00 00 ret
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
8008b94: 34 03 00 00 mvi r3,0
switch ( policy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
8008b98: 58 22 00 14 sw (r1+20),r2
return 0;
default:
return ENOTSUP;
}
}
8008b9c: b8 60 08 00 mv r1,r3
8008ba0: c3 a0 00 00 ret
080040fc <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
80040fc: 37 9c ff d8 addi sp,sp,-40
8004100: 5b 8b 00 14 sw (sp+20),r11
8004104: 5b 8c 00 10 sw (sp+16),r12
8004108: 5b 8d 00 0c sw (sp+12),r13
800410c: 5b 8e 00 08 sw (sp+8),r14
8004110: 5b 9d 00 04 sw (sp+4),ra
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
8004114: 34 04 00 16 mvi r4,22
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
8004118: b8 20 58 00 mv r11,r1
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
800411c: 44 20 00 08 be r1,r0,800413c <pthread_barrier_init+0x40>
return EINVAL;
if ( count == 0 )
8004120: 44 60 00 07 be r3,r0,800413c <pthread_barrier_init+0x40>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
8004124: 44 40 00 34 be r2,r0,80041f4 <pthread_barrier_init+0xf8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
8004128: 28 41 00 00 lw r1,(r2+0)
return EINVAL;
800412c: 34 04 00 16 mvi r4,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
8004130: 44 20 00 03 be r1,r0,800413c <pthread_barrier_init+0x40>
return EINVAL;
switch ( the_attr->process_shared ) {
8004134: 28 4e 00 04 lw r14,(r2+4)
8004138: 45 c0 00 09 be r14,r0,800415c <pthread_barrier_init+0x60> <== ALWAYS TAKEN
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
_Thread_Enable_dispatch();
return 0;
}
800413c: b8 80 08 00 mv r1,r4
8004140: 2b 9d 00 04 lw ra,(sp+4)
8004144: 2b 8b 00 14 lw r11,(sp+20)
8004148: 2b 8c 00 10 lw r12,(sp+16)
800414c: 2b 8d 00 0c lw r13,(sp+12)
8004150: 2b 8e 00 08 lw r14,(sp+8)
8004154: 37 9c 00 28 addi sp,sp,40
8004158: c3 a0 00 00 ret
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
800415c: 78 01 08 01 mvhi r1,0x801
8004160: 38 21 79 08 ori r1,r1,0x7908
8004164: 28 22 00 00 lw r2,(r1+0)
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
8004168: 5b 80 00 24 sw (sp+36),r0
the_attributes.maximum_count = count;
800416c: 5b 83 00 28 sw (sp+40),r3
++level;
8004170: 34 42 00 01 addi r2,r2,1
_Thread_Dispatch_disable_level = level;
8004174: 58 22 00 00 sw (r1+0),r2
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
_Objects_Allocate( &_POSIX_Barrier_Information );
8004178: 78 0d 08 01 mvhi r13,0x801
800417c: 39 ad 7c 04 ori r13,r13,0x7c04
8004180: b9 a0 08 00 mv r1,r13
8004184: f8 00 08 81 calli 8006388 <_Objects_Allocate>
8004188: b8 20 60 00 mv r12,r1
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
800418c: 44 2e 00 17 be r1,r14,80041e8 <pthread_barrier_init+0xec>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
8004190: 37 82 00 24 addi r2,sp,36
8004194: 34 21 00 10 addi r1,r1,16
8004198: f8 00 05 64 calli 8005728 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
800419c: 29 82 00 08 lw r2,(r12+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80041a0: 29 a3 00 1c lw r3,(r13+28)
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
80041a4: 20 41 ff ff andi r1,r2,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80041a8: b4 21 08 00 add r1,r1,r1
80041ac: b4 21 08 00 add r1,r1,r1
80041b0: b4 61 08 00 add r1,r3,r1
80041b4: 58 2c 00 00 sw (r1+0),r12
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
80041b8: 59 80 00 0c sw (r12+12),r0
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
80041bc: 59 62 00 00 sw (r11+0),r2
_Thread_Enable_dispatch();
80041c0: f8 00 0d a5 calli 8007854 <_Thread_Enable_dispatch>
return 0;
80041c4: 34 04 00 00 mvi r4,0
}
80041c8: b8 80 08 00 mv r1,r4
80041cc: 2b 9d 00 04 lw ra,(sp+4)
80041d0: 2b 8b 00 14 lw r11,(sp+20)
80041d4: 2b 8c 00 10 lw r12,(sp+16)
80041d8: 2b 8d 00 0c lw r13,(sp+12)
80041dc: 2b 8e 00 08 lw r14,(sp+8)
80041e0: 37 9c 00 28 addi sp,sp,40
80041e4: c3 a0 00 00 ret
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
80041e8: f8 00 0d 9b calli 8007854 <_Thread_Enable_dispatch>
return EAGAIN;
80041ec: 34 04 00 0b mvi r4,11
80041f0: e3 ff ff d3 bi 800413c <pthread_barrier_init+0x40>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
80041f4: 37 8c 00 1c addi r12,sp,28
80041f8: b9 80 08 00 mv r1,r12
80041fc: 5b 83 00 18 sw (sp+24),r3
8004200: fb ff ff 7c calli 8003ff0 <pthread_barrierattr_init>
the_attr = &my_attr;
8004204: b9 80 10 00 mv r2,r12
8004208: 2b 83 00 18 lw r3,(sp+24)
800420c: e3 ff ff c7 bi 8004128 <pthread_barrier_init+0x2c>
08003ff0 <pthread_barrierattr_init>:
int pthread_barrierattr_init(
pthread_barrierattr_t *attr
)
{
if ( !attr )
return EINVAL;
8003ff0: 34 02 00 16 mvi r2,22
int pthread_barrierattr_init(
pthread_barrierattr_t *attr
)
{
if ( !attr )
8003ff4: 44 20 00 05 be r1,r0,8004008 <pthread_barrierattr_init+0x18><== NEVER TAKEN
return EINVAL;
attr->is_initialized = true;
8003ff8: 34 02 00 01 mvi r2,1
8003ffc: 58 22 00 00 sw (r1+0),r2
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
8004000: 58 20 00 04 sw (r1+4),r0
return 0;
8004004: 34 02 00 00 mvi r2,0
}
8004008: b8 40 08 00 mv r1,r2
800400c: c3 a0 00 00 ret
0800391c <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
800391c: 37 9c ff f4 addi sp,sp,-12
8003920: 5b 8b 00 0c sw (sp+12),r11
8003924: 5b 8c 00 08 sw (sp+8),r12
8003928: 5b 9d 00 04 sw (sp+4),ra
800392c: b8 20 58 00 mv r11,r1
8003930: b8 40 60 00 mv r12,r2
/*
* The POSIX standard does not address what to do when the routine
* is NULL. It also does not address what happens when we cannot
* allocate memory or anything else bad happens.
*/
if ( !routine )
8003934: 44 20 00 14 be r1,r0,8003984 <pthread_cleanup_push+0x68>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8003938: 78 03 08 01 mvhi r3,0x801
800393c: 38 63 78 e0 ori r3,r3,0x78e0
8003940: 28 61 00 00 lw r1,(r3+0)
++level;
8003944: 34 21 00 01 addi r1,r1,1
_Thread_Dispatch_disable_level = level;
8003948: 58 61 00 00 sw (r3+0),r1
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
800394c: 34 01 00 10 mvi r1,16
8003950: f8 00 12 e0 calli 80084d0 <_Workspace_Allocate>
8003954: b8 20 18 00 mv r3,r1
if ( handler ) {
8003958: 44 20 00 0a be r1,r0,8003980 <pthread_cleanup_push+0x64> <== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
800395c: 78 04 08 01 mvhi r4,0x801
8003960: 38 84 7d 80 ori r4,r4,0x7d80
8003964: 28 81 00 10 lw r1,(r4+16)
handler_stack = &thread_support->Cancellation_Handlers;
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
8003968: b8 60 10 00 mv r2,r3
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
if ( handler ) {
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
800396c: 28 21 01 1c lw r1,(r1+284)
handler->routine = routine;
8003970: 58 6b 00 08 sw (r3+8),r11
handler->arg = arg;
8003974: 58 6c 00 0c sw (r3+12),r12
_Chain_Append( handler_stack, &handler->Node );
8003978: 34 21 00 e4 addi r1,r1,228
800397c: f8 00 05 60 calli 8004efc <_Chain_Append>
}
_Thread_Enable_dispatch();
8003980: f8 00 0d ba calli 8007068 <_Thread_Enable_dispatch>
}
8003984: 2b 9d 00 04 lw ra,(sp+4)
8003988: 2b 8b 00 0c lw r11,(sp+12)
800398c: 2b 8c 00 08 lw r12,(sp+8)
8003990: 37 9c 00 0c addi sp,sp,12
8003994: c3 a0 00 00 ret
08004a98 <pthread_cond_init>:
*/
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
8004a98: 37 9c ff ec addi sp,sp,-20
8004a9c: 5b 8b 00 10 sw (sp+16),r11
8004aa0: 5b 8c 00 0c sw (sp+12),r12
8004aa4: 5b 8d 00 08 sw (sp+8),r13
8004aa8: 5b 9d 00 04 sw (sp+4),ra
8004aac: b8 20 68 00 mv r13,r1
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
8004ab0: 44 40 00 35 be r2,r0,8004b84 <pthread_cond_init+0xec>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
8004ab4: 28 44 00 04 lw r4,(r2+4)
8004ab8: 34 03 00 01 mvi r3,1
return EINVAL;
8004abc: 34 01 00 16 mvi r1,22
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
8004ac0: 44 83 00 03 be r4,r3,8004acc <pthread_cond_init+0x34> <== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
8004ac4: 28 43 00 00 lw r3,(r2+0)
8004ac8: 5c 60 00 07 bne r3,r0,8004ae4 <pthread_cond_init+0x4c>
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
8004acc: 2b 9d 00 04 lw ra,(sp+4)
8004ad0: 2b 8b 00 10 lw r11,(sp+16)
8004ad4: 2b 8c 00 0c lw r12,(sp+12)
8004ad8: 2b 8d 00 08 lw r13,(sp+8)
8004adc: 37 9c 00 14 addi sp,sp,20
8004ae0: c3 a0 00 00 ret
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8004ae4: 78 03 08 01 mvhi r3,0x801
8004ae8: 38 63 88 f8 ori r3,r3,0x88f8
8004aec: 28 61 00 00 lw r1,(r3+0)
++level;
8004af0: 34 21 00 01 addi r1,r1,1
_Thread_Dispatch_disable_level = level;
8004af4: 58 61 00 00 sw (r3+0),r1
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
8004af8: 78 0c 08 01 mvhi r12,0x801
8004afc: 39 8c 8c 8c ori r12,r12,0x8c8c
8004b00: b9 80 08 00 mv r1,r12
8004b04: 5b 82 00 14 sw (sp+20),r2
8004b08: f8 00 0a 6d calli 80074bc <_Objects_Allocate>
8004b0c: b8 20 58 00 mv r11,r1
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
8004b10: 2b 82 00 14 lw r2,(sp+20)
8004b14: 44 20 00 1f be r1,r0,8004b90 <pthread_cond_init+0xf8>
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
8004b18: 78 01 08 01 mvhi r1,0x801
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
8004b1c: 28 45 00 04 lw r5,(r2+4)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
8004b20: 38 21 6c 08 ori r1,r1,0x6c08
8004b24: 28 23 00 00 lw r3,(r1+0)
8004b28: 34 04 00 74 mvi r4,116
8004b2c: 35 61 00 18 addi r1,r11,24
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
8004b30: 59 65 00 10 sw (r11+16),r5
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
8004b34: 34 02 00 00 mvi r2,0
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
8004b38: 59 60 00 14 sw (r11+20),r0
_Thread_queue_Initialize(
8004b3c: f8 00 12 7d calli 8009530 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
8004b40: 29 61 00 08 lw r1,(r11+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8004b44: 29 83 00 1c lw r3,(r12+28)
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
8004b48: 20 22 ff ff andi r2,r1,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8004b4c: b4 42 10 00 add r2,r2,r2
8004b50: b4 42 10 00 add r2,r2,r2
8004b54: b4 62 10 00 add r2,r3,r2
8004b58: 58 4b 00 00 sw (r2+0),r11
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
8004b5c: 59 60 00 0c sw (r11+12),r0
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
8004b60: 59 a1 00 00 sw (r13+0),r1
_Thread_Enable_dispatch();
8004b64: f8 00 0f f9 calli 8008b48 <_Thread_Enable_dispatch>
return 0;
8004b68: 34 01 00 00 mvi r1,0
}
8004b6c: 2b 9d 00 04 lw ra,(sp+4)
8004b70: 2b 8b 00 10 lw r11,(sp+16)
8004b74: 2b 8c 00 0c lw r12,(sp+12)
8004b78: 2b 8d 00 08 lw r13,(sp+8)
8004b7c: 37 9c 00 14 addi sp,sp,20
8004b80: c3 a0 00 00 ret
{
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
8004b84: 78 02 08 01 mvhi r2,0x801
8004b88: 38 42 6c 00 ori r2,r2,0x6c00
8004b8c: e3 ff ff ca bi 8004ab4 <pthread_cond_init+0x1c>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
8004b90: f8 00 0f ee calli 8008b48 <_Thread_Enable_dispatch>
return ENOMEM;
8004b94: 34 01 00 0c mvi r1,12
8004b98: e3 ff ff cd bi 8004acc <pthread_cond_init+0x34>
080048f4 <pthread_condattr_destroy>:
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
80048f4: 34 02 00 16 mvi r2,22
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
80048f8: 44 20 00 05 be r1,r0,800490c <pthread_condattr_destroy+0x18>
80048fc: 28 23 00 00 lw r3,(r1+0)
8004900: 44 60 00 03 be r3,r0,800490c <pthread_condattr_destroy+0x18><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
8004904: 58 20 00 00 sw (r1+0),r0
return 0;
8004908: 34 02 00 00 mvi r2,0
}
800490c: b8 40 08 00 mv r1,r2
8004910: c3 a0 00 00 ret
08003d90 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
8003d90: 37 9c ff a0 addi sp,sp,-96
8003d94: 5b 8b 00 3c sw (sp+60),r11
8003d98: 5b 8c 00 38 sw (sp+56),r12
8003d9c: 5b 8d 00 34 sw (sp+52),r13
8003da0: 5b 8e 00 30 sw (sp+48),r14
8003da4: 5b 8f 00 2c sw (sp+44),r15
8003da8: 5b 90 00 28 sw (sp+40),r16
8003dac: 5b 91 00 24 sw (sp+36),r17
8003db0: 5b 92 00 20 sw (sp+32),r18
8003db4: 5b 93 00 1c sw (sp+28),r19
8003db8: 5b 94 00 18 sw (sp+24),r20
8003dbc: 5b 95 00 14 sw (sp+20),r21
8003dc0: 5b 9d 00 10 sw (sp+16),ra
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
8003dc4: 34 0c 00 0e mvi r12,14
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
8003dc8: b8 60 68 00 mv r13,r3
8003dcc: b8 20 78 00 mv r15,r1
8003dd0: b8 80 70 00 mv r14,r4
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
8003dd4: 44 60 00 13 be r3,r0,8003e20 <pthread_create+0x90>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
8003dd8: b8 40 58 00 mv r11,r2
8003ddc: 44 40 00 66 be r2,r0,8003f74 <pthread_create+0x1e4>
if ( !the_attr->is_initialized )
8003de0: 29 61 00 00 lw r1,(r11+0)
return EINVAL;
8003de4: 34 0c 00 16 mvi r12,22
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
if ( !the_attr->is_initialized )
8003de8: 44 20 00 0e be r1,r0,8003e20 <pthread_create+0x90>
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
8003dec: 29 61 00 04 lw r1,(r11+4)
8003df0: 44 20 00 06 be r1,r0,8003e08 <pthread_create+0x78>
8003df4: 78 02 08 02 mvhi r2,0x802
8003df8: 38 42 00 f8 ori r2,r2,0xf8
8003dfc: 29 63 00 08 lw r3,(r11+8)
8003e00: 28 41 00 00 lw r1,(r2+0)
8003e04: 54 23 00 07 bgu r1,r3,8003e20 <pthread_create+0x90>
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
8003e08: 29 61 00 10 lw r1,(r11+16)
8003e0c: 34 02 00 01 mvi r2,1
8003e10: 44 22 00 5c be r1,r2,8003f80 <pthread_create+0x1f0>
8003e14: 34 02 00 02 mvi r2,2
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
8003e18: 34 0c 00 16 mvi r12,22
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
8003e1c: 44 22 00 10 be r1,r2,8003e5c <pthread_create+0xcc>
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
8003e20: b9 80 08 00 mv r1,r12
8003e24: 2b 9d 00 10 lw ra,(sp+16)
8003e28: 2b 8b 00 3c lw r11,(sp+60)
8003e2c: 2b 8c 00 38 lw r12,(sp+56)
8003e30: 2b 8d 00 34 lw r13,(sp+52)
8003e34: 2b 8e 00 30 lw r14,(sp+48)
8003e38: 2b 8f 00 2c lw r15,(sp+44)
8003e3c: 2b 90 00 28 lw r16,(sp+40)
8003e40: 2b 91 00 24 lw r17,(sp+36)
8003e44: 2b 92 00 20 lw r18,(sp+32)
8003e48: 2b 93 00 1c lw r19,(sp+28)
8003e4c: 2b 94 00 18 lw r20,(sp+24)
8003e50: 2b 95 00 14 lw r21,(sp+20)
8003e54: 37 9c 00 60 addi sp,sp,96
8003e58: c3 a0 00 00 ret
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
8003e5c: 29 67 00 18 lw r7,(r11+24)
8003e60: 29 66 00 1c lw r6,(r11+28)
8003e64: 29 65 00 20 lw r5,(r11+32)
8003e68: 29 64 00 24 lw r4,(r11+36)
8003e6c: 29 63 00 28 lw r3,(r11+40)
8003e70: 29 62 00 2c lw r2,(r11+44)
8003e74: 29 61 00 30 lw r1,(r11+48)
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
8003e78: 29 71 00 14 lw r17,(r11+20)
schedparam = the_attr->schedparam;
8003e7c: 5b 87 00 40 sw (sp+64),r7
8003e80: 5b 86 00 44 sw (sp+68),r6
8003e84: 5b 85 00 48 sw (sp+72),r5
8003e88: 5b 84 00 4c sw (sp+76),r4
8003e8c: 5b 83 00 50 sw (sp+80),r3
8003e90: 5b 82 00 54 sw (sp+84),r2
8003e94: 5b 81 00 58 sw (sp+88),r1
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
8003e98: 29 70 00 0c lw r16,(r11+12)
return ENOTSUP;
8003e9c: 34 0c 00 86 mvi r12,134
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
8003ea0: 5e 00 ff e0 bne r16,r0,8003e20 <pthread_create+0x90>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
8003ea4: 2b 81 00 40 lw r1,(sp+64)
return EINVAL;
8003ea8: 34 0c 00 16 mvi r12,22
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
8003eac: f8 00 1b 91 calli 800acf0 <_POSIX_Priority_Is_valid>
8003eb0: 44 30 ff dc be r1,r16,8003e20 <pthread_create+0x90> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
8003eb4: 78 05 08 02 mvhi r5,0x802
8003eb8: 38 a5 00 fc ori r5,r5,0xfc
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
8003ebc: ba 20 08 00 mv r1,r17
8003ec0: 37 82 00 40 addi r2,sp,64
8003ec4: 37 83 00 60 addi r3,sp,96
8003ec8: 37 84 00 5c addi r4,sp,92
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
8003ecc: 2b 94 00 40 lw r20,(sp+64)
8003ed0: 40 b5 00 00 lbu r21,(r5+0)
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
8003ed4: f8 00 1b 8f calli 800ad10 <_POSIX_Thread_Translate_sched_param>
8003ed8: b8 20 60 00 mv r12,r1
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
8003edc: 5c 20 ff d1 bne r1,r0,8003e20 <pthread_create+0x90>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
8003ee0: 78 12 08 02 mvhi r18,0x802
8003ee4: 3a 52 09 68 ori r18,r18,0x968
8003ee8: 2a 41 00 00 lw r1,(r18+0)
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
8003eec: 78 10 08 02 mvhi r16,0x802
8003ef0: 3a 10 0a 64 ori r16,r16,0xa64
8003ef4: f8 00 05 7b calli 80054e0 <_API_Mutex_Lock>
8003ef8: ba 00 08 00 mv r1,r16
8003efc: f8 00 08 c8 calli 800621c <_Objects_Allocate>
8003f00: b8 20 98 00 mv r19,r1
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
8003f04: 44 2c 00 18 be r1,r12,8003f64 <pthread_create+0x1d4>
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
8003f08: 78 01 08 02 mvhi r1,0x802
8003f0c: 38 21 00 f8 ori r1,r1,0xf8
8003f10: 28 24 00 00 lw r4,(r1+0)
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
8003f14: 29 61 00 08 lw r1,(r11+8)
8003f18: 29 63 00 04 lw r3,(r11+4)
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
8003f1c: b4 84 20 00 add r4,r4,r4
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
8003f20: 50 81 00 02 bgeu r4,r1,8003f28 <pthread_create+0x198>
8003f24: b8 20 20 00 mv r4,r1
8003f28: 2b 89 00 5c lw r9,(sp+92)
8003f2c: 2b 88 00 60 lw r8,(sp+96)
8003f30: ba 00 08 00 mv r1,r16
8003f34: ba 60 10 00 mv r2,r19
8003f38: 34 05 00 00 mvi r5,0
8003f3c: ca b4 30 00 sub r6,r21,r20
8003f40: 34 07 00 01 mvi r7,1
8003f44: 5b 89 00 04 sw (sp+4),r9
8003f48: 5b 80 00 08 sw (sp+8),r0
8003f4c: 5b 80 00 0c sw (sp+12),r0
8003f50: f8 00 0e 92 calli 8007998 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
8003f54: 5c 20 00 1f bne r1,r0,8003fd0 <pthread_create+0x240>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
8003f58: ba 00 08 00 mv r1,r16
8003f5c: ba 60 10 00 mv r2,r19
8003f60: f8 00 09 ba calli 8006648 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
8003f64: 2a 41 00 00 lw r1,(r18+0)
return EAGAIN;
8003f68: 34 0c 00 0b mvi r12,11
name /* posix threads don't have a name */
);
if ( !status ) {
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
8003f6c: f8 00 05 79 calli 8005550 <_API_Mutex_Unlock>
return EAGAIN;
8003f70: e3 ff ff ac bi 8003e20 <pthread_create+0x90>
int rc;
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
8003f74: 78 0b 08 01 mvhi r11,0x801
8003f78: 39 6b eb 38 ori r11,r11,0xeb38
8003f7c: e3 ff ff 99 bi 8003de0 <pthread_create+0x50>
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
8003f80: 78 01 08 02 mvhi r1,0x802
8003f84: 38 21 0d 80 ori r1,r1,0xd80
8003f88: 28 21 00 10 lw r1,(r1+16)
8003f8c: 28 22 01 1c lw r2,(r1+284)
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
8003f90: 28 48 00 88 lw r8,(r2+136)
8003f94: 28 47 00 8c lw r7,(r2+140)
8003f98: 28 46 00 90 lw r6,(r2+144)
8003f9c: 28 45 00 94 lw r5,(r2+148)
8003fa0: 28 44 00 98 lw r4,(r2+152)
8003fa4: 28 43 00 9c lw r3,(r2+156)
8003fa8: 28 41 00 a0 lw r1,(r2+160)
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
schedpolicy = api->schedpolicy;
8003fac: 28 51 00 84 lw r17,(r2+132)
schedparam = api->schedparam;
8003fb0: 5b 88 00 40 sw (sp+64),r8
8003fb4: 5b 87 00 44 sw (sp+68),r7
8003fb8: 5b 86 00 48 sw (sp+72),r6
8003fbc: 5b 85 00 4c sw (sp+76),r5
8003fc0: 5b 84 00 50 sw (sp+80),r4
8003fc4: 5b 83 00 54 sw (sp+84),r3
8003fc8: 5b 81 00 58 sw (sp+88),r1
break;
8003fcc: e3 ff ff b3 bi 8003e98 <pthread_create+0x108>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8003fd0: 2a 70 01 1c lw r16,(r19+284)
api->Attributes = *the_attr;
8003fd4: 29 63 00 00 lw r3,(r11+0)
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003fd8: ba 60 08 00 mv r1,r19
8003fdc: 34 02 00 01 mvi r2,1
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
8003fe0: 5a 03 00 00 sw (r16+0),r3
8003fe4: 29 65 00 04 lw r5,(r11+4)
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003fe8: b9 a0 18 00 mv r3,r13
8003fec: b9 c0 20 00 mv r4,r14
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
8003ff0: 5a 05 00 04 sw (r16+4),r5
8003ff4: 29 66 00 08 lw r6,(r11+8)
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003ff8: 34 05 00 00 mvi r5,0
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
8003ffc: 5a 06 00 08 sw (r16+8),r6
8004000: 29 66 00 0c lw r6,(r11+12)
8004004: 5a 06 00 0c sw (r16+12),r6
8004008: 29 66 00 10 lw r6,(r11+16)
800400c: 5a 06 00 10 sw (r16+16),r6
8004010: 29 66 00 14 lw r6,(r11+20)
8004014: 5a 06 00 14 sw (r16+20),r6
8004018: 29 66 00 18 lw r6,(r11+24)
800401c: 5a 06 00 18 sw (r16+24),r6
8004020: 29 66 00 1c lw r6,(r11+28)
8004024: 5a 06 00 1c sw (r16+28),r6
8004028: 29 66 00 20 lw r6,(r11+32)
800402c: 5a 06 00 20 sw (r16+32),r6
8004030: 29 66 00 24 lw r6,(r11+36)
8004034: 5a 06 00 24 sw (r16+36),r6
8004038: 29 66 00 28 lw r6,(r11+40)
800403c: 5a 06 00 28 sw (r16+40),r6
8004040: 29 66 00 2c lw r6,(r11+44)
8004044: 5a 06 00 2c sw (r16+44),r6
8004048: 29 66 00 30 lw r6,(r11+48)
800404c: 5a 06 00 30 sw (r16+48),r6
8004050: 29 66 00 34 lw r6,(r11+52)
8004054: 5a 06 00 34 sw (r16+52),r6
8004058: 29 66 00 38 lw r6,(r11+56)
800405c: 5a 06 00 38 sw (r16+56),r6
8004060: 29 66 00 3c lw r6,(r11+60)
8004064: 5a 06 00 3c sw (r16+60),r6
api->detachstate = the_attr->detachstate;
8004068: 29 66 00 3c lw r6,(r11+60)
800406c: 5a 06 00 40 sw (r16+64),r6
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
8004070: 2b 86 00 40 lw r6,(sp+64)
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
8004074: 5a 11 00 84 sw (r16+132),r17
api->schedparam = schedparam;
8004078: 5a 06 00 88 sw (r16+136),r6
800407c: 2b 86 00 44 lw r6,(sp+68)
8004080: 5a 06 00 8c sw (r16+140),r6
8004084: 2b 86 00 48 lw r6,(sp+72)
8004088: 5a 06 00 90 sw (r16+144),r6
800408c: 2b 86 00 4c lw r6,(sp+76)
8004090: 5a 06 00 94 sw (r16+148),r6
8004094: 2b 86 00 50 lw r6,(sp+80)
8004098: 5a 06 00 98 sw (r16+152),r6
800409c: 2b 86 00 54 lw r6,(sp+84)
80040a0: 5a 06 00 9c sw (r16+156),r6
80040a4: 2b 86 00 58 lw r6,(sp+88)
80040a8: 5a 06 00 a0 sw (r16+160),r6
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
80040ac: f8 00 10 f5 calli 8008480 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
80040b0: 34 01 00 04 mvi r1,4
80040b4: 46 21 00 06 be r17,r1,80040cc <pthread_create+0x33c>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
80040b8: 2a 62 00 08 lw r2,(r19+8)
_RTEMS_Unlock_allocator();
80040bc: 2a 41 00 00 lw r1,(r18+0)
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
80040c0: 59 e2 00 00 sw (r15+0),r2
_RTEMS_Unlock_allocator();
80040c4: f8 00 05 23 calli 8005550 <_API_Mutex_Unlock>
return 0;
80040c8: e3 ff ff 56 bi 8003e20 <pthread_create+0x90>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
80040cc: 36 01 00 90 addi r1,r16,144
80040d0: f8 00 11 2b calli 800857c <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
80040d4: 5a 01 00 b4 sw (r16+180),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
80040d8: 78 01 08 02 mvhi r1,0x802
80040dc: 36 02 00 a8 addi r2,r16,168
80040e0: 38 21 09 80 ori r1,r1,0x980
80040e4: f8 00 11 f6 calli 80088bc <_Watchdog_Insert>
80040e8: e3 ff ff f4 bi 80040b8 <pthread_create+0x328>
0800cd68 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
800cd68: 37 9c ff fc addi sp,sp,-4
800cd6c: 5b 9d 00 04 sw (sp+4),ra
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
800cd70: 78 03 08 02 mvhi r3,0x802
800cd74: 38 63 0d e0 ori r3,r3,0xde0
}
void pthread_exit(
void *value_ptr
)
{
800cd78: b8 20 10 00 mv r2,r1
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
800cd7c: 28 61 00 10 lw r1,(r3+16)
800cd80: fb ff ff b4 calli 800cc50 <_POSIX_Thread_Exit>
}
800cd84: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
800cd88: 37 9c 00 04 addi sp,sp,4 <== NOT EXECUTED
800cd8c: c3 a0 00 00 ret <== NOT EXECUTED
0801cc18 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
801cc18: 37 9c ff e4 addi sp,sp,-28
801cc1c: 5b 8b 00 18 sw (sp+24),r11
801cc20: 5b 8c 00 14 sw (sp+20),r12
801cc24: 5b 8d 00 10 sw (sp+16),r13
801cc28: 5b 8e 00 0c sw (sp+12),r14
801cc2c: 5b 8f 00 08 sw (sp+8),r15
801cc30: 5b 9d 00 04 sw (sp+4),ra
801cc34: b8 40 58 00 mv r11,r2
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
801cc38: 44 40 00 04 be r2,r0,801cc48 <pthread_kill+0x30>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
801cc3c: 34 4e ff ff addi r14,r2,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
801cc40: 34 02 00 1f mvi r2,31
801cc44: 50 4e 00 0d bgeu r2,r14,801cc78 <pthread_kill+0x60>
rtems_set_errno_and_return_minus_one( EINVAL );
801cc48: fb ff c1 8b calli 800d274 <__errno>
801cc4c: 34 02 00 16 mvi r2,22
801cc50: 58 22 00 00 sw (r1+0),r2
801cc54: 34 01 ff ff mvi r1,-1
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
801cc58: 2b 9d 00 04 lw ra,(sp+4)
801cc5c: 2b 8b 00 18 lw r11,(sp+24)
801cc60: 2b 8c 00 14 lw r12,(sp+20)
801cc64: 2b 8d 00 10 lw r13,(sp+16)
801cc68: 2b 8e 00 0c lw r14,(sp+12)
801cc6c: 2b 8f 00 08 lw r15,(sp+8)
801cc70: 37 9c 00 1c addi sp,sp,28
801cc74: c3 a0 00 00 ret
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
801cc78: 37 82 00 1c addi r2,sp,28
801cc7c: fb ff a7 fa calli 8006c64 <_Thread_Get>
801cc80: b8 20 60 00 mv r12,r1
switch ( location ) {
801cc84: 2b 81 00 1c lw r1,(sp+28)
801cc88: 44 20 00 06 be r1,r0,801cca0 <pthread_kill+0x88> <== ALWAYS TAKEN
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
801cc8c: fb ff c1 7a calli 800d274 <__errno> <== NOT EXECUTED
801cc90: 34 02 00 03 mvi r2,3 <== NOT EXECUTED
801cc94: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
801cc98: 34 01 ff ff mvi r1,-1 <== NOT EXECUTED
801cc9c: e3 ff ff ef bi 801cc58 <pthread_kill+0x40> <== NOT EXECUTED
801cca0: 78 01 08 02 mvhi r1,0x802
801cca4: 38 21 01 bc ori r1,r1,0x1bc
801cca8: fb ff 9e a5 calli 800473c <_API_extensions_Add_post_switch>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
801ccac: b5 6b 18 00 add r3,r11,r11
801ccb0: b4 6b 18 00 add r3,r3,r11
801ccb4: 78 04 08 02 mvhi r4,0x802
801ccb8: b4 63 18 00 add r3,r3,r3
801ccbc: 38 84 0e 68 ori r4,r4,0xe68
801ccc0: b4 63 18 00 add r3,r3,r3
801ccc4: b4 83 18 00 add r3,r4,r3
801ccc8: 28 61 00 08 lw r1,(r3+8)
801cccc: 34 0f 00 01 mvi r15,1
* If sig == 0 then just validate arguments
*/
_POSIX_signals_Add_post_switch_extension();
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
801ccd0: 29 8d 01 1c lw r13,(r12+284)
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
801ccd4: 44 2f 00 11 be r1,r15,801cd18 <pthread_kill+0x100>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
801ccd8: b9 c0 10 00 mv r2,r14
801ccdc: 34 01 00 01 mvi r1,1
801cce0: fb ff fb f0 calli 801bca0 <__ashlsi3>
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
801cce4: 29 a4 00 d4 lw r4,(r13+212)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
801cce8: b9 60 10 00 mv r2,r11
801ccec: 34 03 00 00 mvi r3,0
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
801ccf0: b8 81 08 00 or r1,r4,r1
801ccf4: 59 a1 00 d4 sw (r13+212),r1
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
801ccf8: b9 80 08 00 mv r1,r12
801ccfc: fb ff ff 64 calli 801ca8c <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
801cd00: 78 02 08 02 mvhi r2,0x802
801cd04: 38 42 0d e0 ori r2,r2,0xde0
801cd08: 28 41 00 08 lw r1,(r2+8)
801cd0c: 44 20 00 03 be r1,r0,801cd18 <pthread_kill+0x100>
801cd10: 28 41 00 10 lw r1,(r2+16)
801cd14: 45 81 00 0b be r12,r1,801cd40 <pthread_kill+0x128>
_Thread_Dispatch_necessary = true;
}
_Thread_Enable_dispatch();
801cd18: fb ff a7 c7 calli 8006c34 <_Thread_Enable_dispatch>
return 0;
801cd1c: 34 01 00 00 mvi r1,0
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
801cd20: 2b 9d 00 04 lw ra,(sp+4)
801cd24: 2b 8b 00 18 lw r11,(sp+24)
801cd28: 2b 8c 00 14 lw r12,(sp+20)
801cd2c: 2b 8d 00 10 lw r13,(sp+16)
801cd30: 2b 8e 00 0c lw r14,(sp+12)
801cd34: 2b 8f 00 08 lw r15,(sp+8)
801cd38: 37 9c 00 1c addi sp,sp,28
801cd3c: c3 a0 00 00 ret
api->signals_pending |= signo_to_mask( sig );
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
801cd40: 30 4f 00 0c sb (r2+12),r15
801cd44: e3 ff ff f5 bi 801cd18 <pthread_kill+0x100>
080065c8 <pthread_mutex_timedlock>:
*/
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
80065c8: 37 9c ff f0 addi sp,sp,-16
80065cc: 5b 8b 00 0c sw (sp+12),r11
80065d0: 5b 8c 00 08 sw (sp+8),r12
80065d4: 5b 9d 00 04 sw (sp+4),ra
80065d8: b8 20 60 00 mv r12,r1
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
80065dc: b8 40 08 00 mv r1,r2
80065e0: 37 82 00 10 addi r2,sp,16
80065e4: f8 00 00 49 calli 8006708 <_POSIX_Absolute_timeout_to_ticks>
80065e8: b8 20 58 00 mv r11,r1
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
80065ec: 34 01 00 03 mvi r1,3
80065f0: 45 61 00 15 be r11,r1,8006644 <pthread_mutex_timedlock+0x7c>
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
80065f4: 2b 83 00 10 lw r3,(sp+16)
80065f8: 34 02 00 00 mvi r2,0
80065fc: b9 80 08 00 mv r1,r12
8006600: fb ff ff 9f calli 800647c <_POSIX_Mutex_Lock_support>
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
8006604: 34 02 00 10 mvi r2,16
8006608: 44 22 00 06 be r1,r2,8006620 <pthread_mutex_timedlock+0x58>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
800660c: 2b 9d 00 04 lw ra,(sp+4)
8006610: 2b 8b 00 0c lw r11,(sp+12)
8006614: 2b 8c 00 08 lw r12,(sp+8)
8006618: 37 9c 00 10 addi sp,sp,16
800661c: c3 a0 00 00 ret
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
8006620: 45 60 00 12 be r11,r0,8006668 <pthread_mutex_timedlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
8006624: 35 6b ff ff addi r11,r11,-1
8006628: 34 02 00 01 mvi r2,1
800662c: 50 4b 00 11 bgeu r2,r11,8006670 <pthread_mutex_timedlock+0xa8><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
8006630: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8006634: 2b 8b 00 0c lw r11,(sp+12) <== NOT EXECUTED
8006638: 2b 8c 00 08 lw r12,(sp+8) <== NOT EXECUTED
800663c: 37 9c 00 10 addi sp,sp,16 <== NOT EXECUTED
8006640: c3 a0 00 00 ret <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
8006644: 2b 83 00 10 lw r3,(sp+16)
8006648: b9 80 08 00 mv r1,r12
800664c: 34 02 00 01 mvi r2,1
8006650: fb ff ff 8b calli 800647c <_POSIX_Mutex_Lock_support>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
8006654: 2b 9d 00 04 lw ra,(sp+4)
8006658: 2b 8b 00 0c lw r11,(sp+12)
800665c: 2b 8c 00 08 lw r12,(sp+8)
8006660: 37 9c 00 10 addi sp,sp,16
8006664: c3 a0 00 00 ret
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
8006668: 34 01 00 16 mvi r1,22 <== NOT EXECUTED
800666c: e3 ff ff e8 bi 800660c <pthread_mutex_timedlock+0x44> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
8006670: 34 01 00 74 mvi r1,116
8006674: e3 ff ff e6 bi 800660c <pthread_mutex_timedlock+0x44>
08005fcc <pthread_mutexattr_init>:
int pthread_mutexattr_init(
pthread_mutexattr_t *attr
)
{
if ( !attr )
return EINVAL;
8005fcc: 34 03 00 16 mvi r3,22
*/
int pthread_mutexattr_init(
pthread_mutexattr_t *attr
)
{
if ( !attr )
8005fd0: 44 20 00 10 be r1,r0,8006010 <pthread_mutexattr_init+0x44> <== NEVER TAKEN
return EINVAL;
*attr = _POSIX_Mutex_Default_attributes;
8005fd4: 78 02 08 01 mvhi r2,0x801
8005fd8: 38 42 bc 84 ori r2,r2,0xbc84
8005fdc: 28 44 00 00 lw r4,(r2+0)
return 0;
8005fe0: 34 03 00 00 mvi r3,0
)
{
if ( !attr )
return EINVAL;
*attr = _POSIX_Mutex_Default_attributes;
8005fe4: 58 24 00 00 sw (r1+0),r4
8005fe8: 28 44 00 04 lw r4,(r2+4)
8005fec: 58 24 00 04 sw (r1+4),r4
8005ff0: 28 44 00 08 lw r4,(r2+8)
8005ff4: 58 24 00 08 sw (r1+8),r4
8005ff8: 28 44 00 0c lw r4,(r2+12)
8005ffc: 58 24 00 0c sw (r1+12),r4
8006000: 28 44 00 10 lw r4,(r2+16)
8006004: 58 24 00 10 sw (r1+16),r4
8006008: 28 42 00 14 lw r2,(r2+20)
800600c: 58 22 00 14 sw (r1+20),r2
return 0;
}
8006010: b8 60 08 00 mv r1,r3
8006014: c3 a0 00 00 ret
080060b0 <pthread_mutexattr_setpshared>:
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
80060b0: 34 03 00 16 mvi r3,22
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
80060b4: 44 20 00 07 be r1,r0,80060d0 <pthread_mutexattr_setpshared+0x20>
80060b8: 28 24 00 00 lw r4,(r1+0)
80060bc: 44 80 00 05 be r4,r0,80060d0 <pthread_mutexattr_setpshared+0x20>
return EINVAL;
switch ( pshared ) {
80060c0: 34 04 00 01 mvi r4,1
80060c4: 54 44 00 03 bgu r2,r4,80060d0 <pthread_mutexattr_setpshared+0x20><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
80060c8: 58 22 00 04 sw (r1+4),r2
return 0;
80060cc: 34 03 00 00 mvi r3,0
default:
return EINVAL;
}
}
80060d0: b8 60 08 00 mv r1,r3
80060d4: c3 a0 00 00 ret
08003580 <pthread_mutexattr_settype>:
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
8003580: 34 03 00 16 mvi r3,22
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
8003584: 44 20 00 07 be r1,r0,80035a0 <pthread_mutexattr_settype+0x20>
8003588: 28 24 00 00 lw r4,(r1+0)
800358c: 44 80 00 05 be r4,r0,80035a0 <pthread_mutexattr_settype+0x20><== NEVER TAKEN
return EINVAL;
switch ( type ) {
8003590: 34 04 00 03 mvi r4,3
8003594: 54 44 00 03 bgu r2,r4,80035a0 <pthread_mutexattr_settype+0x20>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
8003598: 58 22 00 10 sw (r1+16),r2
return 0;
800359c: 34 03 00 00 mvi r3,0
default:
return EINVAL;
}
}
80035a0: b8 60 08 00 mv r1,r3
80035a4: c3 a0 00 00 ret
08004698 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
8004698: 37 9c ff ec addi sp,sp,-20
800469c: 5b 8b 00 10 sw (sp+16),r11
80046a0: 5b 8c 00 0c sw (sp+12),r12
80046a4: 5b 8d 00 08 sw (sp+8),r13
80046a8: 5b 9d 00 04 sw (sp+4),ra
if ( !once_control || !init_routine )
80046ac: 64 43 00 00 cmpei r3,r2,0
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
80046b0: b8 40 60 00 mv r12,r2
if ( !once_control || !init_routine )
80046b4: 64 22 00 00 cmpei r2,r1,0
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
80046b8: b8 20 58 00 mv r11,r1
if ( !once_control || !init_routine )
80046bc: b8 62 18 00 or r3,r3,r2
return EINVAL;
80046c0: 34 01 00 16 mvi r1,22
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
80046c4: 5c 60 00 04 bne r3,r0,80046d4 <pthread_once+0x3c>
return EINVAL;
if ( !once_control->init_executed ) {
80046c8: 29 6d 00 04 lw r13,(r11+4)
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
80046cc: 34 01 00 00 mvi r1,0
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
80046d0: 45 a3 00 07 be r13,r3,80046ec <pthread_once+0x54>
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
80046d4: 2b 9d 00 04 lw ra,(sp+4)
80046d8: 2b 8b 00 10 lw r11,(sp+16)
80046dc: 2b 8c 00 0c lw r12,(sp+12)
80046e0: 2b 8d 00 08 lw r13,(sp+8)
80046e4: 37 9c 00 14 addi sp,sp,20
80046e8: c3 a0 00 00 ret
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
80046ec: 34 01 01 00 mvi r1,256
80046f0: 34 02 01 00 mvi r2,256
80046f4: 37 83 00 14 addi r3,sp,20
80046f8: f8 00 01 c4 calli 8004e08 <rtems_task_mode>
if ( !once_control->init_executed ) {
80046fc: 29 61 00 04 lw r1,(r11+4)
8004700: 44 2d 00 0c be r1,r13,8004730 <pthread_once+0x98> <== ALWAYS TAKEN
once_control->is_initialized = true;
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
8004704: 2b 81 00 14 lw r1,(sp+20)
8004708: 34 02 01 00 mvi r2,256
800470c: 37 83 00 14 addi r3,sp,20
8004710: f8 00 01 be calli 8004e08 <rtems_task_mode>
}
return 0;
8004714: 34 01 00 00 mvi r1,0
}
8004718: 2b 9d 00 04 lw ra,(sp+4)
800471c: 2b 8b 00 10 lw r11,(sp+16)
8004720: 2b 8c 00 0c lw r12,(sp+12)
8004724: 2b 8d 00 08 lw r13,(sp+8)
8004728: 37 9c 00 14 addi sp,sp,20
800472c: c3 a0 00 00 ret
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( !once_control->init_executed ) {
once_control->is_initialized = true;
8004730: 34 01 00 01 mvi r1,1
8004734: 59 61 00 00 sw (r11+0),r1
once_control->init_executed = true;
8004738: 59 61 00 04 sw (r11+4),r1
(*init_routine)();
800473c: d9 80 00 00 call r12
8004740: e3 ff ff f1 bi 8004704 <pthread_once+0x6c>
08004828 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
8004828: 37 9c ff e0 addi sp,sp,-32
800482c: 5b 8b 00 14 sw (sp+20),r11
8004830: 5b 8c 00 10 sw (sp+16),r12
8004834: 5b 8d 00 0c sw (sp+12),r13
8004838: 5b 8e 00 08 sw (sp+8),r14
800483c: 5b 9d 00 04 sw (sp+4),ra
8004840: b8 20 58 00 mv r11,r1
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
8004844: 34 01 00 16 mvi r1,22
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
8004848: 45 60 00 07 be r11,r0,8004864 <pthread_rwlock_init+0x3c>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
800484c: 44 40 00 31 be r2,r0,8004910 <pthread_rwlock_init+0xe8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
8004850: 28 43 00 00 lw r3,(r2+0)
return EINVAL;
8004854: 34 01 00 16 mvi r1,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
8004858: 44 60 00 03 be r3,r0,8004864 <pthread_rwlock_init+0x3c> <== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
800485c: 28 4e 00 04 lw r14,(r2+4)
8004860: 45 c0 00 08 be r14,r0,8004880 <pthread_rwlock_init+0x58> <== ALWAYS TAKEN
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
8004864: 2b 9d 00 04 lw ra,(sp+4)
8004868: 2b 8b 00 14 lw r11,(sp+20)
800486c: 2b 8c 00 10 lw r12,(sp+16)
8004870: 2b 8d 00 0c lw r13,(sp+12)
8004874: 2b 8e 00 08 lw r14,(sp+8)
8004878: 37 9c 00 20 addi sp,sp,32
800487c: c3 a0 00 00 ret
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8004880: 78 01 08 02 mvhi r1,0x802
8004884: 38 21 53 28 ori r1,r1,0x5328
8004888: 28 22 00 00 lw r2,(r1+0)
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
800488c: 5b 80 00 20 sw (sp+32),r0
++level;
8004890: 34 42 00 01 addi r2,r2,1
_Thread_Dispatch_disable_level = level;
8004894: 58 22 00 00 sw (r1+0),r2
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
_Objects_Allocate( &_POSIX_RWLock_Information );
8004898: 78 0d 08 02 mvhi r13,0x802
800489c: 39 ad 54 a4 ori r13,r13,0x54a4
80048a0: b9 a0 08 00 mv r1,r13
80048a4: f8 00 0b b1 calli 8007768 <_Objects_Allocate>
80048a8: b8 20 60 00 mv r12,r1
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
80048ac: 44 2e 00 16 be r1,r14,8004904 <pthread_rwlock_init+0xdc> <== NEVER TAKEN
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
80048b0: 37 82 00 20 addi r2,sp,32
80048b4: 34 21 00 10 addi r1,r1,16
80048b8: f8 00 09 9b calli 8006f24 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
80048bc: 29 82 00 08 lw r2,(r12+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80048c0: 29 a3 00 1c lw r3,(r13+28)
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
80048c4: 20 41 ff ff andi r1,r2,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80048c8: b4 21 08 00 add r1,r1,r1
80048cc: b4 21 08 00 add r1,r1,r1
80048d0: b4 61 08 00 add r1,r3,r1
80048d4: 58 2c 00 00 sw (r1+0),r12
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
80048d8: 59 80 00 0c sw (r12+12),r0
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
80048dc: 59 62 00 00 sw (r11+0),r2
_Thread_Enable_dispatch();
80048e0: f8 00 11 3b calli 8008dcc <_Thread_Enable_dispatch>
return 0;
80048e4: 34 01 00 00 mvi r1,0
}
80048e8: 2b 9d 00 04 lw ra,(sp+4)
80048ec: 2b 8b 00 14 lw r11,(sp+20)
80048f0: 2b 8c 00 10 lw r12,(sp+16)
80048f4: 2b 8d 00 0c lw r13,(sp+12)
80048f8: 2b 8e 00 08 lw r14,(sp+8)
80048fc: 37 9c 00 20 addi sp,sp,32
8004900: c3 a0 00 00 ret
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
8004904: f8 00 11 32 calli 8008dcc <_Thread_Enable_dispatch>
return EAGAIN;
8004908: 34 01 00 0b mvi r1,11
800490c: e3 ff ff d6 bi 8004864 <pthread_rwlock_init+0x3c>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
8004910: 37 8c 00 18 addi r12,sp,24
8004914: b9 80 08 00 mv r1,r12
8004918: f8 00 02 29 calli 80051bc <pthread_rwlockattr_init>
the_attr = &default_attr;
800491c: b9 80 10 00 mv r2,r12
8004920: e3 ff ff cc bi 8004850 <pthread_rwlock_init+0x28>
080050e8 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
80050e8: 37 9c ff e0 addi sp,sp,-32
80050ec: 5b 8b 00 18 sw (sp+24),r11
80050f0: 5b 8c 00 14 sw (sp+20),r12
80050f4: 5b 8d 00 10 sw (sp+16),r13
80050f8: 5b 8e 00 0c sw (sp+12),r14
80050fc: 5b 8f 00 08 sw (sp+8),r15
8005100: 5b 9d 00 04 sw (sp+4),ra
8005104: b8 20 58 00 mv r11,r1
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
8005108: 34 0c 00 16 mvi r12,22
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
800510c: b8 40 08 00 mv r1,r2
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
8005110: 45 60 00 0c be r11,r0,8005140 <pthread_rwlock_timedrdlock+0x58>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
8005114: 37 82 00 1c addi r2,sp,28
8005118: f8 00 1b df calli 800c094 <_POSIX_Absolute_timeout_to_ticks>
800511c: 78 03 08 01 mvhi r3,0x801
8005120: 29 62 00 00 lw r2,(r11+0)
8005124: b8 20 70 00 mv r14,r1
8005128: b8 60 08 00 mv r1,r3
800512c: 38 21 9a 44 ori r1,r1,0x9a44
8005130: 37 83 00 20 addi r3,sp,32
8005134: f8 00 0b 7d calli 8007f28 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
8005138: 2b 8d 00 20 lw r13,(sp+32)
800513c: 45 a0 00 0a be r13,r0,8005164 <pthread_rwlock_timedrdlock+0x7c>
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
8005140: b9 80 08 00 mv r1,r12
8005144: 2b 9d 00 04 lw ra,(sp+4)
8005148: 2b 8b 00 18 lw r11,(sp+24)
800514c: 2b 8c 00 14 lw r12,(sp+20)
8005150: 2b 8d 00 10 lw r13,(sp+16)
8005154: 2b 8e 00 0c lw r14,(sp+12)
8005158: 2b 8f 00 08 lw r15,(sp+8)
800515c: 37 9c 00 20 addi sp,sp,32
8005160: c3 a0 00 00 ret
int _EXFUN(pthread_rwlock_init,
(pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedrdlock,
8005164: 65 cf 00 03 cmpei r15,r14,3
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
8005168: 29 62 00 00 lw r2,(r11+0)
800516c: 2b 84 00 1c lw r4,(sp+28)
8005170: 34 21 00 10 addi r1,r1,16
8005174: b9 e0 18 00 mv r3,r15
8005178: 34 05 00 00 mvi r5,0
800517c: f8 00 07 2b calli 8006e28 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
8005180: f8 00 0f 44 calli 8008e90 <_Thread_Enable_dispatch>
if ( !do_wait ) {
8005184: 5d ed 00 10 bne r15,r13,80051c4 <pthread_rwlock_timedrdlock+0xdc>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
8005188: 78 01 08 01 mvhi r1,0x801
800518c: 38 21 9d a0 ori r1,r1,0x9da0
8005190: 28 21 00 10 lw r1,(r1+16)
8005194: 34 02 00 02 mvi r2,2
8005198: 28 21 00 34 lw r1,(r1+52)
800519c: 44 22 00 04 be r1,r2,80051ac <pthread_rwlock_timedrdlock+0xc4>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
80051a0: f8 00 00 4a calli 80052c8 <_POSIX_RWLock_Translate_core_RWLock_return_code>
80051a4: b8 20 60 00 mv r12,r1
80051a8: e3 ff ff e6 bi 8005140 <pthread_rwlock_timedrdlock+0x58>
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
80051ac: 45 cf ff e5 be r14,r15,8005140 <pthread_rwlock_timedrdlock+0x58><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
80051b0: 35 ce ff ff addi r14,r14,-1
80051b4: 34 02 00 01 mvi r2,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
80051b8: 34 0c 00 74 mvi r12,116
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
80051bc: 50 4e ff e1 bgeu r2,r14,8005140 <pthread_rwlock_timedrdlock+0x58><== ALWAYS TAKEN
80051c0: e3 ff ff f8 bi 80051a0 <pthread_rwlock_timedrdlock+0xb8> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
80051c4: 78 01 08 01 mvhi r1,0x801
80051c8: 38 21 9d a0 ori r1,r1,0x9da0
80051cc: 28 21 00 10 lw r1,(r1+16)
80051d0: 28 21 00 34 lw r1,(r1+52)
80051d4: e3 ff ff f3 bi 80051a0 <pthread_rwlock_timedrdlock+0xb8>
080051d8 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
80051d8: 37 9c ff e0 addi sp,sp,-32
80051dc: 5b 8b 00 18 sw (sp+24),r11
80051e0: 5b 8c 00 14 sw (sp+20),r12
80051e4: 5b 8d 00 10 sw (sp+16),r13
80051e8: 5b 8e 00 0c sw (sp+12),r14
80051ec: 5b 8f 00 08 sw (sp+8),r15
80051f0: 5b 9d 00 04 sw (sp+4),ra
80051f4: b8 20 58 00 mv r11,r1
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
80051f8: 34 0c 00 16 mvi r12,22
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
80051fc: b8 40 08 00 mv r1,r2
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
8005200: 45 60 00 0c be r11,r0,8005230 <pthread_rwlock_timedwrlock+0x58>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
8005204: 37 82 00 1c addi r2,sp,28
8005208: f8 00 1b a3 calli 800c094 <_POSIX_Absolute_timeout_to_ticks>
800520c: 78 03 08 01 mvhi r3,0x801
8005210: 29 62 00 00 lw r2,(r11+0)
8005214: b8 20 70 00 mv r14,r1
8005218: b8 60 08 00 mv r1,r3
800521c: 38 21 9a 44 ori r1,r1,0x9a44
8005220: 37 83 00 20 addi r3,sp,32
8005224: f8 00 0b 41 calli 8007f28 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
8005228: 2b 8d 00 20 lw r13,(sp+32)
800522c: 45 a0 00 0a be r13,r0,8005254 <pthread_rwlock_timedwrlock+0x7c>
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
8005230: b9 80 08 00 mv r1,r12
8005234: 2b 9d 00 04 lw ra,(sp+4)
8005238: 2b 8b 00 18 lw r11,(sp+24)
800523c: 2b 8c 00 14 lw r12,(sp+20)
8005240: 2b 8d 00 10 lw r13,(sp+16)
8005244: 2b 8e 00 0c lw r14,(sp+12)
8005248: 2b 8f 00 08 lw r15,(sp+8)
800524c: 37 9c 00 20 addi sp,sp,32
8005250: c3 a0 00 00 ret
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
8005254: 65 cf 00 03 cmpei r15,r14,3
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
8005258: 29 62 00 00 lw r2,(r11+0)
800525c: 2b 84 00 1c lw r4,(sp+28)
8005260: 34 21 00 10 addi r1,r1,16
8005264: b9 e0 18 00 mv r3,r15
8005268: 34 05 00 00 mvi r5,0
800526c: f8 00 07 37 calli 8006f48 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
8005270: f8 00 0f 08 calli 8008e90 <_Thread_Enable_dispatch>
if ( !do_wait &&
8005274: 5d ed 00 10 bne r15,r13,80052b4 <pthread_rwlock_timedwrlock+0xdc>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
8005278: 78 01 08 01 mvhi r1,0x801
800527c: 38 21 9d a0 ori r1,r1,0x9da0
8005280: 28 21 00 10 lw r1,(r1+16)
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
8005284: 34 02 00 02 mvi r2,2
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
8005288: 28 21 00 34 lw r1,(r1+52)
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
800528c: 44 22 00 04 be r1,r2,800529c <pthread_rwlock_timedwrlock+0xc4>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
8005290: f8 00 00 0e calli 80052c8 <_POSIX_RWLock_Translate_core_RWLock_return_code>
8005294: b8 20 60 00 mv r12,r1
8005298: e3 ff ff e6 bi 8005230 <pthread_rwlock_timedwrlock+0x58>
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
800529c: 45 cf ff e5 be r14,r15,8005230 <pthread_rwlock_timedwrlock+0x58><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
80052a0: 35 ce ff ff addi r14,r14,-1
80052a4: 34 02 00 01 mvi r2,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
80052a8: 34 0c 00 74 mvi r12,116
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
80052ac: 50 4e ff e1 bgeu r2,r14,8005230 <pthread_rwlock_timedwrlock+0x58><== ALWAYS TAKEN
80052b0: e3 ff ff f8 bi 8005290 <pthread_rwlock_timedwrlock+0xb8> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
80052b4: 78 01 08 01 mvhi r1,0x801
80052b8: 38 21 9d a0 ori r1,r1,0x9da0
80052bc: 28 21 00 10 lw r1,(r1+16)
80052c0: 28 21 00 34 lw r1,(r1+52)
80052c4: e3 ff ff f3 bi 8005290 <pthread_rwlock_timedwrlock+0xb8>
08005c9c <pthread_rwlockattr_setpshared>:
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
return EINVAL;
8005c9c: 34 03 00 16 mvi r3,22
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
8005ca0: 44 20 00 07 be r1,r0,8005cbc <pthread_rwlockattr_setpshared+0x20>
return EINVAL;
if ( !attr->is_initialized )
8005ca4: 28 24 00 00 lw r4,(r1+0)
8005ca8: 44 80 00 05 be r4,r0,8005cbc <pthread_rwlockattr_setpshared+0x20>
return EINVAL;
switch ( pshared ) {
8005cac: 34 04 00 01 mvi r4,1
8005cb0: 54 44 00 03 bgu r2,r4,8005cbc <pthread_rwlockattr_setpshared+0x20><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
8005cb4: 58 22 00 04 sw (r1+4),r2
return 0;
8005cb8: 34 03 00 00 mvi r3,0
default:
return EINVAL;
}
}
8005cbc: b8 60 08 00 mv r1,r3
8005cc0: c3 a0 00 00 ret
0800720c <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
800720c: 37 9c ff dc addi sp,sp,-36
8007210: 5b 8b 00 18 sw (sp+24),r11
8007214: 5b 8c 00 14 sw (sp+20),r12
8007218: 5b 8d 00 10 sw (sp+16),r13
800721c: 5b 8e 00 0c sw (sp+12),r14
8007220: 5b 8f 00 08 sw (sp+8),r15
8007224: 5b 9d 00 04 sw (sp+4),ra
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
8007228: 34 0c 00 16 mvi r12,22
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
800722c: b8 60 58 00 mv r11,r3
8007230: b8 20 68 00 mv r13,r1
8007234: b8 40 70 00 mv r14,r2
int rc;
/*
* Check all the parameters
*/
if ( !param )
8007238: 44 60 00 08 be r3,r0,8007258 <pthread_setschedparam+0x4c>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
800723c: b8 40 08 00 mv r1,r2
8007240: 37 84 00 20 addi r4,sp,32
8007244: b8 60 10 00 mv r2,r3
8007248: 37 83 00 24 addi r3,sp,36
800724c: f8 00 19 b9 calli 800d930 <_POSIX_Thread_Translate_sched_param>
8007250: b8 20 60 00 mv r12,r1
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
8007254: 44 20 00 0a be r1,r0,800727c <pthread_setschedparam+0x70>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
8007258: b9 80 08 00 mv r1,r12
800725c: 2b 9d 00 04 lw ra,(sp+4)
8007260: 2b 8b 00 18 lw r11,(sp+24)
8007264: 2b 8c 00 14 lw r12,(sp+20)
8007268: 2b 8d 00 10 lw r13,(sp+16)
800726c: 2b 8e 00 0c lw r14,(sp+12)
8007270: 2b 8f 00 08 lw r15,(sp+8)
8007274: 37 9c 00 24 addi sp,sp,36
8007278: c3 a0 00 00 ret
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
800727c: b9 a0 08 00 mv r1,r13
8007280: 37 82 00 1c addi r2,sp,28
8007284: f8 00 0c 38 calli 800a364 <_Thread_Get>
8007288: b8 20 78 00 mv r15,r1
switch ( location ) {
800728c: 2b 81 00 1c lw r1,(sp+28)
8007290: 44 2c 00 03 be r1,r12,800729c <pthread_setschedparam+0x90>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
8007294: 34 0c 00 03 mvi r12,3
8007298: e3 ff ff f0 bi 8007258 <pthread_setschedparam+0x4c>
*/
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
800729c: 29 ed 01 1c lw r13,(r15+284)
if ( api->schedpolicy == SCHED_SPORADIC )
80072a0: 34 01 00 04 mvi r1,4
80072a4: 29 a2 00 84 lw r2,(r13+132)
80072a8: 44 41 00 31 be r2,r1,800736c <pthread_setschedparam+0x160>
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
80072ac: 59 ae 00 84 sw (r13+132),r14
api->schedparam = *param;
80072b0: 29 62 00 00 lw r2,(r11+0)
80072b4: 59 a2 00 88 sw (r13+136),r2
80072b8: 29 61 00 04 lw r1,(r11+4)
80072bc: 59 a1 00 8c sw (r13+140),r1
80072c0: 29 61 00 08 lw r1,(r11+8)
80072c4: 59 a1 00 90 sw (r13+144),r1
80072c8: 29 61 00 0c lw r1,(r11+12)
80072cc: 59 a1 00 94 sw (r13+148),r1
80072d0: 29 61 00 10 lw r1,(r11+16)
80072d4: 59 a1 00 98 sw (r13+152),r1
80072d8: 29 61 00 14 lw r1,(r11+20)
80072dc: 59 a1 00 9c sw (r13+156),r1
80072e0: 29 61 00 18 lw r1,(r11+24)
80072e4: 59 a1 00 a0 sw (r13+160),r1
the_thread->budget_algorithm = budget_algorithm;
80072e8: 2b 81 00 24 lw r1,(sp+36)
80072ec: 59 e1 00 78 sw (r15+120),r1
the_thread->budget_callout = budget_callout;
80072f0: 2b 81 00 20 lw r1,(sp+32)
80072f4: 59 e1 00 7c sw (r15+124),r1
switch ( api->schedpolicy ) {
80072f8: 48 0e 00 05 bg r0,r14,800730c <pthread_setschedparam+0x100><== NEVER TAKEN
80072fc: 34 01 00 02 mvi r1,2
8007300: 4c 2e 00 0d bge r1,r14,8007334 <pthread_setschedparam+0x128>
8007304: 34 01 00 04 mvi r1,4
8007308: 45 c1 00 03 be r14,r1,8007314 <pthread_setschedparam+0x108><== ALWAYS TAKEN
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
800730c: f8 00 0c 0a calli 800a334 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
8007310: e3 ff ff d2 bi 8007258 <pthread_setschedparam+0x4c> <== NOT EXECUTED
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
8007314: 59 a2 00 a4 sw (r13+164),r2
_Watchdog_Remove( &api->Sporadic_timer );
8007318: 35 a1 00 a8 addi r1,r13,168
800731c: f8 00 10 de calli 800b694 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
8007320: 34 01 00 00 mvi r1,0
8007324: b9 e0 10 00 mv r2,r15
8007328: fb ff ff 68 calli 80070c8 <_POSIX_Threads_Sporadic_budget_TSR>
break;
}
_Thread_Enable_dispatch();
800732c: f8 00 0c 02 calli 800a334 <_Thread_Enable_dispatch>
8007330: e3 ff ff ca bi 8007258 <pthread_setschedparam+0x4c>
8007334: 78 03 08 01 mvhi r3,0x801
8007338: 38 63 b0 fc ori r3,r3,0xb0fc
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
800733c: 78 01 08 01 mvhi r1,0x801
8007340: 38 21 b8 e0 ori r1,r1,0xb8e0
8007344: 40 63 00 00 lbu r3,(r3+0)
8007348: 28 24 00 00 lw r4,(r1+0)
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
800734c: b9 e0 08 00 mv r1,r15
8007350: c8 62 10 00 sub r2,r3,r2
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
8007354: 59 e4 00 74 sw (r15+116),r4
the_thread->real_priority =
8007358: 59 e2 00 18 sw (r15+24),r2
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
800735c: 34 03 00 01 mvi r3,1
8007360: f8 00 0a a0 calli 8009de0 <_Thread_Change_priority>
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
8007364: f8 00 0b f4 calli 800a334 <_Thread_Enable_dispatch>
8007368: e3 ff ff bc bi 8007258 <pthread_setschedparam+0x4c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
800736c: 35 a1 00 a8 addi r1,r13,168
8007370: f8 00 10 c9 calli 800b694 <_Watchdog_Remove>
8007374: e3 ff ff ce bi 80072ac <pthread_setschedparam+0xa0>
08003fd8 <pthread_spin_unlock>:
*/
int pthread_spin_unlock(
pthread_spinlock_t *spinlock
)
{
8003fd8: 37 9c ff f0 addi sp,sp,-16
8003fdc: 5b 8b 00 08 sw (sp+8),r11
8003fe0: 5b 9d 00 04 sw (sp+4),ra
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
return EINVAL;
8003fe4: 34 0b 00 16 mvi r11,22
{
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
8003fe8: 44 20 00 0f be r1,r0,8004024 <pthread_spin_unlock+0x4c> <== NEVER TAKEN
8003fec: 28 22 00 00 lw r2,(r1+0)
8003ff0: 78 01 08 01 mvhi r1,0x801
8003ff4: 38 21 6b 04 ori r1,r1,0x6b04
8003ff8: 37 83 00 10 addi r3,sp,16
8003ffc: f8 00 08 cd calli 8006330 <_Objects_Get>
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
8004000: 2b 82 00 10 lw r2,(sp+16)
8004004: 5c 40 00 08 bne r2,r0,8004024 <pthread_spin_unlock+0x4c>
case OBJECTS_LOCAL:
status = _CORE_spinlock_Release( &the_spinlock->Spinlock );
8004008: 34 21 00 10 addi r1,r1,16
800400c: f8 00 05 06 calli 8005424 <_CORE_spinlock_Release>
_Thread_Enable_dispatch();
8004010: 5b 81 00 0c sw (sp+12),r1
8004014: f8 00 0c da calli 800737c <_Thread_Enable_dispatch>
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
8004018: 2b 81 00 0c lw r1,(sp+12)
800401c: fb ff ff cf calli 8003f58 <_POSIX_Spinlock_Translate_core_spinlock_return_code>
8004020: b8 20 58 00 mv r11,r1
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
8004024: b9 60 08 00 mv r1,r11
8004028: 2b 9d 00 04 lw ra,(sp+4)
800402c: 2b 8b 00 08 lw r11,(sp+8)
8004030: 37 9c 00 10 addi sp,sp,16
8004034: c3 a0 00 00 ret
08004350 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
8004350: 37 9c ff f8 addi sp,sp,-8
8004354: 5b 8b 00 08 sw (sp+8),r11
8004358: 5b 9d 00 04 sw (sp+4),ra
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
800435c: 78 0b 08 01 mvhi r11,0x801
8004360: 39 6b 7d 80 ori r11,r11,0x7d80
8004364: 29 62 00 08 lw r2,(r11+8)
8004368: 5c 40 00 10 bne r2,r0,80043a8 <pthread_testcancel+0x58> <== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
800436c: 78 01 08 01 mvhi r1,0x801
8004370: 38 21 78 e0 ori r1,r1,0x78e0
8004374: 28 24 00 00 lw r4,(r1+0)
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
8004378: 29 63 00 10 lw r3,(r11+16)
++level;
800437c: 34 84 00 01 addi r4,r4,1
8004380: 28 63 01 1c lw r3,(r3+284)
_Thread_Dispatch_disable_level = level;
8004384: 58 24 00 00 sw (r1+0),r4
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
8004388: 28 61 00 d8 lw r1,(r3+216)
800438c: 5c 22 00 0b bne r1,r2,80043b8 <pthread_testcancel+0x68> <== NEVER TAKEN
8004390: 28 62 00 e0 lw r2,(r3+224)
8004394: 44 41 00 09 be r2,r1,80043b8 <pthread_testcancel+0x68>
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
8004398: f8 00 0b 34 calli 8007068 <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
800439c: 29 61 00 10 lw r1,(r11+16)
80043a0: 34 02 ff ff mvi r2,-1
80043a4: f8 00 18 da calli 800a70c <_POSIX_Thread_Exit>
}
80043a8: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80043ac: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
80043b0: 37 9c 00 08 addi sp,sp,8 <== NOT EXECUTED
80043b4: c3 a0 00 00 ret <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
80043b8: f8 00 0b 2c calli 8007068 <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
}
80043bc: 2b 9d 00 04 lw ra,(sp+4)
80043c0: 2b 8b 00 08 lw r11,(sp+8)
80043c4: 37 9c 00 08 addi sp,sp,8
80043c8: c3 a0 00 00 ret
08004880 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
8004880: 37 9c ff c4 addi sp,sp,-60
8004884: 5b 8b 00 18 sw (sp+24),r11
8004888: 5b 8c 00 14 sw (sp+20),r12
800488c: 5b 8d 00 10 sw (sp+16),r13
8004890: 5b 8e 00 0c sw (sp+12),r14
8004894: 5b 8f 00 08 sw (sp+8),r15
8004898: 5b 9d 00 04 sw (sp+4),ra
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
800489c: 78 0b 08 01 mvhi r11,0x801
80048a0: 39 6b 88 40 ori r11,r11,0x8840
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
80048a4: b8 20 60 00 mv r12,r1
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
80048a8: b9 60 08 00 mv r1,r11
80048ac: f8 00 02 e7 calli 8005448 <pthread_mutex_lock>
80048b0: b8 20 68 00 mv r13,r1
if (result != 0) {
80048b4: 5c 20 00 52 bne r1,r0,80049fc <rtems_aio_enqueue+0x17c> <== NEVER TAKEN
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
80048b8: f8 00 05 de calli 8006030 <pthread_self>
80048bc: 37 82 00 38 addi r2,sp,56
80048c0: 37 83 00 1c addi r3,sp,28
80048c4: f8 00 04 8c calli 8005af4 <pthread_getschedparam>
req->caller_thread = pthread_self ();
80048c8: f8 00 05 da calli 8006030 <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
80048cc: 29 82 00 14 lw r2,(r12+20)
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
80048d0: 29 63 00 68 lw r3,(r11+104)
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
80048d4: 28 44 00 10 lw r4,(r2+16)
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
80048d8: 59 81 00 10 sw (r12+16),r1
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
80048dc: 2b 81 00 1c lw r1,(sp+28)
80048e0: c8 24 08 00 sub r1,r1,r4
80048e4: 59 81 00 0c sw (r12+12),r1
req->policy = policy;
80048e8: 2b 81 00 38 lw r1,(sp+56)
80048ec: 59 81 00 08 sw (r12+8),r1
req->aiocbp->error_code = EINPROGRESS;
80048f0: 34 01 00 77 mvi r1,119
80048f4: 58 41 00 2c sw (r2+44),r1
req->aiocbp->return_value = 0;
80048f8: 58 40 00 30 sw (r2+48),r0
if ((aio_request_queue.idle_threads == 0) &&
80048fc: 5c 6d 00 24 bne r3,r13,800498c <rtems_aio_enqueue+0x10c> <== NEVER TAKEN
8004900: 29 63 00 64 lw r3,(r11+100)
8004904: 34 01 00 04 mvi r1,4
8004908: 48 61 00 21 bg r3,r1,800498c <rtems_aio_enqueue+0x10c>
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
800490c: 28 42 00 00 lw r2,(r2+0)
8004910: 78 01 08 01 mvhi r1,0x801
8004914: 38 21 88 88 ori r1,r1,0x8888
8004918: 34 03 00 01 mvi r3,1
800491c: fb ff ff 67 calli 80046b8 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
8004920: 28 22 00 18 lw r2,(r1+24)
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
8004924: b8 20 70 00 mv r14,r1
if (r_chain->new_fd == 1) {
8004928: 34 01 00 01 mvi r1,1
800492c: 5c 41 00 1f bne r2,r1,80049a8 <rtems_aio_enqueue+0x128>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
8004930: b9 80 10 00 mv r2,r12
8004934: 35 c1 00 08 addi r1,r14,8
8004938: f8 00 09 11 calli 8006d7c <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
800493c: 34 02 00 00 mvi r2,0
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
if (r_chain->new_fd == 1) {
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
8004940: 59 c0 00 18 sw (r14+24),r0
pthread_mutex_init (&r_chain->mutex, NULL);
8004944: 35 c1 00 1c addi r1,r14,28
8004948: f8 00 02 5f calli 80052c4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
800494c: 34 02 00 00 mvi r2,0
8004950: 35 c1 00 20 addi r1,r14,32
8004954: f8 00 01 24 calli 8004de4 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
8004958: 78 02 08 01 mvhi r2,0x801
800495c: 78 03 08 00 mvhi r3,0x800
8004960: 37 81 00 3c addi r1,sp,60
8004964: 38 42 88 48 ori r2,r2,0x8848
8004968: 38 63 42 7c ori r3,r3,0x427c
800496c: b9 c0 20 00 mv r4,r14
8004970: f8 00 03 8a calli 8005798 <pthread_create>
8004974: b8 20 60 00 mv r12,r1
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
8004978: 5c 20 00 42 bne r1,r0,8004a80 <rtems_aio_enqueue+0x200> <== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
800497c: 29 61 00 64 lw r1,(r11+100)
8004980: 34 21 00 01 addi r1,r1,1
8004984: 59 61 00 64 sw (r11+100),r1
8004988: e0 00 00 12 bi 80049d0 <rtems_aio_enqueue+0x150>
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
800498c: 28 42 00 00 lw r2,(r2+0)
8004990: 78 01 08 01 mvhi r1,0x801
8004994: 38 21 88 88 ori r1,r1,0x8888
8004998: 34 03 00 00 mvi r3,0
800499c: fb ff ff 47 calli 80046b8 <rtems_aio_search_fd>
80049a0: b8 20 70 00 mv r14,r1
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
80049a4: 44 20 00 19 be r1,r0,8004a08 <rtems_aio_enqueue+0x188>
{
pthread_mutex_lock (&r_chain->mutex);
80049a8: 35 cf 00 1c addi r15,r14,28
80049ac: b9 e0 08 00 mv r1,r15
80049b0: f8 00 02 a6 calli 8005448 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
80049b4: 35 c1 00 08 addi r1,r14,8
80049b8: b9 80 10 00 mv r2,r12
80049bc: fb ff fe 1a calli 8004224 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
80049c0: 35 c1 00 20 addi r1,r14,32
80049c4: f8 00 01 49 calli 8004ee8 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
80049c8: b9 e0 08 00 mv r1,r15
80049cc: f8 00 02 cf calli 8005508 <pthread_mutex_unlock>
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
80049d0: b9 60 08 00 mv r1,r11
80049d4: f8 00 02 cd calli 8005508 <pthread_mutex_unlock>
return 0;
}
80049d8: b9 a0 08 00 mv r1,r13
80049dc: 2b 9d 00 04 lw ra,(sp+4)
80049e0: 2b 8b 00 18 lw r11,(sp+24)
80049e4: 2b 8c 00 14 lw r12,(sp+20)
80049e8: 2b 8d 00 10 lw r13,(sp+16)
80049ec: 2b 8e 00 0c lw r14,(sp+12)
80049f0: 2b 8f 00 08 lw r15,(sp+8)
80049f4: 37 9c 00 3c addi sp,sp,60
80049f8: c3 a0 00 00 ret
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
80049fc: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
8004a00: fb ff f3 fa calli 80019e8 <free> <== NOT EXECUTED
return result;
8004a04: e3 ff ff f5 bi 80049d8 <rtems_aio_enqueue+0x158> <== NOT EXECUTED
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
8004a08: 29 82 00 14 lw r2,(r12+20)
8004a0c: 78 01 08 01 mvhi r1,0x801
8004a10: 38 21 88 94 ori r1,r1,0x8894
8004a14: 28 42 00 00 lw r2,(r2+0)
8004a18: 34 03 00 01 mvi r3,1
8004a1c: fb ff ff 27 calli 80046b8 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
8004a20: 28 22 00 18 lw r2,(r1+24)
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
8004a24: b8 20 70 00 mv r14,r1
if (r_chain->new_fd == 1) {
8004a28: 34 01 00 01 mvi r1,1
8004a2c: 44 41 00 0a be r2,r1,8004a54 <rtems_aio_enqueue+0x1d4>
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
pthread_cond_init (&r_chain->cond, NULL);
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
8004a30: 35 c1 00 08 addi r1,r14,8
8004a34: b9 80 10 00 mv r2,r12
8004a38: fb ff fd fb calli 8004224 <rtems_aio_insert_prio>
if (aio_request_queue.idle_threads > 0)
8004a3c: 29 61 00 68 lw r1,(r11+104)
8004a40: 4c 01 ff e4 bge r0,r1,80049d0 <rtems_aio_enqueue+0x150> <== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
8004a44: 78 01 08 01 mvhi r1,0x801 <== NOT EXECUTED
8004a48: 38 21 88 44 ori r1,r1,0x8844 <== NOT EXECUTED
8004a4c: f8 00 01 27 calli 8004ee8 <pthread_cond_signal> <== NOT EXECUTED
8004a50: e3 ff ff e0 bi 80049d0 <rtems_aio_enqueue+0x150> <== NOT EXECUTED
8004a54: 35 c1 00 08 addi r1,r14,8
8004a58: b9 80 10 00 mv r2,r12
8004a5c: f8 00 08 c8 calli 8006d7c <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
8004a60: 35 c1 00 1c addi r1,r14,28
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
8004a64: 59 c0 00 18 sw (r14+24),r0
pthread_mutex_init (&r_chain->mutex, NULL);
8004a68: 34 02 00 00 mvi r2,0
8004a6c: f8 00 02 16 calli 80052c4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
8004a70: 35 c1 00 20 addi r1,r14,32
8004a74: 34 02 00 00 mvi r2,0
8004a78: f8 00 00 db calli 8004de4 <pthread_cond_init>
8004a7c: e3 ff ff f0 bi 8004a3c <rtems_aio_enqueue+0x1bc>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
8004a80: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8004a84: f8 00 02 a1 calli 8005508 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
8004a88: b9 80 68 00 mv r13,r12 <== NOT EXECUTED
8004a8c: e3 ff ff d3 bi 80049d8 <rtems_aio_enqueue+0x158> <== NOT EXECUTED
0800427c <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
800427c: 37 9c ff 98 addi sp,sp,-104
8004280: 5b 8b 00 40 sw (sp+64),r11
8004284: 5b 8c 00 3c sw (sp+60),r12
8004288: 5b 8d 00 38 sw (sp+56),r13
800428c: 5b 8e 00 34 sw (sp+52),r14
8004290: 5b 8f 00 30 sw (sp+48),r15
8004294: 5b 90 00 2c sw (sp+44),r16
8004298: 5b 91 00 28 sw (sp+40),r17
800429c: 5b 92 00 24 sw (sp+36),r18
80042a0: 5b 93 00 20 sw (sp+32),r19
80042a4: 5b 94 00 1c sw (sp+28),r20
80042a8: 5b 95 00 18 sw (sp+24),r21
80042ac: 5b 96 00 14 sw (sp+20),r22
80042b0: 5b 97 00 10 sw (sp+16),r23
80042b4: 5b 98 00 0c sw (sp+12),r24
80042b8: 5b 99 00 08 sw (sp+8),r25
80042bc: 5b 9d 00 04 sw (sp+4),ra
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
80042c0: 78 14 08 01 mvhi r20,0x801
80042c4: 3a 94 88 40 ori r20,r20,0x8840
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
80042c8: 78 16 08 01 mvhi r22,0x801
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
80042cc: 78 15 08 01 mvhi r21,0x801
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
80042d0: 78 17 08 01 mvhi r23,0x801
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
80042d4: b8 20 68 00 mv r13,r1
80042d8: 34 2e 00 1c addi r14,r1,28
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
80042dc: ba 80 90 00 mv r18,r20
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
80042e0: 37 98 00 60 addi r24,sp,96
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
80042e4: 34 19 00 74 mvi r25,116
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
80042e8: 3a d6 88 98 ori r22,r22,0x8898
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
80042ec: 3a b5 88 8c ori r21,r21,0x888c
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
80042f0: 3a f7 88 44 ori r23,r23,0x8844
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
80042f4: 37 8f 00 44 addi r15,sp,68
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
80042f8: 34 10 00 02 mvi r16,2
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
80042fc: 34 11 ff ff mvi r17,-1
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
8004300: 34 13 00 03 mvi r19,3
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
8004304: b9 c0 08 00 mv r1,r14
8004308: f8 00 04 50 calli 8005448 <pthread_mutex_lock>
if (result != 0)
800430c: 5c 20 00 1f bne r1,r0,8004388 <rtems_aio_handle+0x10c> <== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004310: 29 ab 00 08 lw r11,(r13+8)
8004314: 35 a4 00 0c addi r4,r13,12
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
8004318: 45 64 00 45 be r11,r4,800442c <rtems_aio_handle+0x1b0>
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
800431c: f8 00 07 45 calli 8006030 <pthread_self>
8004320: 37 82 00 68 addi r2,sp,104
8004324: b9 e0 18 00 mv r3,r15
8004328: f8 00 05 f3 calli 8005af4 <pthread_getschedparam>
param.sched_priority = req->priority;
800432c: 29 64 00 0c lw r4,(r11+12)
8004330: 5b 84 00 44 sw (sp+68),r4
pthread_setschedparam (pthread_self(), req->policy, ¶m);
8004334: f8 00 07 3f calli 8006030 <pthread_self>
8004338: 29 62 00 08 lw r2,(r11+8)
800433c: b9 e0 18 00 mv r3,r15
8004340: f8 00 07 41 calli 8006044 <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
8004344: b9 60 08 00 mv r1,r11
8004348: f8 00 0a 72 calli 8006d10 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
800434c: b9 c0 08 00 mv r1,r14
8004350: f8 00 04 6e calli 8005508 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
8004354: 29 6c 00 14 lw r12,(r11+20)
8004358: 29 84 00 28 lw r4,(r12+40)
800435c: 44 90 00 2d be r4,r16,8004410 <rtems_aio_handle+0x194>
8004360: 44 93 00 28 be r4,r19,8004400 <rtems_aio_handle+0x184> <== NEVER TAKEN
8004364: 34 05 00 01 mvi r5,1
8004368: 44 85 00 1b be r4,r5,80043d4 <rtems_aio_handle+0x158> <== ALWAYS TAKEN
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
800436c: 59 91 00 30 sw (r12+48),r17 <== NOT EXECUTED
req->aiocbp->error_code = errno;
8004370: f8 00 2d 03 calli 800f77c <__errno> <== NOT EXECUTED
8004374: 28 21 00 00 lw r1,(r1+0) <== NOT EXECUTED
8004378: 59 81 00 2c sw (r12+44),r1 <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
800437c: b9 c0 08 00 mv r1,r14 <== NOT EXECUTED
8004380: f8 00 04 32 calli 8005448 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
8004384: 44 20 ff e3 be r1,r0,8004310 <rtems_aio_handle+0x94> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004388: 34 01 00 00 mvi r1,0
800438c: 2b 9d 00 04 lw ra,(sp+4)
8004390: 2b 8b 00 40 lw r11,(sp+64)
8004394: 2b 8c 00 3c lw r12,(sp+60)
8004398: 2b 8d 00 38 lw r13,(sp+56)
800439c: 2b 8e 00 34 lw r14,(sp+52)
80043a0: 2b 8f 00 30 lw r15,(sp+48)
80043a4: 2b 90 00 2c lw r16,(sp+44)
80043a8: 2b 91 00 28 lw r17,(sp+40)
80043ac: 2b 92 00 24 lw r18,(sp+36)
80043b0: 2b 93 00 20 lw r19,(sp+32)
80043b4: 2b 94 00 1c lw r20,(sp+28)
80043b8: 2b 95 00 18 lw r21,(sp+24)
80043bc: 2b 96 00 14 lw r22,(sp+20)
80043c0: 2b 97 00 10 lw r23,(sp+16)
80043c4: 2b 98 00 0c lw r24,(sp+12)
80043c8: 2b 99 00 08 lw r25,(sp+8)
80043cc: 37 9c 00 68 addi sp,sp,104
80043d0: c3 a0 00 00 ret
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
80043d4: 29 84 00 04 lw r4,(r12+4)
80043d8: 29 81 00 00 lw r1,(r12+0)
80043dc: 29 82 00 08 lw r2,(r12+8)
80043e0: 29 83 00 0c lw r3,(r12+12)
80043e4: f8 00 30 96 calli 801063c <pread>
80043e8: b8 20 20 00 mv r4,r1
break;
default:
result = -1;
}
if (result == -1) {
80043ec: 44 91 00 5b be r4,r17,8004558 <rtems_aio_handle+0x2dc> <== NEVER TAKEN
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
80043f0: 29 65 00 14 lw r5,(r11+20)
80043f4: 58 a4 00 30 sw (r5+48),r4
req->aiocbp->error_code = 0;
80043f8: 58 a0 00 2c sw (r5+44),r0
80043fc: e3 ff ff c2 bi 8004304 <rtems_aio_handle+0x88>
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
8004400: 29 81 00 00 lw r1,(r12+0) <== NOT EXECUTED
8004404: f8 00 1c fe calli 800b7fc <fsync> <== NOT EXECUTED
8004408: b8 20 20 00 mv r4,r1 <== NOT EXECUTED
break;
800440c: e3 ff ff f8 bi 80043ec <rtems_aio_handle+0x170> <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
8004410: 29 84 00 04 lw r4,(r12+4)
8004414: 29 81 00 00 lw r1,(r12+0)
8004418: 29 82 00 08 lw r2,(r12+8)
800441c: 29 83 00 0c lw r3,(r12+12)
8004420: f8 00 30 cb calli 801074c <pwrite>
8004424: b8 20 20 00 mv r4,r1
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
8004428: e3 ff ff f1 bi 80043ec <rtems_aio_handle+0x170>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
800442c: b9 c0 08 00 mv r1,r14
8004430: f8 00 04 36 calli 8005508 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
8004434: ba 40 08 00 mv r1,r18
8004438: f8 00 04 04 calli 8005448 <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
800443c: 29 a1 00 08 lw r1,(r13+8)
8004440: 45 61 00 04 be r11,r1,8004450 <rtems_aio_handle+0x1d4> <== ALWAYS TAKEN
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
8004444: ba 40 08 00 mv r1,r18
8004448: f8 00 04 30 calli 8005508 <pthread_mutex_unlock>
800444c: e3 ff ff ae bi 8004304 <rtems_aio_handle+0x88>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
8004450: bb 00 10 00 mv r2,r24
8004454: 34 01 00 01 mvi r1,1
8004458: f8 00 01 df calli 8004bd4 <clock_gettime>
timeout.tv_sec += 3;
800445c: 2b 84 00 60 lw r4,(sp+96)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
8004460: 35 ab 00 20 addi r11,r13,32
8004464: b9 60 08 00 mv r1,r11
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
8004468: 34 84 00 03 addi r4,r4,3
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
800446c: ba 40 10 00 mv r2,r18
8004470: bb 00 18 00 mv r3,r24
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
8004474: 5b 84 00 60 sw (sp+96),r4
timeout.tv_nsec = 0;
8004478: 5b 80 00 64 sw (sp+100),r0
result = pthread_cond_timedwait (&r_chain->cond,
800447c: f8 00 02 c4 calli 8004f8c <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
8004480: 5c 39 ff f1 bne r1,r25,8004444 <rtems_aio_handle+0x1c8> <== NEVER TAKEN
8004484: b9 a0 08 00 mv r1,r13
8004488: f8 00 0a 22 calli 8006d10 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
800448c: b9 c0 08 00 mv r1,r14
8004490: f8 00 03 26 calli 8005128 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
8004494: b9 60 08 00 mv r1,r11
8004498: f8 00 02 13 calli 8004ce4 <pthread_cond_destroy>
free (r_chain);
800449c: b9 a0 08 00 mv r1,r13
80044a0: fb ff f5 52 calli 80019e8 <free>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
80044a4: 2a 4e 00 54 lw r14,(r18+84)
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
80044a8: 45 d6 00 18 be r14,r22,8004508 <rtems_aio_handle+0x28c>
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
80044ac: 2a 83 00 68 lw r3,(r20+104)
++aio_request_queue.active_threads;
80044b0: 2a 82 00 64 lw r2,(r20+100)
80044b4: b9 c0 08 00 mv r1,r14
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
80044b8: 34 63 ff ff addi r3,r3,-1
++aio_request_queue.active_threads;
80044bc: 34 42 00 01 addi r2,r2,1
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
80044c0: 5a 83 00 68 sw (r20+104),r3
++aio_request_queue.active_threads;
80044c4: 5a 82 00 64 sw (r20+100),r2
80044c8: f8 00 0a 12 calli 8006d10 <_Chain_Extract>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
80044cc: 2a 84 00 48 lw r4,(r20+72)
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
80044d0: 29 c3 00 14 lw r3,(r14+20)
++aio_request_queue.active_threads;
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
80044d4: b9 c0 68 00 mv r13,r14
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
80044d8: 28 81 00 14 lw r1,(r4+20)
80044dc: 4c 23 00 06 bge r1,r3,80044f4 <rtems_aio_handle+0x278> <== NEVER TAKEN
80044e0: 44 95 00 05 be r4,r21,80044f4 <rtems_aio_handle+0x278> <== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
80044e4: 28 84 00 00 lw r4,(r4+0)
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
80044e8: 28 81 00 14 lw r1,(r4+20)
80044ec: 4c 23 00 02 bge r1,r3,80044f4 <rtems_aio_handle+0x278>
80044f0: e3 ff ff fc bi 80044e0 <rtems_aio_handle+0x264>
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
80044f4: 28 81 00 04 lw r1,(r4+4)
80044f8: b9 c0 10 00 mv r2,r14
80044fc: 35 ce 00 1c addi r14,r14,28
8004500: f8 00 0a 1f calli 8006d7c <_Chain_Insert>
8004504: e3 ff ff d0 bi 8004444 <rtems_aio_handle+0x1c8>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
8004508: 2a 44 00 68 lw r4,(r18+104)
--aio_request_queue.active_threads;
800450c: 2a 43 00 64 lw r3,(r18+100)
clock_gettime (CLOCK_REALTIME, &timeout);
8004510: bb 00 10 00 mv r2,r24
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
8004514: 34 84 00 01 addi r4,r4,1
--aio_request_queue.active_threads;
8004518: 34 63 ff ff addi r3,r3,-1
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
800451c: 5a 44 00 68 sw (r18+104),r4
--aio_request_queue.active_threads;
8004520: 5a 43 00 64 sw (r18+100),r3
clock_gettime (CLOCK_REALTIME, &timeout);
8004524: 34 01 00 01 mvi r1,1
8004528: f8 00 01 ab calli 8004bd4 <clock_gettime>
timeout.tv_sec += 3;
800452c: 2b 84 00 60 lw r4,(sp+96)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004530: ba e0 08 00 mv r1,r23
8004534: ba 40 10 00 mv r2,r18
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
8004538: 34 84 00 03 addi r4,r4,3
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
800453c: bb 00 18 00 mv r3,r24
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
8004540: 5b 84 00 60 sw (sp+96),r4
timeout.tv_nsec = 0;
8004544: 5b 80 00 64 sw (sp+100),r0
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004548: f8 00 02 91 calli 8004f8c <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
800454c: 44 39 00 05 be r1,r25,8004560 <rtems_aio_handle+0x2e4> <== ALWAYS TAKEN
8004550: 2a 4e 00 54 lw r14,(r18+84) <== NOT EXECUTED
8004554: e3 ff ff d6 bi 80044ac <rtems_aio_handle+0x230> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
8004558: 29 6c 00 14 lw r12,(r11+20) <== NOT EXECUTED
800455c: e3 ff ff 84 bi 800436c <rtems_aio_handle+0xf0> <== NOT EXECUTED
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
8004560: 2a 42 00 68 lw r2,(r18+104)
pthread_mutex_unlock (&aio_request_queue.mutex);
8004564: ba 40 08 00 mv r1,r18
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
8004568: 34 42 ff ff addi r2,r2,-1
800456c: 5a 42 00 68 sw (r18+104),r2
pthread_mutex_unlock (&aio_request_queue.mutex);
8004570: f8 00 03 e6 calli 8005508 <pthread_mutex_unlock>
return NULL;
8004574: e3 ff ff 85 bi 8004388 <rtems_aio_handle+0x10c>
08004578 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
8004578: 37 9c ff f0 addi sp,sp,-16
800457c: 5b 8b 00 10 sw (sp+16),r11
8004580: 5b 8c 00 0c sw (sp+12),r12
8004584: 5b 8d 00 08 sw (sp+8),r13
8004588: 5b 9d 00 04 sw (sp+4),ra
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
800458c: 78 0c 08 01 mvhi r12,0x801
8004590: 39 8c 88 48 ori r12,r12,0x8848
8004594: b9 80 08 00 mv r1,r12
8004598: f8 00 04 3f calli 8005694 <pthread_attr_init>
800459c: b8 20 68 00 mv r13,r1
if (result != 0)
80045a0: 44 20 00 08 be r1,r0,80045c0 <rtems_aio_init+0x48> <== ALWAYS TAKEN
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
80045a4: b9 a0 08 00 mv r1,r13 <== NOT EXECUTED
80045a8: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80045ac: 2b 8b 00 10 lw r11,(sp+16) <== NOT EXECUTED
80045b0: 2b 8c 00 0c lw r12,(sp+12) <== NOT EXECUTED
80045b4: 2b 8d 00 08 lw r13,(sp+8) <== NOT EXECUTED
80045b8: 37 9c 00 10 addi sp,sp,16 <== NOT EXECUTED
80045bc: c3 a0 00 00 ret <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
80045c0: b9 80 08 00 mv r1,r12
80045c4: 34 02 00 00 mvi r2,0
80045c8: f8 00 04 6a calli 8005770 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
80045cc: 5c 2d 00 26 bne r1,r13,8004664 <rtems_aio_init+0xec> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
80045d0: 78 0b 08 01 mvhi r11,0x801
80045d4: 39 6b 88 40 ori r11,r11,0x8840
80045d8: b9 60 08 00 mv r1,r11
80045dc: 34 02 00 00 mvi r2,0
80045e0: f8 00 03 39 calli 80052c4 <pthread_mutex_init>
if (result != 0)
80045e4: 5c 20 00 28 bne r1,r0,8004684 <rtems_aio_init+0x10c> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
80045e8: 78 01 08 01 mvhi r1,0x801
80045ec: 38 21 88 44 ori r1,r1,0x8844
80045f0: 34 02 00 00 mvi r2,0
80045f4: f8 00 01 fc calli 8004de4 <pthread_cond_init>
80045f8: b8 20 68 00 mv r13,r1
if (result != 0) {
80045fc: 5c 20 00 2a bne r1,r0,80046a4 <rtems_aio_init+0x12c> <== NEVER TAKEN
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
8004600: 78 01 08 01 mvhi r1,0x801
8004604: 38 21 88 94 ori r1,r1,0x8894
8004608: 59 61 00 5c sw (r11+92),r1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
800460c: 78 04 08 01 mvhi r4,0x801
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
8004610: 38 01 b0 0b mvu r1,0xb00b
head->previous = NULL;
tail->previous = head;
8004614: 78 03 08 01 mvhi r3,0x801
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8004618: 78 02 08 01 mvhi r2,0x801
800461c: 38 84 88 8c ori r4,r4,0x888c
head->previous = NULL;
tail->previous = head;
8004620: 38 63 88 88 ori r3,r3,0x8888
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8004624: 38 42 88 98 ori r2,r2,0x8898
8004628: 59 61 00 60 sw (r11+96),r1
return result;
}
800462c: b9 a0 08 00 mv r1,r13
8004630: 59 64 00 48 sw (r11+72),r4
head->previous = NULL;
8004634: 59 60 00 4c sw (r11+76),r0
tail->previous = head;
8004638: 59 63 00 50 sw (r11+80),r3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
800463c: 59 62 00 54 sw (r11+84),r2
head->previous = NULL;
8004640: 59 60 00 58 sw (r11+88),r0
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
8004644: 59 60 00 64 sw (r11+100),r0
aio_request_queue.idle_threads = 0;
8004648: 59 60 00 68 sw (r11+104),r0
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
800464c: 2b 9d 00 04 lw ra,(sp+4)
8004650: 2b 8b 00 10 lw r11,(sp+16)
8004654: 2b 8c 00 0c lw r12,(sp+12)
8004658: 2b 8d 00 08 lw r13,(sp+8)
800465c: 37 9c 00 10 addi sp,sp,16
8004660: c3 a0 00 00 ret
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
8004664: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
8004668: 78 0b 08 01 mvhi r11,0x801 <== NOT EXECUTED
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
800466c: f8 00 04 02 calli 8005674 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
8004670: 39 6b 88 40 ori r11,r11,0x8840 <== NOT EXECUTED
8004674: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8004678: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
800467c: f8 00 03 12 calli 80052c4 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
8004680: 44 20 ff da be r1,r0,80045e8 <rtems_aio_init+0x70> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
8004684: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
8004688: f8 00 03 fb calli 8005674 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
800468c: 78 01 08 01 mvhi r1,0x801 <== NOT EXECUTED
8004690: 38 21 88 44 ori r1,r1,0x8844 <== NOT EXECUTED
8004694: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
8004698: f8 00 01 d3 calli 8004de4 <pthread_cond_init> <== NOT EXECUTED
800469c: b8 20 68 00 mv r13,r1 <== NOT EXECUTED
if (result != 0) {
80046a0: 44 20 ff d8 be r1,r0,8004600 <rtems_aio_init+0x88> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
80046a4: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
80046a8: f8 00 02 a0 calli 8005128 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
80046ac: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
80046b0: f8 00 03 f1 calli 8005674 <pthread_attr_destroy> <== NOT EXECUTED
80046b4: e3 ff ff d3 bi 8004600 <rtems_aio_init+0x88> <== NOT EXECUTED
08004224 <rtems_aio_insert_prio>:
* NONE
*/
static void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
8004224: 37 9c ff fc addi sp,sp,-4
8004228: 5b 9d 00 04 sw (sp+4),ra
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
800422c: 28 23 00 00 lw r3,(r1+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8004230: 34 26 00 04 addi r6,r1,4
* NONE
*/
static void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
8004234: b8 40 38 00 mv r7,r2
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
8004238: 44 66 00 0d be r3,r6,800426c <rtems_aio_insert_prio+0x48> <== NEVER TAKEN
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
800423c: 28 42 00 14 lw r2,(r2+20)
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
8004240: 28 61 00 14 lw r1,(r3+20)
while (req->aiocbp->aio_reqprio > prio &&
8004244: 28 45 00 10 lw r5,(r2+16)
8004248: 28 21 00 10 lw r1,(r1+16)
800424c: 4c 25 00 06 bge r1,r5,8004264 <rtems_aio_insert_prio+0x40> <== ALWAYS TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004250: 28 63 00 00 lw r3,(r3+0) <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
8004254: 28 61 00 14 lw r1,(r3+20) <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
8004258: 28 24 00 10 lw r4,(r1+16) <== NOT EXECUTED
800425c: 4c 85 00 02 bge r4,r5,8004264 <rtems_aio_insert_prio+0x40> <== NOT EXECUTED
8004260: 5c 66 ff fc bne r3,r6,8004250 <rtems_aio_insert_prio+0x2c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
8004264: 28 61 00 04 lw r1,(r3+4)
8004268: b8 e0 10 00 mv r2,r7
800426c: f8 00 0a c4 calli 8006d7c <_Chain_Insert>
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
8004270: 2b 9d 00 04 lw ra,(sp+4)
8004274: 37 9c 00 04 addi sp,sp,4
8004278: c3 a0 00 00 ret
08004798 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
8004798: 37 9c ff ec addi sp,sp,-20
800479c: 5b 8b 00 14 sw (sp+20),r11
80047a0: 5b 8c 00 10 sw (sp+16),r12
80047a4: 5b 8d 00 0c sw (sp+12),r13
80047a8: 5b 8e 00 08 sw (sp+8),r14
80047ac: 5b 9d 00 04 sw (sp+4),ra
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
80047b0: 28 2b 00 08 lw r11,(r1+8)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
80047b4: 34 2c 00 0c addi r12,r1,12
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
80047b8: 45 6c 00 0c be r11,r12,80047e8 <rtems_aio_remove_fd+0x50> <== NEVER TAKEN
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
80047bc: 34 0e 00 8c mvi r14,140
req->aiocbp->return_value = -1;
80047c0: 34 0d ff ff mvi r13,-1
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
80047c4: b9 60 08 00 mv r1,r11
80047c8: f8 00 09 52 calli 8006d10 <_Chain_Extract>
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
80047cc: 29 62 00 14 lw r2,(r11+20)
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
80047d0: b9 60 08 00 mv r1,r11
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
80047d4: 29 6b 00 00 lw r11,(r11+0)
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
80047d8: 58 4e 00 2c sw (r2+44),r14
req->aiocbp->return_value = -1;
80047dc: 58 4d 00 30 sw (r2+48),r13
free (req);
80047e0: fb ff f4 82 calli 80019e8 <free>
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
80047e4: 5d 6c ff f8 bne r11,r12,80047c4 <rtems_aio_remove_fd+0x2c>
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
80047e8: 2b 9d 00 04 lw ra,(sp+4)
80047ec: 2b 8b 00 14 lw r11,(sp+20)
80047f0: 2b 8c 00 10 lw r12,(sp+16)
80047f4: 2b 8d 00 0c lw r13,(sp+12)
80047f8: 2b 8e 00 08 lw r14,(sp+8)
80047fc: 37 9c 00 14 addi sp,sp,20
8004800: c3 a0 00 00 ret
08004804 <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
8004804: 37 9c ff f8 addi sp,sp,-8
8004808: 5b 8b 00 08 sw (sp+8),r11
800480c: 5b 9d 00 04 sw (sp+4),ra
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004810: 28 2b 00 00 lw r11,(r1+0)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8004814: 34 23 00 04 addi r3,r1,4
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
8004818: 34 01 00 02 mvi r1,2
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
800481c: 5d 63 00 04 bne r11,r3,800482c <rtems_aio_remove_req+0x28>
8004820: e0 00 00 0f bi 800485c <rtems_aio_remove_req+0x58>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004824: 29 6b 00 00 lw r11,(r11+0) <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
8004828: 45 63 00 11 be r11,r3,800486c <rtems_aio_remove_req+0x68> <== NOT EXECUTED
800482c: 29 61 00 14 lw r1,(r11+20)
8004830: 5c 22 ff fd bne r1,r2,8004824 <rtems_aio_remove_req+0x20> <== NEVER TAKEN
8004834: b9 60 08 00 mv r1,r11
8004838: f8 00 09 36 calli 8006d10 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
800483c: 29 61 00 14 lw r1,(r11+20)
8004840: 34 02 00 8c mvi r2,140
8004844: 58 22 00 2c sw (r1+44),r2
current->aiocbp->return_value = -1;
8004848: 34 02 ff ff mvi r2,-1
800484c: 58 22 00 30 sw (r1+48),r2
free (current);
8004850: b9 60 08 00 mv r1,r11
8004854: fb ff f4 65 calli 80019e8 <free>
}
return AIO_CANCELED;
8004858: 34 01 00 00 mvi r1,0
}
800485c: 2b 9d 00 04 lw ra,(sp+4)
8004860: 2b 8b 00 08 lw r11,(sp+8)
8004864: 37 9c 00 08 addi sp,sp,8
8004868: c3 a0 00 00 ret
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
800486c: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
8004870: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8004874: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
8004878: 37 9c 00 08 addi sp,sp,8 <== NOT EXECUTED
800487c: c3 a0 00 00 ret <== NOT EXECUTED
080046f8 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
80046f8: 37 9c ff e4 addi sp,sp,-28
80046fc: 5b 8b 00 18 sw (sp+24),r11
8004700: 5b 8c 00 14 sw (sp+20),r12
8004704: 5b 8d 00 10 sw (sp+16),r13
8004708: 5b 8e 00 0c sw (sp+12),r14
800470c: 5b 8f 00 08 sw (sp+8),r15
8004710: 5b 9d 00 04 sw (sp+4),ra
8004714: b8 20 70 00 mv r14,r1
8004718: b8 40 68 00 mv r13,r2
800471c: b8 60 60 00 mv r12,r3
8004720: b8 80 78 00 mv r15,r4
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
8004724: b9 c0 08 00 mv r1,r14
8004728: f8 00 01 a8 calli 8004dc8 <_Chain_Get>
800472c: b8 20 58 00 mv r11,r1
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
8004730: 34 02 00 00 mvi r2,0
8004734: b9 a0 08 00 mv r1,r13
8004738: b9 80 18 00 mv r3,r12
800473c: 37 84 00 1c addi r4,sp,28
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
8004740: 5d 60 00 0e bne r11,r0,8004778 <rtems_chain_get_with_wait+0x80>
) {
rtems_event_set out;
sc = rtems_event_receive(
8004744: fb ff fd 81 calli 8003d48 <rtems_event_receive>
8004748: b8 20 28 00 mv r5,r1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
800474c: 44 2b ff f6 be r1,r11,8004724 <rtems_chain_get_with_wait+0x2c><== NEVER TAKEN
}
*node_ptr = node;
return sc;
}
8004750: b8 a0 08 00 mv r1,r5
timeout,
&out
);
}
*node_ptr = node;
8004754: 59 eb 00 00 sw (r15+0),r11
return sc;
}
8004758: 2b 9d 00 04 lw ra,(sp+4)
800475c: 2b 8b 00 18 lw r11,(sp+24)
8004760: 2b 8c 00 14 lw r12,(sp+20)
8004764: 2b 8d 00 10 lw r13,(sp+16)
8004768: 2b 8e 00 0c lw r14,(sp+12)
800476c: 2b 8f 00 08 lw r15,(sp+8)
8004770: 37 9c 00 1c addi sp,sp,28
8004774: c3 a0 00 00 ret
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
8004778: 34 05 00 00 mvi r5,0
800477c: e3 ff ff f5 bi 8004750 <rtems_chain_get_with_wait+0x58>
080112dc <rtems_clock_set_nanoseconds_extension>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
80112dc: b8 20 18 00 mv r3,r1
if ( !routine )
return RTEMS_INVALID_ADDRESS;
80112e0: 34 01 00 09 mvi r1,9
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
if ( !routine )
80112e4: 44 60 00 05 be r3,r0,80112f8 <rtems_clock_set_nanoseconds_extension+0x1c><== ALWAYS TAKEN
return RTEMS_INVALID_ADDRESS;
_Watchdog_Nanoseconds_since_tick_handler = routine;
80112e8: 78 02 08 03 mvhi r2,0x803 <== NOT EXECUTED
80112ec: 38 42 b1 c8 ori r2,r2,0xb1c8 <== NOT EXECUTED
80112f0: 58 43 00 00 sw (r2+0),r3 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
80112f4: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
}
80112f8: c3 a0 00 00 ret
0800f248 <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
800f248: 37 9c ff f8 addi sp,sp,-8
800f24c: 5b 8b 00 08 sw (sp+8),r11
800f250: 5b 9d 00 04 sw (sp+4),ra
} else {
*event_out = event->pending_events;
sc = RTEMS_SUCCESSFUL;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
800f254: 34 05 00 09 mvi r5,9
rtems_event_set *event_out
)
{
rtems_status_code sc;
if ( event_out != NULL ) {
800f258: 44 80 00 09 be r4,r0,800f27c <rtems_event_system_receive+0x34><== NEVER TAKEN
Thread_Control *executing = _Thread_Executing;
800f25c: 78 05 08 01 mvhi r5,0x801
800f260: 38 a5 ae 00 ori r5,r5,0xae00
800f264: 28 ab 00 10 lw r11,(r5+16)
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
800f268: 29 66 01 18 lw r6,(r11+280)
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
800f26c: 5c 20 00 09 bne r1,r0,800f290 <rtems_event_system_receive+0x48><== ALWAYS TAKEN
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
800f270: 28 c1 00 04 lw r1,(r6+4) <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
800f274: 34 05 00 00 mvi r5,0 <== NOT EXECUTED
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
800f278: 58 81 00 00 sw (r4+0),r1 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
800f27c: b8 a0 08 00 mv r1,r5 <== NOT EXECUTED
800f280: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
800f284: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
800f288: 37 9c 00 08 addi sp,sp,8 <== NOT EXECUTED
800f28c: c3 a0 00 00 ret <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
800f290: 78 05 08 01 mvhi r5,0x801
800f294: 38 a5 a9 78 ori r5,r5,0xa978
800f298: 28 a7 00 00 lw r7,(r5+0)
++level;
800f29c: 34 e7 00 01 addi r7,r7,1
_Thread_Dispatch_disable_level = level;
800f2a0: 58 a7 00 00 sw (r5+0),r7
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
_Thread_Disable_dispatch();
_Event_Seize(
800f2a4: 78 07 08 01 mvhi r7,0x801
800f2a8: b9 60 28 00 mv r5,r11
800f2ac: 34 c6 00 04 addi r6,r6,4
800f2b0: 38 e7 b2 28 ori r7,r7,0xb228
800f2b4: 78 08 00 04 mvhi r8,0x4
800f2b8: fb ff fe 79 calli 800ec9c <_Event_Seize>
executing,
event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
800f2bc: fb ff e2 c1 calli 8007dc0 <_Thread_Enable_dispatch>
sc = executing->Wait.return_code;
800f2c0: 29 65 00 34 lw r5,(r11+52)
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
800f2c4: b8 a0 08 00 mv r1,r5
800f2c8: 2b 9d 00 04 lw ra,(sp+4)
800f2cc: 2b 8b 00 08 lw r11,(sp+8)
800f2d0: 37 9c 00 08 addi sp,sp,8
800f2d4: c3 a0 00 00 ret
08003eb0 <rtems_event_system_send>:
rtems_status_code rtems_event_system_send(
rtems_id id,
rtems_event_set event_in
)
{
8003eb0: 37 9c ff f4 addi sp,sp,-12
8003eb4: 5b 8b 00 08 sw (sp+8),r11
8003eb8: 5b 9d 00 04 sw (sp+4),ra
8003ebc: b8 40 58 00 mv r11,r2
rtems_status_code sc;
Thread_Control *thread;
Objects_Locations location;
RTEMS_API_Control *api;
thread = _Thread_Get( id, &location );
8003ec0: 37 82 00 0c addi r2,sp,12
8003ec4: f8 00 0b 68 calli 8006c64 <_Thread_Get>
switch ( location ) {
8003ec8: 2b 82 00 0c lw r2,(sp+12)
8003ecc: 44 40 00 06 be r2,r0,8003ee4 <rtems_event_system_send+0x34><== ALWAYS TAKEN
case OBJECTS_REMOTE:
sc = RTEMS_ILLEGAL_ON_REMOTE_OBJECT;
break;
#endif
default:
sc = RTEMS_INVALID_ID;
8003ed0: 34 01 00 04 mvi r1,4 <== NOT EXECUTED
break;
}
return sc;
}
8003ed4: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8003ed8: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
8003edc: 37 9c 00 0c addi sp,sp,12 <== NOT EXECUTED
8003ee0: c3 a0 00 00 ret <== NOT EXECUTED
thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = thread->API_Extensions[ THREAD_API_RTEMS ];
_Event_Surrender(
8003ee4: 28 23 01 18 lw r3,(r1+280)
8003ee8: 78 04 08 02 mvhi r4,0x802
8003eec: b9 60 10 00 mv r2,r11
8003ef0: 34 63 00 04 addi r3,r3,4
8003ef4: 38 84 12 08 ori r4,r4,0x1208
8003ef8: 78 05 00 04 mvhi r5,0x4
8003efc: f8 00 19 41 calli 800a400 <_Event_Surrender>
event_in,
&api->System_event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
8003f00: f8 00 0b 4d calli 8006c34 <_Thread_Enable_dispatch>
sc = RTEMS_SUCCESSFUL;
8003f04: 34 01 00 00 mvi r1,0
sc = RTEMS_INVALID_ID;
break;
}
return sc;
}
8003f08: 2b 9d 00 04 lw ra,(sp+4)
8003f0c: 2b 8b 00 08 lw r11,(sp+8)
8003f10: 37 9c 00 0c addi sp,sp,12
8003f14: c3 a0 00 00 ret
080059f0 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
80059f0: 37 9c ff f8 addi sp,sp,-8
80059f4: 5b 8b 00 08 sw (sp+8),r11
80059f8: 5b 9d 00 04 sw (sp+4),ra
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
80059fc: 78 04 08 01 mvhi r4,0x801
8005a00: 38 84 ae 00 ori r4,r4,0xae00
8005a04: 28 85 00 08 lw r5,(r4+8)
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
8005a08: 78 04 08 01 mvhi r4,0x801
8005a0c: 38 84 b2 b0 ori r4,r4,0xb2b0
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
8005a10: b8 20 58 00 mv r11,r1
rtems_device_major_number major_limit = _IO_Number_of_drivers;
8005a14: 28 86 00 00 lw r6,(r4+0)
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
8005a18: 34 01 00 12 mvi r1,18
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
8005a1c: 5c a0 00 33 bne r5,r0,8005ae8 <rtems_io_register_driver+0xf8>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
8005a20: 34 01 00 09 mvi r1,9
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
8005a24: 44 65 00 31 be r3,r5,8005ae8 <rtems_io_register_driver+0xf8>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
8005a28: 58 66 00 00 sw (r3+0),r6
if ( driver_table == NULL )
8005a2c: 44 40 00 2f be r2,r0,8005ae8 <rtems_io_register_driver+0xf8>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
8005a30: 28 45 00 00 lw r5,(r2+0)
8005a34: 44 a0 00 42 be r5,r0,8005b3c <rtems_io_register_driver+0x14c>
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
8005a38: 34 01 00 0a mvi r1,10
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
8005a3c: 51 66 00 2b bgeu r11,r6,8005ae8 <rtems_io_register_driver+0xf8>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8005a40: 78 01 08 01 mvhi r1,0x801
8005a44: 38 21 a9 78 ori r1,r1,0xa978
8005a48: 28 25 00 00 lw r5,(r1+0)
++level;
8005a4c: 34 a5 00 01 addi r5,r5,1
_Thread_Dispatch_disable_level = level;
8005a50: 58 25 00 00 sw (r1+0),r5
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
8005a54: 5d 60 00 29 bne r11,r0,8005af8 <rtems_io_register_driver+0x108>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
8005a58: 28 85 00 00 lw r5,(r4+0)
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
8005a5c: 44 ab 00 3e be r5,r11,8005b54 <rtems_io_register_driver+0x164><== NEVER TAKEN
8005a60: 78 06 08 01 mvhi r6,0x801
8005a64: 38 c6 b2 b4 ori r6,r6,0xb2b4
8005a68: 28 c1 00 00 lw r1,(r6+0)
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
8005a6c: 28 24 00 00 lw r4,(r1+0)
8005a70: 44 80 00 36 be r4,r0,8005b48 <rtems_io_register_driver+0x158>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
8005a74: 35 6b 00 01 addi r11,r11,1
8005a78: 34 21 00 18 addi r1,r1,24
8005a7c: 54 ab ff fc bgu r5,r11,8005a6c <rtems_io_register_driver+0x7c>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
8005a80: 58 6b 00 00 sw (r3+0),r11
if ( m != n )
8005a84: 44 ab 00 35 be r5,r11,8005b58 <rtems_io_register_driver+0x168>
8005a88: b5 6b 08 00 add r1,r11,r11
8005a8c: b4 2b 08 00 add r1,r1,r11
8005a90: b4 21 08 00 add r1,r1,r1
8005a94: b4 21 08 00 add r1,r1,r1
8005a98: b4 21 08 00 add r1,r1,r1
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
8005a9c: 28 c3 00 00 lw r3,(r6+0)
8005aa0: 28 44 00 00 lw r4,(r2+0)
8005aa4: b4 61 08 00 add r1,r3,r1
8005aa8: 58 24 00 00 sw (r1+0),r4
8005aac: 28 43 00 04 lw r3,(r2+4)
8005ab0: 58 23 00 04 sw (r1+4),r3
8005ab4: 28 43 00 08 lw r3,(r2+8)
8005ab8: 58 23 00 08 sw (r1+8),r3
8005abc: 28 43 00 0c lw r3,(r2+12)
8005ac0: 58 23 00 0c sw (r1+12),r3
8005ac4: 28 43 00 10 lw r3,(r2+16)
8005ac8: 58 23 00 10 sw (r1+16),r3
8005acc: 28 42 00 14 lw r2,(r2+20)
8005ad0: 58 22 00 14 sw (r1+20),r2
_Thread_Enable_dispatch();
8005ad4: f8 00 08 bb calli 8007dc0 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
8005ad8: b9 60 08 00 mv r1,r11
8005adc: 34 02 00 00 mvi r2,0
8005ae0: 34 03 00 00 mvi r3,0
8005ae4: f8 00 27 94 calli 800f934 <rtems_io_initialize>
}
8005ae8: 2b 9d 00 04 lw ra,(sp+4)
8005aec: 2b 8b 00 08 lw r11,(sp+8)
8005af0: 37 9c 00 08 addi sp,sp,8
8005af4: c3 a0 00 00 ret
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
8005af8: b5 6b 08 00 add r1,r11,r11
8005afc: 78 06 08 01 mvhi r6,0x801
8005b00: b4 2b 08 00 add r1,r1,r11
8005b04: 38 c6 b2 b4 ori r6,r6,0xb2b4
8005b08: b4 21 08 00 add r1,r1,r1
8005b0c: 28 c5 00 00 lw r5,(r6+0)
8005b10: b4 21 08 00 add r1,r1,r1
8005b14: b4 21 08 00 add r1,r1,r1
8005b18: b4 a1 28 00 add r5,r5,r1
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
8005b1c: 28 a4 00 00 lw r4,(r5+0)
8005b20: 44 80 00 11 be r4,r0,8005b64 <rtems_io_register_driver+0x174>
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
8005b24: f8 00 08 a7 calli 8007dc0 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
8005b28: 34 01 00 0c mvi r1,12
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
8005b2c: 2b 9d 00 04 lw ra,(sp+4)
8005b30: 2b 8b 00 08 lw r11,(sp+8)
8005b34: 37 9c 00 08 addi sp,sp,8
8005b38: c3 a0 00 00 ret
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
8005b3c: 28 47 00 04 lw r7,(r2+4)
8005b40: 5c e5 ff be bne r7,r5,8005a38 <rtems_io_register_driver+0x48>
8005b44: e3 ff ff e9 bi 8005ae8 <rtems_io_register_driver+0xf8>
8005b48: 28 27 00 04 lw r7,(r1+4)
8005b4c: 5c e4 ff ca bne r7,r4,8005a74 <rtems_io_register_driver+0x84>
8005b50: e3 ff ff cc bi 8005a80 <rtems_io_register_driver+0x90>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
8005b54: 58 60 00 00 sw (r3+0),r0 <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
8005b58: f8 00 08 9a calli 8007dc0 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
8005b5c: 34 01 00 05 mvi r1,5
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
8005b60: e3 ff ff e2 bi 8005ae8 <rtems_io_register_driver+0xf8>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
8005b64: 28 a5 00 04 lw r5,(r5+4)
8005b68: 5c a4 ff ef bne r5,r4,8005b24 <rtems_io_register_driver+0x134>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
8005b6c: 58 6b 00 00 sw (r3+0),r11
8005b70: e3 ff ff cb bi 8005a9c <rtems_io_register_driver+0xac>
08007198 <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)
{
8007198: 37 9c ff e4 addi sp,sp,-28
800719c: 5b 8b 00 1c sw (sp+28),r11
80071a0: 5b 8c 00 18 sw (sp+24),r12
80071a4: 5b 8d 00 14 sw (sp+20),r13
80071a8: 5b 8e 00 10 sw (sp+16),r14
80071ac: 5b 8f 00 0c sw (sp+12),r15
80071b0: 5b 90 00 08 sw (sp+8),r16
80071b4: 5b 9d 00 04 sw (sp+4),ra
80071b8: b8 20 78 00 mv r15,r1
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
80071bc: 44 20 00 19 be r1,r0,8007220 <rtems_iterate_over_all_threads+0x88><== NEVER TAKEN
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
80071c0: 78 01 08 02 mvhi r1,0x802
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
80071c4: 78 0e 08 02 mvhi r14,0x802
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
80071c8: 38 21 2c f4 ori r1,r1,0x2cf4
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
80071cc: 39 ce 2c f8 ori r14,r14,0x2cf8
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
80071d0: 34 30 00 10 addi r16,r1,16
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
80071d4: 29 c1 00 00 lw r1,(r14+0)
80071d8: 28 2d 00 04 lw r13,(r1+4)
if ( !information )
80071dc: 45 a0 00 0f be r13,r0,8007218 <rtems_iterate_over_all_threads+0x80>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
80071e0: 2d a3 00 10 lhu r3,(r13+16)
80071e4: 44 60 00 0d be r3,r0,8007218 <rtems_iterate_over_all_threads+0x80>
80071e8: 34 0c 00 04 mvi r12,4
80071ec: 34 0b 00 01 mvi r11,1
the_thread = (Thread_Control *)information->local_table[ i ];
80071f0: 29 a2 00 1c lw r2,(r13+28)
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
80071f4: 35 6b 00 01 addi r11,r11,1
the_thread = (Thread_Control *)information->local_table[ i ];
80071f8: b4 4c 10 00 add r2,r2,r12
80071fc: 28 42 00 00 lw r2,(r2+0)
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
8007200: 35 8c 00 04 addi r12,r12,4
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
(*routine)(the_thread);
8007204: b8 40 08 00 mv r1,r2
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
8007208: 44 40 00 03 be r2,r0,8007214 <rtems_iterate_over_all_threads+0x7c>
continue;
(*routine)(the_thread);
800720c: d9 e0 00 00 call r15
8007210: 2d a3 00 10 lhu r3,(r13+16)
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
8007214: 50 6b ff f7 bgeu r3,r11,80071f0 <rtems_iterate_over_all_threads+0x58>
8007218: 35 ce 00 04 addi r14,r14,4
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
800721c: 5d d0 ff ee bne r14,r16,80071d4 <rtems_iterate_over_all_threads+0x3c>
(*routine)(the_thread);
}
}
}
8007220: 2b 9d 00 04 lw ra,(sp+4)
8007224: 2b 8b 00 1c lw r11,(sp+28)
8007228: 2b 8c 00 18 lw r12,(sp+24)
800722c: 2b 8d 00 14 lw r13,(sp+20)
8007230: 2b 8e 00 10 lw r14,(sp+16)
8007234: 2b 8f 00 0c lw r15,(sp+12)
8007238: 2b 90 00 08 lw r16,(sp+8)
800723c: 37 9c 00 1c addi sp,sp,28
8007240: c3 a0 00 00 ret
08005944 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
8005944: 37 9c ff f8 addi sp,sp,-8
8005948: 5b 8b 00 08 sw (sp+8),r11
800594c: 5b 9d 00 04 sw (sp+4),ra
8005950: b8 60 58 00 mv r11,r3
/*
* Validate parameters and look up information structure.
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
8005954: 34 03 00 09 mvi r3,9
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
8005958: 45 60 00 1e be r11,r0,80059d0 <rtems_object_get_class_information+0x8c>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
800595c: 20 42 ff ff andi r2,r2,0xffff
8005960: f8 00 08 08 calli 8007980 <_Objects_Get_information>
8005964: b8 20 10 00 mv r2,r1
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
8005968: 34 03 00 0a mvi r3,10
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
800596c: 44 20 00 19 be r1,r0,80059d0 <rtems_object_get_class_information+0x8c>
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
8005970: 28 24 00 08 lw r4,(r1+8)
info->maximum_id = obj_info->maximum_id;
8005974: 28 23 00 0c lw r3,(r1+12)
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
8005978: 2c 46 00 10 lhu r6,(r2+16)
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
800597c: 40 21 00 12 lbu r1,(r1+18)
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
8005980: 59 64 00 00 sw (r11+0),r4
info->maximum_id = obj_info->maximum_id;
8005984: 59 63 00 04 sw (r11+4),r3
info->auto_extend = obj_info->auto_extend;
8005988: 31 61 00 0c sb (r11+12),r1
info->maximum = obj_info->maximum;
800598c: 59 66 00 08 sw (r11+8),r6
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
8005990: 34 04 00 00 mvi r4,0
8005994: 44 c0 00 0d be r6,r0,80059c8 <rtems_object_get_class_information+0x84><== NEVER TAKEN
8005998: 28 43 00 1c lw r3,(r2+28)
800599c: 34 01 00 01 mvi r1,1
80059a0: 34 02 00 01 mvi r2,1
if ( !obj_info->local_table[i] )
80059a4: b4 21 08 00 add r1,r1,r1
80059a8: b4 21 08 00 add r1,r1,r1
80059ac: b4 61 08 00 add r1,r3,r1
80059b0: 28 25 00 00 lw r5,(r1+0)
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
80059b4: 34 42 00 01 addi r2,r2,1
80059b8: b8 40 08 00 mv r1,r2
if ( !obj_info->local_table[i] )
unallocated++;
80059bc: 64 a5 00 00 cmpei r5,r5,0
80059c0: b4 85 20 00 add r4,r4,r5
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
80059c4: 50 c2 ff f8 bgeu r6,r2,80059a4 <rtems_object_get_class_information+0x60>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
80059c8: 59 64 00 10 sw (r11+16),r4
return RTEMS_SUCCESSFUL;
80059cc: 34 03 00 00 mvi r3,0
}
80059d0: b8 60 08 00 mv r1,r3
80059d4: 2b 9d 00 04 lw ra,(sp+4)
80059d8: 2b 8b 00 08 lw r11,(sp+8)
80059dc: 37 9c 00 08 addi sp,sp,8
80059e0: c3 a0 00 00 ret
0800552c <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
800552c: 37 9c ff d8 addi sp,sp,-40
8005530: 5b 8b 00 18 sw (sp+24),r11
8005534: 5b 8c 00 14 sw (sp+20),r12
8005538: 5b 8d 00 10 sw (sp+16),r13
800553c: 5b 8e 00 0c sw (sp+12),r14
8005540: 5b 8f 00 08 sw (sp+8),r15
8005544: 5b 9d 00 04 sw (sp+4),ra
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
8005548: 34 07 00 03 mvi r7,3
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
800554c: b8 20 60 00 mv r12,r1
8005550: b8 40 58 00 mv r11,r2
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
8005554: 44 20 00 3e be r1,r0,800564c <rtems_partition_create+0x120>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
8005558: 34 07 00 09 mvi r7,9
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
800555c: 44 40 00 3c be r2,r0,800564c <rtems_partition_create+0x120>
return RTEMS_INVALID_ADDRESS;
if ( !id )
8005560: 44 c0 00 3b be r6,r0,800564c <rtems_partition_create+0x120><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
8005564: 64 82 00 00 cmpei r2,r4,0
8005568: 64 61 00 00 cmpei r1,r3,0
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
800556c: 34 07 00 08 mvi r7,8
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
8005570: b8 41 08 00 or r1,r2,r1
8005574: 5c 20 00 36 bne r1,r0,800564c <rtems_partition_create+0x120>
8005578: 54 83 00 35 bgu r4,r3,800564c <rtems_partition_create+0x120>
*/
RTEMS_INLINE_ROUTINE bool _Partition_Is_buffer_size_aligned (
uint32_t buffer_size
)
{
return ((buffer_size % CPU_PARTITION_ALIGNMENT) == 0);
800557c: 20 81 00 03 andi r1,r4,0x3
8005580: 5c 20 00 33 bne r1,r0,800564c <rtems_partition_create+0x120>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
8005584: 21 6f 00 03 andi r15,r11,0x3
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
8005588: 34 07 00 09 mvi r7,9
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
800558c: 5d e1 00 30 bne r15,r1,800564c <rtems_partition_create+0x120>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8005590: 78 01 08 02 mvhi r1,0x802
8005594: 38 21 53 28 ori r1,r1,0x5328
8005598: 28 22 00 00 lw r2,(r1+0)
++level;
800559c: 34 42 00 01 addi r2,r2,1
_Thread_Dispatch_disable_level = level;
80055a0: 58 22 00 00 sw (r1+0),r2
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
80055a4: 78 0e 08 02 mvhi r14,0x802
80055a8: 39 ce 51 68 ori r14,r14,0x5168
80055ac: b9 c0 08 00 mv r1,r14
80055b0: 5b 83 00 28 sw (sp+40),r3
80055b4: 5b 84 00 20 sw (sp+32),r4
80055b8: 5b 85 00 24 sw (sp+36),r5
80055bc: 5b 86 00 1c sw (sp+28),r6
80055c0: f8 00 08 6a calli 8007768 <_Objects_Allocate>
80055c4: b8 20 68 00 mv r13,r1
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
80055c8: 2b 83 00 28 lw r3,(sp+40)
80055cc: 2b 84 00 20 lw r4,(sp+32)
80055d0: 2b 85 00 24 lw r5,(sp+36)
80055d4: 2b 86 00 1c lw r6,(sp+28)
80055d8: 44 2f 00 26 be r1,r15,8005670 <rtems_partition_create+0x144>
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
80055dc: 58 25 00 1c sw (r1+28),r5
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
80055e0: 58 23 00 14 sw (r1+20),r3
the_partition->buffer_size = buffer_size;
80055e4: 58 24 00 18 sw (r1+24),r4
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
80055e8: 58 2b 00 10 sw (r1+16),r11
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
80055ec: 58 20 00 20 sw (r1+32),r0
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
80055f0: b8 80 10 00 mv r2,r4
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
80055f4: 34 2f 00 24 addi r15,r1,36
length / buffer_size, buffer_size );
80055f8: b8 60 08 00 mv r1,r3
80055fc: 5b 86 00 1c sw (sp+28),r6
8005600: 5b 84 00 20 sw (sp+32),r4
8005604: f8 00 64 31 calli 801e6c8 <__udivsi3>
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
8005608: 2b 84 00 20 lw r4,(sp+32)
length / buffer_size, buffer_size );
800560c: b8 20 18 00 mv r3,r1
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
8005610: b9 60 10 00 mv r2,r11
8005614: b9 e0 08 00 mv r1,r15
8005618: f8 00 05 2b calli 8006ac4 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
800561c: 29 a2 00 08 lw r2,(r13+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8005620: 29 c3 00 1c lw r3,(r14+28)
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
8005624: 20 41 ff ff andi r1,r2,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8005628: b4 21 08 00 add r1,r1,r1
800562c: b4 21 08 00 add r1,r1,r1
8005630: b4 61 08 00 add r1,r3,r1
8005634: 58 2d 00 00 sw (r1+0),r13
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
8005638: 59 ac 00 0c sw (r13+12),r12
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
800563c: 2b 86 00 1c lw r6,(sp+28)
8005640: 58 c2 00 00 sw (r6+0),r2
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
8005644: f8 00 0d e2 calli 8008dcc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8005648: 34 07 00 00 mvi r7,0
}
800564c: b8 e0 08 00 mv r1,r7
8005650: 2b 9d 00 04 lw ra,(sp+4)
8005654: 2b 8b 00 18 lw r11,(sp+24)
8005658: 2b 8c 00 14 lw r12,(sp+20)
800565c: 2b 8d 00 10 lw r13,(sp+16)
8005660: 2b 8e 00 0c lw r14,(sp+12)
8005664: 2b 8f 00 08 lw r15,(sp+8)
8005668: 37 9c 00 28 addi sp,sp,40
800566c: c3 a0 00 00 ret
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
8005670: f8 00 0d d7 calli 8008dcc <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
8005674: 34 07 00 05 mvi r7,5
8005678: e3 ff ff f5 bi 800564c <rtems_partition_create+0x120>
080389dc <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
80389dc: 37 9c ff e4 addi sp,sp,-28
80389e0: 5b 8b 00 18 sw (sp+24),r11
80389e4: 5b 8c 00 14 sw (sp+20),r12
80389e8: 5b 8d 00 10 sw (sp+16),r13
80389ec: 5b 8e 00 0c sw (sp+12),r14
80389f0: 5b 8f 00 08 sw (sp+8),r15
80389f4: 5b 9d 00 04 sw (sp+4),ra
80389f8: 78 03 08 06 mvhi r3,0x806
80389fc: b8 20 68 00 mv r13,r1
8038a00: b8 60 08 00 mv r1,r3
8038a04: b8 40 70 00 mv r14,r2
8038a08: 38 21 fb 30 ori r1,r1,0xfb30
8038a0c: b9 a0 10 00 mv r2,r13
8038a10: 37 83 00 1c addi r3,sp,28
8038a14: fb ff 31 eb calli 80051c0 <_Objects_Get>
8038a18: b8 20 58 00 mv r11,r1
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
8038a1c: 2b 81 00 1c lw r1,(sp+28)
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8038a20: 34 0c 00 04 mvi r12,4
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
8038a24: 44 20 00 0a be r1,r0,8038a4c <rtems_rate_monotonic_period+0x70>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8038a28: b9 80 08 00 mv r1,r12
8038a2c: 2b 9d 00 04 lw ra,(sp+4)
8038a30: 2b 8b 00 18 lw r11,(sp+24)
8038a34: 2b 8c 00 14 lw r12,(sp+20)
8038a38: 2b 8d 00 10 lw r13,(sp+16)
8038a3c: 2b 8e 00 0c lw r14,(sp+12)
8038a40: 2b 8f 00 08 lw r15,(sp+8)
8038a44: 37 9c 00 1c addi sp,sp,28
8038a48: c3 a0 00 00 ret
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
8038a4c: 78 0c 08 06 mvhi r12,0x806
8038a50: 39 8c f5 00 ori r12,r12,0xf500
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
8038a54: 29 62 00 40 lw r2,(r11+64)
8038a58: 29 81 00 10 lw r1,(r12+16)
8038a5c: 44 41 00 04 be r2,r1,8038a6c <rtems_rate_monotonic_period+0x90>
_Thread_Enable_dispatch();
8038a60: fb ff 35 a6 calli 80060f8 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
8038a64: 34 0c 00 17 mvi r12,23
8038a68: e3 ff ff f0 bi 8038a28 <rtems_rate_monotonic_period+0x4c>
}
if ( length == RTEMS_PERIOD_STATUS ) {
8038a6c: 5d c0 00 0d bne r14,r0,8038aa0 <rtems_rate_monotonic_period+0xc4>
switch ( the_period->state ) {
8038a70: 29 61 00 38 lw r1,(r11+56)
8038a74: 34 02 00 04 mvi r2,4
8038a78: 34 0c 00 00 mvi r12,0
8038a7c: 54 22 00 07 bgu r1,r2,8038a98 <rtems_rate_monotonic_period+0xbc><== NEVER TAKEN
8038a80: 78 02 08 06 mvhi r2,0x806
8038a84: b4 21 08 00 add r1,r1,r1
8038a88: 38 42 80 b0 ori r2,r2,0x80b0
8038a8c: b4 21 08 00 add r1,r1,r1
8038a90: b4 41 08 00 add r1,r2,r1
8038a94: 28 2c 00 00 lw r12,(r1+0)
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
8038a98: fb ff 35 98 calli 80060f8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8038a9c: e3 ff ff e3 bi 8038a28 <rtems_rate_monotonic_period+0x4c>
}
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
8038aa0: 90 00 78 00 rcsr r15,IE
8038aa4: 34 01 ff fe mvi r1,-2
8038aa8: a1 e1 08 00 and r1,r15,r1
8038aac: d0 01 00 00 wcsr IE,r1
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
8038ab0: 29 61 00 38 lw r1,(r11+56)
8038ab4: 44 20 00 19 be r1,r0,8038b18 <rtems_rate_monotonic_period+0x13c>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
8038ab8: 34 02 00 02 mvi r2,2
8038abc: 44 22 00 2b be r1,r2,8038b68 <rtems_rate_monotonic_period+0x18c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8038ac0: 34 0c 00 04 mvi r12,4
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
8038ac4: 5c 2c ff d9 bne r1,r12,8038a28 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
8038ac8: b9 60 08 00 mv r1,r11
8038acc: fb ff ff 49 calli 80387f0 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
8038ad0: d0 0f 00 00 wcsr IE,r15
the_period->state = RATE_MONOTONIC_ACTIVE;
8038ad4: 34 03 00 02 mvi r3,2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8038ad8: 78 01 08 06 mvhi r1,0x806
8038adc: 35 62 00 10 addi r2,r11,16
8038ae0: 59 63 00 38 sw (r11+56),r3
8038ae4: 38 21 f0 f8 ori r1,r1,0xf0f8
the_period->next_length = length;
8038ae8: 59 6e 00 3c sw (r11+60),r14
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
8038aec: 59 6e 00 1c sw (r11+28),r14
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8038af0: fb ff 39 33 calli 8006fbc <_Watchdog_Insert>
8038af4: 78 03 08 06 mvhi r3,0x806
8038af8: 38 63 b0 18 ori r3,r3,0xb018
8038afc: 29 61 00 40 lw r1,(r11+64)
8038b00: 29 62 00 3c lw r2,(r11+60)
8038b04: 28 63 00 34 lw r3,(r3+52)
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
8038b08: 34 0c 00 06 mvi r12,6
8038b0c: d8 60 00 00 call r3
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
8038b10: fb ff 35 7a calli 80060f8 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
8038b14: e3 ff ff c5 bi 8038a28 <rtems_rate_monotonic_period+0x4c>
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
8038b18: d0 0f 00 00 wcsr IE,r15
the_period->next_length = length;
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
8038b1c: b9 60 08 00 mv r1,r11
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
the_period->next_length = length;
8038b20: 59 6e 00 3c sw (r11+60),r14
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
8038b24: fb ff ff 80 calli 8038924 <_Rate_monotonic_Initiate_statistics>
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
8038b28: 78 03 08 03 mvhi r3,0x803
8038b2c: 38 63 8b dc ori r3,r3,0x8bdc
the_period->state = RATE_MONOTONIC_ACTIVE;
8038b30: 34 04 00 02 mvi r4,2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8038b34: 78 01 08 06 mvhi r1,0x806
8038b38: 38 21 f0 f8 ori r1,r1,0xf0f8
8038b3c: 35 62 00 10 addi r2,r11,16
8038b40: 59 64 00 38 sw (r11+56),r4
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8038b44: 59 60 00 18 sw (r11+24),r0
the_watchdog->routine = routine;
8038b48: 59 63 00 2c sw (r11+44),r3
the_watchdog->id = id;
8038b4c: 59 6d 00 30 sw (r11+48),r13
the_watchdog->user_data = user_data;
8038b50: 59 60 00 34 sw (r11+52),r0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
8038b54: 59 6e 00 1c sw (r11+28),r14
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8038b58: fb ff 39 19 calli 8006fbc <_Watchdog_Insert>
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
8038b5c: 34 0c 00 00 mvi r12,0
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
8038b60: fb ff 35 66 calli 80060f8 <_Thread_Enable_dispatch>
8038b64: e3 ff ff b1 bi 8038a28 <rtems_rate_monotonic_period+0x4c>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
8038b68: b9 60 08 00 mv r1,r11
8038b6c: fb ff ff 21 calli 80387f0 <_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;
8038b70: 34 01 00 01 mvi r1,1
8038b74: 59 61 00 38 sw (r11+56),r1
the_period->next_length = length;
8038b78: 59 6e 00 3c sw (r11+60),r14
_ISR_Enable( level );
8038b7c: d0 0f 00 00 wcsr IE,r15
_Thread_Executing->Wait.id = the_period->Object.id;
8038b80: 29 83 00 10 lw r3,(r12+16)
8038b84: 29 64 00 08 lw r4,(r11+8)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
8038b88: 34 02 40 00 mvi r2,16384
8038b8c: b8 60 08 00 mv r1,r3
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
8038b90: 58 64 00 20 sw (r3+32),r4
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
8038b94: fb ff 37 f2 calli 8006b5c <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
8038b98: 90 00 08 00 rcsr r1,IE
8038b9c: 34 02 ff fe mvi r2,-2
8038ba0: a0 22 10 00 and r2,r1,r2
8038ba4: d0 02 00 00 wcsr IE,r2
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
8038ba8: 34 03 00 02 mvi r3,2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
8038bac: 29 62 00 38 lw r2,(r11+56)
the_period->state = RATE_MONOTONIC_ACTIVE;
8038bb0: 59 63 00 38 sw (r11+56),r3
_ISR_Enable( level );
8038bb4: d0 01 00 00 wcsr IE,r1
/*
* 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 )
8038bb8: 34 01 00 03 mvi r1,3
8038bbc: 44 41 00 04 be r2,r1,8038bcc <rtems_rate_monotonic_period+0x1f0><== NEVER TAKEN
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
8038bc0: fb ff 35 4e calli 80060f8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8038bc4: 34 0c 00 00 mvi r12,0
8038bc8: e3 ff ff 98 bi 8038a28 <rtems_rate_monotonic_period+0x4c>
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
8038bcc: 29 81 00 10 lw r1,(r12+16) <== NOT EXECUTED
8038bd0: 34 02 40 00 mvi r2,16384 <== NOT EXECUTED
8038bd4: fb ff 54 55 calli 800dd28 <_Thread_Clear_state> <== NOT EXECUTED
8038bd8: e3 ff ff fa bi 8038bc0 <rtems_rate_monotonic_period+0x1e4> <== NOT EXECUTED
08028e84 <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
8028e84: 37 9c ff 5c addi sp,sp,-164
8028e88: 5b 8b 00 44 sw (sp+68),r11
8028e8c: 5b 8c 00 40 sw (sp+64),r12
8028e90: 5b 8d 00 3c sw (sp+60),r13
8028e94: 5b 8e 00 38 sw (sp+56),r14
8028e98: 5b 8f 00 34 sw (sp+52),r15
8028e9c: 5b 90 00 30 sw (sp+48),r16
8028ea0: 5b 91 00 2c sw (sp+44),r17
8028ea4: 5b 92 00 28 sw (sp+40),r18
8028ea8: 5b 93 00 24 sw (sp+36),r19
8028eac: 5b 94 00 20 sw (sp+32),r20
8028eb0: 5b 95 00 1c sw (sp+28),r21
8028eb4: 5b 96 00 18 sw (sp+24),r22
8028eb8: 5b 97 00 14 sw (sp+20),r23
8028ebc: 5b 98 00 10 sw (sp+16),r24
8028ec0: 5b 99 00 0c sw (sp+12),r25
8028ec4: 5b 9b 00 08 sw (sp+8),fp
8028ec8: 5b 9d 00 04 sw (sp+4),ra
8028ecc: b8 40 68 00 mv r13,r2
8028ed0: b8 20 78 00 mv r15,r1
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
8028ed4: 44 40 00 2f be r2,r0,8028f90 <rtems_rate_monotonic_report_statistics_with_plugin+0x10c><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
8028ed8: 78 02 08 06 mvhi r2,0x806
8028edc: 38 42 4e c8 ori r2,r2,0x4ec8
8028ee0: d9 a0 00 00 call r13
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
8028ee4: 78 02 08 06 mvhi r2,0x806
8028ee8: 38 42 4e e8 ori r2,r2,0x4ee8
8028eec: b9 e0 08 00 mv r1,r15
8028ef0: d9 a0 00 00 call r13
(*print)( context, "--- Wall times are in seconds ---\n" );
8028ef4: 78 02 08 06 mvhi r2,0x806
8028ef8: 38 42 4f 0c ori r2,r2,0x4f0c
8028efc: b9 e0 08 00 mv r1,r15
8028f00: d9 a0 00 00 call r13
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
8028f04: 78 02 08 06 mvhi r2,0x806
8028f08: 38 42 4f 30 ori r2,r2,0x4f30
8028f0c: b9 e0 08 00 mv r1,r15
8028f10: d9 a0 00 00 call r13
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
8028f14: 78 02 08 06 mvhi r2,0x806
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
8028f18: 78 0c 08 06 mvhi r12,0x806
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
8028f1c: b9 e0 08 00 mv r1,r15
8028f20: 38 42 4f 7c ori r2,r2,0x4f7c
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
8028f24: 39 8c fb 30 ori r12,r12,0xfb30
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
8028f28: d9 a0 00 00 call r13
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
8028f2c: 29 81 00 0c lw r1,(r12+12)
8028f30: 29 8b 00 08 lw r11,(r12+8)
8028f34: 55 61 00 17 bgu r11,r1,8028f90 <rtems_rate_monotonic_report_statistics_with_plugin+0x10c><== NEVER TAKEN
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
8028f38: 78 12 08 06 mvhi r18,0x806
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
(*print)( context,
8028f3c: 78 15 08 06 mvhi r21,0x806
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
8028f40: 78 14 08 06 mvhi r20,0x806
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
8028f44: 78 11 08 06 mvhi r17,0x806
8028f48: 37 90 00 48 addi r16,sp,72
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
8028f4c: 37 98 00 80 addi r24,sp,128
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
8028f50: 37 93 00 a0 addi r19,sp,160
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
8028f54: 3a 52 4f c8 ori r18,r18,0x4fc8
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
8028f58: 37 97 00 60 addi r23,sp,96
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
8028f5c: 37 96 00 98 addi r22,sp,152
(*print)( context,
8028f60: 3a b5 4f e0 ori r21,r21,0x4fe0
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
8028f64: 37 9b 00 78 addi fp,sp,120
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
8028f68: 3a 94 50 00 ori r20,r20,0x5000
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
8028f6c: 3a 31 69 68 ori r17,r17,0x6968
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
8028f70: b9 60 08 00 mv r1,r11
8028f74: ba 00 10 00 mv r2,r16
8028f78: f8 00 3c f2 calli 8038340 <rtems_rate_monotonic_get_statistics>
8028f7c: b8 20 70 00 mv r14,r1
if ( status != RTEMS_SUCCESSFUL )
8028f80: 44 20 00 17 be r1,r0,8028fdc <rtems_rate_monotonic_report_statistics_with_plugin+0x158>
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
8028f84: 29 85 00 0c lw r5,(r12+12)
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
8028f88: 35 6b 00 01 addi r11,r11,1
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
8028f8c: 50 ab ff f9 bgeu r5,r11,8028f70 <rtems_rate_monotonic_report_statistics_with_plugin+0xec><== NEVER TAKEN
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
8028f90: 2b 9d 00 04 lw ra,(sp+4)
8028f94: 2b 8b 00 44 lw r11,(sp+68)
8028f98: 2b 8c 00 40 lw r12,(sp+64)
8028f9c: 2b 8d 00 3c lw r13,(sp+60)
8028fa0: 2b 8e 00 38 lw r14,(sp+56)
8028fa4: 2b 8f 00 34 lw r15,(sp+52)
8028fa8: 2b 90 00 30 lw r16,(sp+48)
8028fac: 2b 91 00 2c lw r17,(sp+44)
8028fb0: 2b 92 00 28 lw r18,(sp+40)
8028fb4: 2b 93 00 24 lw r19,(sp+36)
8028fb8: 2b 94 00 20 lw r20,(sp+32)
8028fbc: 2b 95 00 1c lw r21,(sp+28)
8028fc0: 2b 96 00 18 lw r22,(sp+24)
8028fc4: 2b 97 00 14 lw r23,(sp+20)
8028fc8: 2b 98 00 10 lw r24,(sp+16)
8028fcc: 2b 99 00 0c lw r25,(sp+12)
8028fd0: 2b 9b 00 08 lw fp,(sp+8)
8028fd4: 37 9c 00 a4 addi sp,sp,164
8028fd8: c3 a0 00 00 ret
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
8028fdc: bb 00 10 00 mv r2,r24
8028fe0: b9 60 08 00 mv r1,r11
8028fe4: f8 00 3d 69 calli 8038588 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
8028fe8: 2b 81 00 80 lw r1,(sp+128)
8028fec: ba 60 18 00 mv r3,r19
8028ff0: 34 02 00 05 mvi r2,5
8028ff4: fb ff 8f c6 calli 800cf0c <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
8028ff8: 2b 85 00 48 lw r5,(sp+72)
8028ffc: 2b 86 00 4c lw r6,(sp+76)
8029000: ba 40 10 00 mv r2,r18
8029004: b9 60 18 00 mv r3,r11
8029008: b9 e0 08 00 mv r1,r15
802900c: ba 60 20 00 mv r4,r19
8029010: d9 a0 00 00 call r13
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
8029014: 2b 85 00 48 lw r5,(sp+72)
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
8029018: ba c0 18 00 mv r3,r22
802901c: ba e0 08 00 mv r1,r23
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
8029020: ba 20 10 00 mv r2,r17
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
8029024: 5c ae 00 04 bne r5,r14,8029034 <rtems_rate_monotonic_report_statistics_with_plugin+0x1b0>
(*print)( context, "\n" );
8029028: b9 e0 08 00 mv r1,r15
802902c: d9 a0 00 00 call r13
continue;
8029030: e3 ff ff d5 bi 8028f84 <rtems_rate_monotonic_report_statistics_with_plugin+0x100>
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
8029034: b8 a0 10 00 mv r2,r5
8029038: f8 00 04 9f calli 802a2b4 <_Timespec_Divide_by_integer>
(*print)( context,
802903c: 2b 81 00 54 lw r1,(sp+84)
8029040: 34 02 03 e8 mvi r2,1000
8029044: f8 00 d0 70 calli 805d204 <__divsi3>
8029048: b8 20 c8 00 mv r25,r1
802904c: 2b 81 00 5c lw r1,(sp+92)
8029050: 34 02 03 e8 mvi r2,1000
8029054: f8 00 d0 6c calli 805d204 <__divsi3>
8029058: b8 20 70 00 mv r14,r1
802905c: 2b 81 00 9c lw r1,(sp+156)
8029060: 34 02 03 e8 mvi r2,1000
8029064: f8 00 d0 68 calli 805d204 <__divsi3>
8029068: 2b 85 00 58 lw r5,(sp+88)
802906c: 2b 87 00 98 lw r7,(sp+152)
8029070: 2b 83 00 50 lw r3,(sp+80)
8029074: b8 20 40 00 mv r8,r1
8029078: bb 20 20 00 mv r4,r25
802907c: b9 c0 30 00 mv r6,r14
8029080: ba a0 10 00 mv r2,r21
8029084: b9 e0 08 00 mv r1,r15
8029088: d9 a0 00 00 call r13
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
802908c: 2b 82 00 48 lw r2,(sp+72)
8029090: ba c0 18 00 mv r3,r22
8029094: bb 60 08 00 mv r1,fp
8029098: f8 00 04 87 calli 802a2b4 <_Timespec_Divide_by_integer>
(*print)( context,
802909c: 2b 81 00 6c lw r1,(sp+108)
80290a0: 34 02 03 e8 mvi r2,1000
80290a4: f8 00 d0 58 calli 805d204 <__divsi3>
80290a8: b8 20 c8 00 mv r25,r1
80290ac: 2b 81 00 74 lw r1,(sp+116)
80290b0: 34 02 03 e8 mvi r2,1000
80290b4: f8 00 d0 54 calli 805d204 <__divsi3>
80290b8: b8 20 70 00 mv r14,r1
80290bc: 2b 81 00 9c lw r1,(sp+156)
80290c0: 34 02 03 e8 mvi r2,1000
80290c4: f8 00 d0 50 calli 805d204 <__divsi3>
80290c8: 2b 83 00 68 lw r3,(sp+104)
80290cc: 2b 85 00 70 lw r5,(sp+112)
80290d0: 2b 87 00 98 lw r7,(sp+152)
80290d4: b8 20 40 00 mv r8,r1
80290d8: ba 80 10 00 mv r2,r20
80290dc: b9 e0 08 00 mv r1,r15
80290e0: bb 20 20 00 mv r4,r25
80290e4: b9 c0 30 00 mv r6,r14
80290e8: d9 a0 00 00 call r13
80290ec: e3 ff ff a6 bi 8028f84 <rtems_rate_monotonic_report_statistics_with_plugin+0x100>
08029114 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
8029114: 37 9c ff f4 addi sp,sp,-12
8029118: 5b 8b 00 0c sw (sp+12),r11
802911c: 5b 8c 00 08 sw (sp+8),r12
8029120: 5b 9d 00 04 sw (sp+4),ra
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8029124: 78 01 08 06 mvhi r1,0x806
8029128: 38 21 f0 60 ori r1,r1,0xf060
802912c: 28 22 00 00 lw r2,(r1+0)
++level;
8029130: 34 42 00 01 addi r2,r2,1
_Thread_Dispatch_disable_level = level;
8029134: 58 22 00 00 sw (r1+0),r2
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
8029138: 78 0c 08 06 mvhi r12,0x806
802913c: 39 8c fb 30 ori r12,r12,0xfb30
8029140: 29 8b 00 08 lw r11,(r12+8)
8029144: 29 81 00 0c lw r1,(r12+12)
8029148: 55 61 00 06 bgu r11,r1,8029160 <rtems_rate_monotonic_reset_all_statistics+0x4c><== NEVER TAKEN
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
802914c: b9 60 08 00 mv r1,r11
8029150: f8 00 00 0a calli 8029178 <rtems_rate_monotonic_reset_statistics>
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
8029154: 29 81 00 0c lw r1,(r12+12)
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
8029158: 35 6b 00 01 addi r11,r11,1
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
802915c: 50 2b ff fc bgeu r1,r11,802914c <rtems_rate_monotonic_reset_all_statistics+0x38>
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
8029160: fb ff 73 e6 calli 80060f8 <_Thread_Enable_dispatch>
}
8029164: 2b 9d 00 04 lw ra,(sp+4)
8029168: 2b 8b 00 0c lw r11,(sp+12)
802916c: 2b 8c 00 08 lw r12,(sp+8)
8029170: 37 9c 00 0c addi sp,sp,12
8029174: c3 a0 00 00 ret
08004bf0 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
8004bf0: 37 9c ff e8 addi sp,sp,-24
8004bf4: 5b 8b 00 18 sw (sp+24),r11
8004bf8: 5b 8c 00 14 sw (sp+20),r12
8004bfc: 5b 8d 00 10 sw (sp+16),r13
8004c00: 5b 8e 00 0c sw (sp+12),r14
8004c04: 5b 8f 00 08 sw (sp+8),r15
8004c08: 5b 9d 00 04 sw (sp+4),ra
void *ptr = NULL;
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
8004c0c: 28 2e 00 30 lw r14,(r1+48)
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
8004c10: b8 40 58 00 mv r11,r2
8004c14: b8 20 68 00 mv r13,r1
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
8004c18: b8 40 08 00 mv r1,r2
8004c1c: b9 c0 10 00 mv r2,r14
8004c20: f8 00 3d c1 calli 8014324 <__umodsi3>
if (excess > 0) {
8004c24: b9 60 60 00 mv r12,r11
8004c28: 34 03 00 01 mvi r3,1
8004c2c: 44 20 00 04 be r1,r0,8004c3c <rtems_rbheap_allocate+0x4c> <== ALWAYS TAKEN
value += alignment - excess;
8004c30: b5 6e 60 00 add r12,r11,r14 <== NOT EXECUTED
8004c34: c9 81 60 00 sub r12,r12,r1 <== NOT EXECUTED
8004c38: f1 8b 18 00 cmpgeu r3,r12,r11 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
8004c3c: 7d 6b 00 00 cmpnei r11,r11,0
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
8004c40: 34 02 00 00 mvi r2,0
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
8004c44: a0 6b 18 00 and r3,r3,r11
8004c48: 5c 60 00 0a bne r3,r0,8004c70 <rtems_rbheap_allocate+0x80>
}
}
}
return ptr;
}
8004c4c: b8 40 08 00 mv r1,r2
8004c50: 2b 9d 00 04 lw ra,(sp+4)
8004c54: 2b 8b 00 18 lw r11,(sp+24)
8004c58: 2b 8c 00 14 lw r12,(sp+20)
8004c5c: 2b 8d 00 10 lw r13,(sp+16)
8004c60: 2b 8e 00 0c lw r14,(sp+12)
8004c64: 2b 8f 00 08 lw r15,(sp+8)
8004c68: 37 9c 00 18 addi sp,sp,24
8004c6c: c3 a0 00 00 ret
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
if (chunk != NULL) {
rtems_rbheap_add_to_spare_descriptor_chain(control, chunk);
}
}
8004c70: 29 ab 00 00 lw r11,(r13+0)
rtems_chain_control *free_chain,
size_t size
)
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
8004c74: 35 a1 00 04 addi r1,r13,4
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
8004c78: 45 61 ff f5 be r11,r1,8004c4c <rtems_rbheap_allocate+0x5c>
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
8004c7c: 29 6e 00 1c lw r14,(r11+28)
8004c80: 55 8e 00 1f bgu r12,r14,8004cfc <rtems_rbheap_allocate+0x10c>
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
8004c84: 45 60 00 20 be r11,r0,8004d04 <rtems_rbheap_allocate+0x114><== NEVER TAKEN
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
8004c88: 51 8e 00 15 bgeu r12,r14,8004cdc <rtems_rbheap_allocate+0xec>
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
if (chunk != NULL) {
rtems_rbheap_add_to_spare_descriptor_chain(control, chunk);
}
}
8004c8c: 29 af 00 0c lw r15,(r13+12)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8004c90: 35 a1 00 10 addi r1,r13,16
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
8004c94: 45 e1 00 1e be r15,r1,8004d0c <rtems_rbheap_allocate+0x11c><== NEVER TAKEN
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
8004c98: 29 e1 00 00 lw r1,(r15+0)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
8004c9c: 35 a2 00 0c addi r2,r13,12
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
8004ca0: 59 a1 00 0c sw (r13+12),r1
new_first->previous = head;
8004ca4: 58 22 00 04 sw (r1+4),r2
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
8004ca8: 29 61 00 18 lw r1,(r11+24)
if (free_size > aligned_size) {
rtems_rbheap_chunk *new_chunk = get_chunk(control);
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
8004cac: c9 cc 70 00 sub r14,r14,r12
free_chunk->size = new_free_size;
8004cb0: 59 6e 00 1c sw (r11+28),r14
new_chunk->begin = free_chunk->begin + new_free_size;
8004cb4: b5 c1 70 00 add r14,r14,r1
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
8004cb8: 35 e2 00 08 addi r2,r15,8
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
8004cbc: 59 ee 00 18 sw (r15+24),r14
new_chunk->size = aligned_size;
8004cc0: 59 ec 00 1c sw (r15+28),r12
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
8004cc4: 59 e0 00 04 sw (r15+4),r0
8004cc8: 59 e0 00 00 sw (r15+0),r0
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
8004ccc: 35 a1 00 18 addi r1,r13,24
8004cd0: f8 00 07 86 calli 8006ae8 <_RBTree_Insert_unprotected>
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
8004cd4: 29 e2 00 18 lw r2,(r15+24)
8004cd8: e3 ff ff dd bi 8004c4c <rtems_rbheap_allocate+0x5c>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
8004cdc: 29 63 00 00 lw r3,(r11+0)
previous = the_node->previous;
8004ce0: 29 61 00 04 lw r1,(r11+4)
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
8004ce4: 29 62 00 18 lw r2,(r11+24)
next->previous = previous;
8004ce8: 58 61 00 04 sw (r3+4),r1
previous->next = next;
8004cec: 58 23 00 00 sw (r1+0),r3
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
8004cf0: 59 60 00 04 sw (r11+4),r0
8004cf4: 59 60 00 00 sw (r11+0),r0
8004cf8: e3 ff ff d5 bi 8004c4c <rtems_rbheap_allocate+0x5c>
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
if (chunk != NULL) {
rtems_rbheap_add_to_spare_descriptor_chain(control, chunk);
}
}
8004cfc: 29 6b 00 00 lw r11,(r11+0)
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
8004d00: 5c 2b ff df bne r1,r11,8004c7c <rtems_rbheap_allocate+0x8c><== NEVER TAKEN
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
8004d04: 34 02 00 00 mvi r2,0
8004d08: e3 ff ff d1 bi 8004c4c <rtems_rbheap_allocate+0x5c>
{
rtems_chain_control *chain = &control->spare_descriptor_chain;
rtems_chain_node *chunk = rtems_chain_get_unprotected(chain);
if (chunk == NULL) {
(*control->extend_descriptors)(control);
8004d0c: 29 a2 00 34 lw r2,(r13+52) <== NOT EXECUTED
8004d10: b9 a0 08 00 mv r1,r13 <== NOT EXECUTED
8004d14: d8 40 00 00 call r2 <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
if (chunk != NULL) {
rtems_rbheap_add_to_spare_descriptor_chain(control, chunk);
}
}
8004d18: 29 a1 00 0c lw r1,(r13+12) <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
8004d1c: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
8004d20: 45 e1 ff cb be r15,r1,8004c4c <rtems_rbheap_allocate+0x5c> <== NOT EXECUTED
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
8004d24: 28 22 00 00 lw r2,(r1+0) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
8004d28: 35 a3 00 0c addi r3,r13,12 <== NOT EXECUTED
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
8004d2c: b8 20 78 00 mv r15,r1 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
8004d30: 59 a2 00 0c sw (r13+12),r2 <== NOT EXECUTED
new_first->previous = head;
8004d34: 58 43 00 04 sw (r2+4),r3 <== NOT EXECUTED
8004d38: e3 ff ff dc bi 8004ca8 <rtems_rbheap_allocate+0xb8> <== NOT EXECUTED
08004e74 <rtems_rbheap_extend_descriptors_with_malloc>:
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
8004e74: 37 9c ff f8 addi sp,sp,-8 <== NOT EXECUTED
8004e78: 5b 8b 00 08 sw (sp+8),r11 <== NOT EXECUTED
8004e7c: 5b 9d 00 04 sw (sp+4),ra <== NOT EXECUTED
8004e80: b8 20 58 00 mv r11,r1 <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
8004e84: 34 01 00 20 mvi r1,32 <== NOT EXECUTED
8004e88: fb ff f4 9c calli 80020f8 <malloc> <== NOT EXECUTED
if (chunk != NULL) {
8004e8c: 44 20 00 07 be r1,r0,8004ea8 <rtems_rbheap_extend_descriptors_with_malloc+0x34><== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
8004e90: 29 62 00 0c lw r2,(r11+12) <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
8004e94: 35 63 00 0c addi r3,r11,12 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
8004e98: 58 23 00 04 sw (r1+4),r3 <== NOT EXECUTED
before_node = after_node->next;
after_node->next = the_node;
8004e9c: 59 61 00 0c sw (r11+12),r1 <== NOT EXECUTED
the_node->next = before_node;
8004ea0: 58 22 00 00 sw (r1+0),r2 <== NOT EXECUTED
before_node->previous = the_node;
8004ea4: 58 41 00 04 sw (r2+4),r1 <== NOT EXECUTED
rtems_rbheap_add_to_spare_descriptor_chain(control, chunk);
}
}
8004ea8: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8004eac: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
8004eb0: 37 9c 00 08 addi sp,sp,8 <== NOT EXECUTED
8004eb4: c3 a0 00 00 ret <== NOT EXECUTED
08004d3c <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
8004d3c: 37 9c ff cc addi sp,sp,-52
8004d40: 5b 8b 00 14 sw (sp+20),r11
8004d44: 5b 8c 00 10 sw (sp+16),r12
8004d48: 5b 8d 00 0c sw (sp+12),r13
8004d4c: 5b 8e 00 08 sw (sp+8),r14
8004d50: 5b 9d 00 04 sw (sp+4),ra
8004d54: b8 20 60 00 mv r12,r1
rtems_status_code sc = RTEMS_SUCCESSFUL;
8004d58: 34 01 00 00 mvi r1,0
if (ptr != NULL) {
8004d5c: 44 40 00 22 be r2,r0,8004de4 <rtems_rbheap_free+0xa8>
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
8004d60: 29 8b 00 1c lw r11,(r12+28)
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
8004d64: 5b 80 00 18 sw (sp+24),r0
8004d68: 5b 80 00 1c sw (sp+28),r0
8004d6c: 5b 80 00 20 sw (sp+32),r0
8004d70: 5b 80 00 24 sw (sp+36),r0
8004d74: 5b 80 00 28 sw (sp+40),r0
8004d78: 5b 80 00 2c sw (sp+44),r0
8004d7c: 5b 80 00 34 sw (sp+52),r0
8004d80: 5b 82 00 30 sw (sp+48),r2
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
}
} else {
sc = RTEMS_INVALID_ID;
8004d84: 34 01 00 04 mvi r1,4
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
8004d88: 45 60 00 17 be r11,r0,8004de4 <rtems_rbheap_free+0xa8> <== NEVER TAKEN
8004d8c: 34 0d 00 00 mvi r13,0
8004d90: 37 8e 00 20 addi r14,sp,32
compare_result = the_rbtree->compare_function(the_node, iter_node);
8004d94: 29 83 00 28 lw r3,(r12+40)
8004d98: b9 60 10 00 mv r2,r11
8004d9c: b9 c0 08 00 mv r1,r14
8004da0: d8 60 00 00 call r3
found = iter_node;
if ( the_rbtree->is_unique )
break;
}
RBTree_Direction dir =
8004da4: 68 22 00 00 cmpgi r2,r1,0
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
8004da8: 5c 20 00 04 bne r1,r0,8004db8 <rtems_rbheap_free+0x7c>
found = iter_node;
if ( the_rbtree->is_unique )
8004dac: 41 83 00 2c lbu r3,(r12+44)
8004db0: b9 60 68 00 mv r13,r11
8004db4: 5c 61 00 13 bne r3,r1,8004e00 <rtems_rbheap_free+0xc4> <== ALWAYS TAKEN
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
8004db8: b4 42 10 00 add r2,r2,r2
8004dbc: b4 42 10 00 add r2,r2,r2
8004dc0: b5 62 58 00 add r11,r11,r2
8004dc4: 29 6b 00 04 lw r11,(r11+4)
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
8004dc8: 5d 60 ff f3 bne r11,r0,8004d94 <rtems_rbheap_free+0x58>
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
8004dcc: 35 ab ff f8 addi r11,r13,-8
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
}
} else {
sc = RTEMS_INVALID_ID;
8004dd0: 34 01 00 04 mvi r1,4
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
8004dd4: 45 a0 00 04 be r13,r0,8004de4 <rtems_rbheap_free+0xa8>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
8004dd8: 29 a2 ff f8 lw r2,(r13+-8)
check_and_merge(free_chain, chunk_tree, chunk, succ);
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
8004ddc: 34 01 00 0e mvi r1,14
8004de0: 44 40 00 0a be r2,r0,8004e08 <rtems_rbheap_free+0xcc>
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
8004de4: 2b 9d 00 04 lw ra,(sp+4)
8004de8: 2b 8b 00 14 lw r11,(sp+20)
8004dec: 2b 8c 00 10 lw r12,(sp+16)
8004df0: 2b 8d 00 0c lw r13,(sp+12)
8004df4: 2b 8e 00 08 lw r14,(sp+8)
8004df8: 37 9c 00 34 addi sp,sp,52
8004dfc: c3 a0 00 00 ret
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( _RBTree_Is_equal( compare_result ) ) {
found = iter_node;
if ( the_rbtree->is_unique )
8004e00: b9 60 68 00 mv r13,r11
8004e04: e3 ff ff f2 bi 8004dcc <rtems_rbheap_free+0x90>
8004e08: 29 63 00 04 lw r3,(r11+4)
8004e0c: 5c 62 ff f6 bne r3,r2,8004de4 <rtems_rbheap_free+0xa8> <== NEVER TAKEN
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
8004e10: b9 a0 08 00 mv r1,r13
8004e14: f8 00 08 21 calli 8006e98 <_RBTree_Next_unprotected>
8004e18: b8 20 70 00 mv r14,r1
8004e1c: 34 02 00 01 mvi r2,1
8004e20: b9 a0 08 00 mv r1,r13
8004e24: f8 00 08 1d calli 8006e98 <_RBTree_Next_unprotected>
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
8004e28: 35 8d 00 18 addi r13,r12,24
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
8004e2c: 34 24 ff f8 addi r4,r1,-8
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
8004e30: b9 a0 10 00 mv r2,r13
8004e34: b9 80 08 00 mv r1,r12
8004e38: b9 60 18 00 mv r3,r11
8004e3c: fb ff fe ee calli 80049f4 <check_and_merge>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
8004e40: 29 82 00 00 lw r2,(r12+0)
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
8004e44: 59 6c 00 04 sw (r11+4),r12
before_node = after_node->next;
after_node->next = the_node;
8004e48: 59 8b 00 00 sw (r12+0),r11
the_node->next = before_node;
8004e4c: 59 62 00 00 sw (r11+0),r2
before_node->previous = the_node;
8004e50: 58 4b 00 04 sw (r2+4),r11
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
8004e54: b9 80 08 00 mv r1,r12
8004e58: b9 a0 10 00 mv r2,r13
8004e5c: b9 60 18 00 mv r3,r11
8004e60: 35 c4 ff f8 addi r4,r14,-8
8004e64: fb ff fe e4 calli 80049f4 <check_and_merge>
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
8004e68: 34 01 00 00 mvi r1,0
8004e6c: e3 ff ff de bi 8004de4 <rtems_rbheap_free+0xa8>
080143e4 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
80143e4: 37 9c ff f4 addi sp,sp,-12
80143e8: 5b 8b 00 08 sw (sp+8),r11
80143ec: 5b 9d 00 04 sw (sp+4),ra
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
80143f0: 34 03 00 0a mvi r3,10
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
80143f4: b8 40 58 00 mv r11,r2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
80143f8: 5c 40 00 06 bne r2,r0,8014410 <rtems_signal_send+0x2c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80143fc: b8 60 08 00 mv r1,r3
8014400: 2b 9d 00 04 lw ra,(sp+4)
8014404: 2b 8b 00 08 lw r11,(sp+8)
8014408: 37 9c 00 0c addi sp,sp,12
801440c: c3 a0 00 00 ret
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
8014410: 37 82 00 0c addi r2,sp,12
8014414: f8 00 16 b9 calli 8019ef8 <_Thread_Get>
switch ( location ) {
8014418: 2b 83 00 0c lw r3,(sp+12)
801441c: 44 60 00 07 be r3,r0,8014438 <rtems_signal_send+0x54>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8014420: 34 03 00 04 mvi r3,4
}
8014424: b8 60 08 00 mv r1,r3
8014428: 2b 9d 00 04 lw ra,(sp+4)
801442c: 2b 8b 00 08 lw r11,(sp+8)
8014430: 37 9c 00 0c addi sp,sp,12
8014434: c3 a0 00 00 ret
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
8014438: 28 22 01 18 lw r2,(r1+280)
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
801443c: 28 44 00 0c lw r4,(r2+12)
8014440: 44 83 00 23 be r4,r3,80144cc <rtems_signal_send+0xe8>
if ( asr->is_enabled ) {
8014444: 40 43 00 08 lbu r3,(r2+8)
8014448: 44 60 00 12 be r3,r0,8014490 <rtems_signal_send+0xac> <== NEVER TAKEN
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
801444c: 90 00 18 00 rcsr r3,IE
8014450: 34 04 ff fe mvi r4,-2
8014454: a0 64 20 00 and r4,r3,r4
8014458: d0 04 00 00 wcsr IE,r4
*signal_set |= signals;
801445c: 28 44 00 14 lw r4,(r2+20)
8014460: b8 8b 58 00 or r11,r4,r11
8014464: 58 4b 00 14 sw (r2+20),r11
_ISR_Enable( _level );
8014468: d0 03 00 00 wcsr IE,r3
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
801446c: 78 02 08 04 mvhi r2,0x804
8014470: 38 42 01 e0 ori r2,r2,0x1e0
8014474: 28 43 00 08 lw r3,(r2+8)
8014478: 44 60 00 0e be r3,r0,80144b0 <rtems_signal_send+0xcc>
801447c: 28 43 00 10 lw r3,(r2+16)
8014480: 5c 23 00 0c bne r1,r3,80144b0 <rtems_signal_send+0xcc> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
8014484: 34 01 00 01 mvi r1,1
8014488: 30 41 00 0c sb (r2+12),r1
801448c: e0 00 00 09 bi 80144b0 <rtems_signal_send+0xcc>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
8014490: 90 00 08 00 rcsr r1,IE
8014494: 34 03 ff fe mvi r3,-2
8014498: a0 23 18 00 and r3,r1,r3
801449c: d0 03 00 00 wcsr IE,r3
*signal_set |= signals;
80144a0: 28 43 00 18 lw r3,(r2+24)
80144a4: b8 6b 58 00 or r11,r3,r11
80144a8: 58 4b 00 18 sw (r2+24),r11
_ISR_Enable( _level );
80144ac: d0 01 00 00 wcsr IE,r1
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
80144b0: f8 00 16 86 calli 8019ec8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80144b4: 34 03 00 00 mvi r3,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80144b8: b8 60 08 00 mv r1,r3
80144bc: 2b 9d 00 04 lw ra,(sp+4)
80144c0: 2b 8b 00 08 lw r11,(sp+8)
80144c4: 37 9c 00 0c addi sp,sp,12
80144c8: c3 a0 00 00 ret
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
80144cc: f8 00 16 7f calli 8019ec8 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
80144d0: 34 03 00 0b mvi r3,11
80144d4: e3 ff ff ca bi 80143fc <rtems_signal_send+0x18>
0800f4cc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
800f4cc: 37 9c ff dc addi sp,sp,-36
800f4d0: 5b 8b 00 24 sw (sp+36),r11
800f4d4: 5b 8c 00 20 sw (sp+32),r12
800f4d8: 5b 8d 00 1c sw (sp+28),r13
800f4dc: 5b 8e 00 18 sw (sp+24),r14
800f4e0: 5b 8f 00 14 sw (sp+20),r15
800f4e4: 5b 90 00 10 sw (sp+16),r16
800f4e8: 5b 91 00 0c sw (sp+12),r17
800f4ec: 5b 92 00 08 sw (sp+8),r18
800f4f0: 5b 9d 00 04 sw (sp+4),ra
800f4f4: b8 40 70 00 mv r14,r2
800f4f8: b8 60 88 00 mv r17,r3
800f4fc: b8 20 80 00 mv r16,r1
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
800f500: 34 02 00 09 mvi r2,9
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
800f504: 44 60 00 46 be r3,r0,800f61c <rtems_task_mode+0x150>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
800f508: 78 0f 08 01 mvhi r15,0x801
800f50c: 39 ef ae 00 ori r15,r15,0xae00
800f510: 29 eb 00 10 lw r11,(r15+16)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
800f514: 41 6d 00 70 lbu r13,(r11+112)
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
800f518: 29 61 00 78 lw r1,(r11+120)
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
800f51c: 29 6c 01 18 lw r12,(r11+280)
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
800f520: 65 ad 00 00 cmpei r13,r13,0
800f524: b5 ad 20 00 add r4,r13,r13
800f528: b4 84 20 00 add r4,r4,r4
800f52c: b4 84 20 00 add r4,r4,r4
800f530: b4 84 20 00 add r4,r4,r4
800f534: b4 84 20 00 add r4,r4,r4
800f538: b4 84 20 00 add r4,r4,r4
800f53c: b4 84 20 00 add r4,r4,r4
800f540: b4 84 68 00 add r13,r4,r4
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
800f544: 5c 20 00 42 bne r1,r0,800f64c <rtems_task_mode+0x180>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
800f548: 41 92 00 08 lbu r18,(r12+8)
old_mode |= _ISR_Get_level();
800f54c: fb ff e7 5d calli 80092c0 <_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;
800f550: 66 52 00 00 cmpei r18,r18,0
800f554: c8 12 90 00 sub r18,r0,r18
800f558: 22 52 04 00 andi r18,r18,0x400
800f55c: ba 41 08 00 or r1,r18,r1
old_mode |= _ISR_Get_level();
800f560: b8 2d 68 00 or r13,r1,r13
*previous_mode_set = old_mode;
800f564: 5a 2d 00 00 sw (r17+0),r13
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
800f568: 21 c1 01 00 andi r1,r14,0x100
800f56c: 44 20 00 04 be r1,r0,800f57c <rtems_task_mode+0xb0>
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;
800f570: 22 01 01 00 andi r1,r16,0x100
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
800f574: 64 21 00 00 cmpei r1,r1,0
800f578: 31 61 00 70 sb (r11+112),r1
if ( mask & RTEMS_TIMESLICE_MASK ) {
800f57c: 21 c1 02 00 andi r1,r14,0x200
800f580: 44 20 00 09 be r1,r0,800f5a4 <rtems_task_mode+0xd8>
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_timeslice (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_TIMESLICE_MASK) == RTEMS_TIMESLICE;
800f584: 22 01 02 00 andi r1,r16,0x200
if ( _Modes_Is_timeslice(mode_set) ) {
800f588: 44 20 00 3e be r1,r0,800f680 <rtems_task_mode+0x1b4>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
800f58c: 78 01 08 01 mvhi r1,0x801
800f590: 38 21 a9 10 ori r1,r1,0xa910
800f594: 28 22 00 00 lw r2,(r1+0)
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;
800f598: 34 01 00 01 mvi r1,1
800f59c: 59 61 00 78 sw (r11+120),r1
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
800f5a0: 59 62 00 74 sw (r11+116),r2
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
800f5a4: 21 c1 00 01 andi r1,r14,0x1
800f5a8: 44 20 00 04 be r1,r0,800f5b8 <rtems_task_mode+0xec>
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
800f5ac: 22 01 00 01 andi r1,r16,0x1
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
800f5b0: 64 21 00 00 cmpei r1,r1,0
800f5b4: d0 01 00 00 wcsr IE,r1
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
800f5b8: 21 ce 04 00 andi r14,r14,0x400
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
800f5bc: 34 04 00 00 mvi r4,0
if ( mask & RTEMS_ASR_MASK ) {
800f5c0: 45 c0 00 11 be r14,r0,800f604 <rtems_task_mode+0x138>
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_asr_disabled (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_ASR_MASK) == RTEMS_NO_ASR;
800f5c4: 22 10 04 00 andi r16,r16,0x400
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
800f5c8: 41 81 00 08 lbu r1,(r12+8)
#include <rtems/score/tod.h>
#include <rtems/score/wkspace.h>
#include <rtems/score/apiext.h>
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_mode(
800f5cc: 66 10 00 00 cmpei r16,r16,0
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 ) {
800f5d0: 44 30 00 0d be r1,r16,800f604 <rtems_task_mode+0x138>
asr->is_enabled = is_asr_enabled;
800f5d4: 31 90 00 08 sb (r12+8),r16
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
800f5d8: 90 00 08 00 rcsr r1,IE
800f5dc: 34 02 ff fe mvi r2,-2
800f5e0: a0 22 10 00 and r2,r1,r2
800f5e4: d0 02 00 00 wcsr IE,r2
_signals = information->signals_pending;
800f5e8: 29 83 00 18 lw r3,(r12+24)
information->signals_pending = information->signals_posted;
800f5ec: 29 82 00 14 lw r2,(r12+20)
information->signals_posted = _signals;
800f5f0: 59 83 00 14 sw (r12+20),r3
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
800f5f4: 59 82 00 18 sw (r12+24),r2
information->signals_posted = _signals;
_ISR_Enable( _level );
800f5f8: d0 01 00 00 wcsr IE,r1
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
800f5fc: 29 84 00 14 lw r4,(r12+20)
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
800f600: 7c 84 00 00 cmpnei r4,r4,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
800f604: 78 01 08 01 mvhi r1,0x801
800f608: 38 21 ad f8 ori r1,r1,0xadf8
800f60c: 28 23 00 00 lw r3,(r1+0)
800f610: 34 01 00 03 mvi r1,3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
800f614: 34 02 00 00 mvi r2,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
800f618: 44 61 00 0f be r3,r1,800f654 <rtems_task_mode+0x188>
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
800f61c: b8 40 08 00 mv r1,r2
800f620: 2b 9d 00 04 lw ra,(sp+4)
800f624: 2b 8b 00 24 lw r11,(sp+36)
800f628: 2b 8c 00 20 lw r12,(sp+32)
800f62c: 2b 8d 00 1c lw r13,(sp+28)
800f630: 2b 8e 00 18 lw r14,(sp+24)
800f634: 2b 8f 00 14 lw r15,(sp+20)
800f638: 2b 90 00 10 lw r16,(sp+16)
800f63c: 2b 91 00 0c lw r17,(sp+12)
800f640: 2b 92 00 08 lw r18,(sp+8)
800f644: 37 9c 00 24 addi sp,sp,36
800f648: c3 a0 00 00 ret
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
800f64c: 39 ad 02 00 ori r13,r13,0x200
800f650: e3 ff ff be bi 800f548 <rtems_task_mode+0x7c>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
800f654: 29 e1 00 10 lw r1,(r15+16)
if ( are_signals_pending ||
800f658: 5c 80 00 05 bne r4,r0,800f66c <rtems_task_mode+0x1a0>
800f65c: 29 e3 00 14 lw r3,(r15+20)
800f660: 44 23 ff ef be r1,r3,800f61c <rtems_task_mode+0x150>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
800f664: 40 21 00 70 lbu r1,(r1+112)
800f668: 44 20 ff ed be r1,r0,800f61c <rtems_task_mode+0x150> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
800f66c: 34 01 00 01 mvi r1,1
800f670: 31 e1 00 0c sb (r15+12),r1
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
800f674: f8 00 03 5d calli 80103e8 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
800f678: 34 02 00 00 mvi r2,0
800f67c: e3 ff ff e8 bi 800f61c <rtems_task_mode+0x150>
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
800f680: 59 60 00 78 sw (r11+120),r0
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
800f684: 21 c1 00 01 andi r1,r14,0x1
800f688: 44 20 ff cc be r1,r0,800f5b8 <rtems_task_mode+0xec>
800f68c: e3 ff ff c8 bi 800f5ac <rtems_task_mode+0xe0>
08009798 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
8009798: 37 9c ff f0 addi sp,sp,-16
800979c: 5b 8b 00 0c sw (sp+12),r11
80097a0: 5b 8c 00 08 sw (sp+8),r12
80097a4: 5b 9d 00 04 sw (sp+4),ra
80097a8: b8 40 58 00 mv r11,r2
80097ac: b8 60 60 00 mv r12,r3
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
80097b0: 44 40 00 06 be r2,r0,80097c8 <rtems_task_set_priority+0x30>
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 ) );
80097b4: 78 02 08 01 mvhi r2,0x801
80097b8: 38 42 b0 d8 ori r2,r2,0xb0d8
80097bc: 40 42 00 00 lbu r2,(r2+0)
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
80097c0: 34 04 00 13 mvi r4,19
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
80097c4: 55 62 00 08 bgu r11,r2,80097e4 <rtems_task_set_priority+0x4c>
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
80097c8: 34 04 00 09 mvi r4,9
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
80097cc: 45 80 00 06 be r12,r0,80097e4 <rtems_task_set_priority+0x4c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
80097d0: 37 82 00 10 addi r2,sp,16
80097d4: f8 00 0b 79 calli 800c5b8 <_Thread_Get>
switch ( location ) {
80097d8: 2b 82 00 10 lw r2,(sp+16)
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
80097dc: 34 04 00 04 mvi r4,4
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
80097e0: 44 40 00 07 be r2,r0,80097fc <rtems_task_set_priority+0x64>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80097e4: b8 80 08 00 mv r1,r4
80097e8: 2b 9d 00 04 lw ra,(sp+4)
80097ec: 2b 8b 00 0c lw r11,(sp+12)
80097f0: 2b 8c 00 08 lw r12,(sp+8)
80097f4: 37 9c 00 10 addi sp,sp,16
80097f8: c3 a0 00 00 ret
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
80097fc: 28 23 00 14 lw r3,(r1+20)
8009800: 59 83 00 00 sw (r12+0),r3
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
8009804: 45 62 00 09 be r11,r2,8009828 <rtems_task_set_priority+0x90>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
8009808: 28 22 00 1c lw r2,(r1+28)
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
the_thread->real_priority = new_priority;
800980c: 58 2b 00 18 sw (r1+24),r11
if ( the_thread->resource_count == 0 ||
8009810: 44 40 00 03 be r2,r0,800981c <rtems_task_set_priority+0x84>
8009814: 28 22 00 14 lw r2,(r1+20)
8009818: 51 62 00 04 bgeu r11,r2,8009828 <rtems_task_set_priority+0x90><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
800981c: b9 60 10 00 mv r2,r11
8009820: 34 03 00 00 mvi r3,0
8009824: f8 00 09 e8 calli 800bfc4 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
8009828: f8 00 0b 58 calli 800c588 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
800982c: 34 04 00 00 mvi r4,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8009830: b8 80 08 00 mv r1,r4
8009834: 2b 9d 00 04 lw ra,(sp+4)
8009838: 2b 8b 00 0c lw r11,(sp+12)
800983c: 2b 8c 00 08 lw r12,(sp+8)
8009840: 37 9c 00 10 addi sp,sp,16
8009844: c3 a0 00 00 ret
08004fa4 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
8004fa4: 37 9c ff ec addi sp,sp,-20
8004fa8: 5b 8b 00 10 sw (sp+16),r11
8004fac: 5b 8c 00 0c sw (sp+12),r12
8004fb0: 5b 8d 00 08 sw (sp+8),r13
8004fb4: 5b 9d 00 04 sw (sp+4),ra
8004fb8: b8 40 58 00 mv r11,r2
8004fbc: b8 60 68 00 mv r13,r3
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
8004fc0: 34 02 00 09 mvi r2,9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
8004fc4: 45 60 00 07 be r11,r0,8004fe0 <rtems_task_variable_add+0x3c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
8004fc8: 37 82 00 14 addi r2,sp,20
8004fcc: f8 00 09 c7 calli 80076e8 <_Thread_Get>
8004fd0: b8 20 60 00 mv r12,r1
switch (location) {
8004fd4: 2b 81 00 14 lw r1,(sp+20)
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8004fd8: 34 02 00 04 mvi r2,4
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
8004fdc: 44 20 00 08 be r1,r0,8004ffc <rtems_task_variable_add+0x58>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8004fe0: b8 40 08 00 mv r1,r2
8004fe4: 2b 9d 00 04 lw ra,(sp+4)
8004fe8: 2b 8b 00 10 lw r11,(sp+16)
8004fec: 2b 8c 00 0c lw r12,(sp+12)
8004ff0: 2b 8d 00 08 lw r13,(sp+8)
8004ff4: 37 9c 00 14 addi sp,sp,20
8004ff8: c3 a0 00 00 ret
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
8004ffc: 29 84 01 24 lw r4,(r12+292)
while (tvp) {
8005000: 44 81 00 08 be r4,r1,8005020 <rtems_task_variable_add+0x7c>
if (tvp->ptr == ptr) {
8005004: 28 81 00 04 lw r1,(r4+4)
8005008: 5c 2b 00 04 bne r1,r11,8005018 <rtems_task_variable_add+0x74>
800500c: e0 00 00 18 bi 800506c <rtems_task_variable_add+0xc8>
8005010: 28 82 00 04 lw r2,(r4+4)
8005014: 44 4b 00 16 be r2,r11,800506c <rtems_task_variable_add+0xc8><== NEVER TAKEN
tvp->dtor = dtor;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
8005018: 28 84 00 00 lw r4,(r4+0)
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
800501c: 5c 80 ff fd bne r4,r0,8005010 <rtems_task_variable_add+0x6c>
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
8005020: 34 01 00 14 mvi r1,20
8005024: f8 00 0e 87 calli 8008a40 <_Workspace_Allocate>
if (new == NULL) {
8005028: 44 20 00 1b be r1,r0,8005094 <rtems_task_variable_add+0xf0>
}
new->gval = *ptr;
new->ptr = ptr;
new->dtor = dtor;
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
800502c: 29 82 01 24 lw r2,(r12+292)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
8005030: 29 63 00 00 lw r3,(r11+0)
new->ptr = ptr;
8005034: 58 2b 00 04 sw (r1+4),r11
new->dtor = dtor;
8005038: 58 2d 00 10 sw (r1+16),r13
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
800503c: 58 23 00 08 sw (r1+8),r3
new->ptr = ptr;
new->dtor = dtor;
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
8005040: 58 22 00 00 sw (r1+0),r2
the_thread->task_variables = new;
8005044: 59 81 01 24 sw (r12+292),r1
_Thread_Enable_dispatch();
8005048: f8 00 09 9c calli 80076b8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
800504c: 34 02 00 00 mvi r2,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8005050: b8 40 08 00 mv r1,r2
8005054: 2b 9d 00 04 lw ra,(sp+4)
8005058: 2b 8b 00 10 lw r11,(sp+16)
800505c: 2b 8c 00 0c lw r12,(sp+12)
8005060: 2b 8d 00 08 lw r13,(sp+8)
8005064: 37 9c 00 14 addi sp,sp,20
8005068: c3 a0 00 00 ret
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
tvp->dtor = dtor;
800506c: 58 8d 00 10 sw (r4+16),r13
_Thread_Enable_dispatch();
8005070: f8 00 09 92 calli 80076b8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8005074: 34 02 00 00 mvi r2,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8005078: b8 40 08 00 mv r1,r2
800507c: 2b 9d 00 04 lw ra,(sp+4)
8005080: 2b 8b 00 10 lw r11,(sp+16)
8005084: 2b 8c 00 0c lw r12,(sp+12)
8005088: 2b 8d 00 08 lw r13,(sp+8)
800508c: 37 9c 00 14 addi sp,sp,20
8005090: c3 a0 00 00 ret
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
8005094: f8 00 09 89 calli 80076b8 <_Thread_Enable_dispatch>
return RTEMS_NO_MEMORY;
8005098: 34 02 00 1a mvi r2,26
800509c: e3 ff ff d1 bi 8004fe0 <rtems_task_variable_add+0x3c>
080050a0 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
80050a0: 37 9c ff f4 addi sp,sp,-12
80050a4: 5b 8b 00 08 sw (sp+8),r11
80050a8: 5b 9d 00 04 sw (sp+4),ra
80050ac: b8 40 58 00 mv r11,r2
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
80050b0: 34 02 00 09 mvi r2,9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
80050b4: 45 60 00 06 be r11,r0,80050cc <rtems_task_variable_delete+0x2c>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
80050b8: 37 82 00 0c addi r2,sp,12
80050bc: f8 00 09 8b calli 80076e8 <_Thread_Get>
switch (location) {
80050c0: 2b 82 00 0c lw r2,(sp+12)
80050c4: 44 40 00 07 be r2,r0,80050e0 <rtems_task_variable_delete+0x40>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
80050c8: 34 02 00 04 mvi r2,4
}
80050cc: b8 40 08 00 mv r1,r2
80050d0: 2b 9d 00 04 lw ra,(sp+4)
80050d4: 2b 8b 00 08 lw r11,(sp+8)
80050d8: 37 9c 00 0c addi sp,sp,12
80050dc: c3 a0 00 00 ret
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
80050e0: 28 24 01 24 lw r4,(r1+292)
while (tvp) {
80050e4: 44 82 00 09 be r4,r2,8005108 <rtems_task_variable_delete+0x68>
if (tvp->ptr == ptr) {
80050e8: 28 82 00 04 lw r2,(r4+4)
80050ec: 5c 4b 00 05 bne r2,r11,8005100 <rtems_task_variable_delete+0x60>
80050f0: e0 00 00 18 bi 8005150 <rtems_task_variable_delete+0xb0>
80050f4: 28 62 00 04 lw r2,(r3+4)
80050f8: 44 4b 00 0b be r2,r11,8005124 <rtems_task_variable_delete+0x84>
80050fc: b8 60 20 00 mv r4,r3
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
8005100: 28 83 00 00 lw r3,(r4+0)
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
8005104: 5c 60 ff fc bne r3,r0,80050f4 <rtems_task_variable_delete+0x54><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
8005108: f8 00 09 6c calli 80076b8 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
800510c: 34 02 00 09 mvi r2,9
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8005110: b8 40 08 00 mv r1,r2
8005114: 2b 9d 00 04 lw ra,(sp+4)
8005118: 2b 8b 00 08 lw r11,(sp+8)
800511c: 37 9c 00 0c addi sp,sp,12
8005120: c3 a0 00 00 ret
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
8005124: 28 62 00 00 lw r2,(r3+0)
8005128: 58 82 00 00 sw (r4+0),r2
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
800512c: b8 60 10 00 mv r2,r3
8005130: f8 00 00 39 calli 8005214 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
8005134: f8 00 09 61 calli 80076b8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8005138: 34 02 00 00 mvi r2,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
800513c: b8 40 08 00 mv r1,r2
8005140: 2b 9d 00 04 lw ra,(sp+4)
8005144: 2b 8b 00 08 lw r11,(sp+8)
8005148: 37 9c 00 0c addi sp,sp,12
800514c: c3 a0 00 00 ret
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
8005150: 28 82 00 00 lw r2,(r4+0)
8005154: b8 80 18 00 mv r3,r4
8005158: 58 22 01 24 sw (r1+292),r2
800515c: e3 ff ff f4 bi 800512c <rtems_task_variable_delete+0x8c>
08005160 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
8005160: 37 9c ff f0 addi sp,sp,-16
8005164: 5b 8b 00 0c sw (sp+12),r11
8005168: 5b 8c 00 08 sw (sp+8),r12
800516c: 5b 9d 00 04 sw (sp+4),ra
8005170: b8 40 58 00 mv r11,r2
8005174: b8 60 60 00 mv r12,r3
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
8005178: 34 02 00 09 mvi r2,9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
800517c: 45 60 00 07 be r11,r0,8005198 <rtems_task_variable_get+0x38>
return RTEMS_INVALID_ADDRESS;
if ( !result )
8005180: 44 60 00 06 be r3,r0,8005198 <rtems_task_variable_get+0x38>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
8005184: 37 82 00 10 addi r2,sp,16
8005188: f8 00 09 58 calli 80076e8 <_Thread_Get>
switch (location) {
800518c: 2b 82 00 10 lw r2,(sp+16)
8005190: 44 40 00 08 be r2,r0,80051b0 <rtems_task_variable_get+0x50>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8005194: 34 02 00 04 mvi r2,4
}
8005198: b8 40 08 00 mv r1,r2
800519c: 2b 9d 00 04 lw ra,(sp+4)
80051a0: 2b 8b 00 0c lw r11,(sp+12)
80051a4: 2b 8c 00 08 lw r12,(sp+8)
80051a8: 37 9c 00 10 addi sp,sp,16
80051ac: c3 a0 00 00 ret
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
80051b0: 28 21 01 24 lw r1,(r1+292)
while (tvp) {
80051b4: 5c 22 00 04 bne r1,r2,80051c4 <rtems_task_variable_get+0x64>
80051b8: e0 00 00 0f bi 80051f4 <rtems_task_variable_get+0x94>
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
80051bc: 28 21 00 00 lw r1,(r1+0)
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
80051c0: 44 20 00 0d be r1,r0,80051f4 <rtems_task_variable_get+0x94><== NEVER TAKEN
if (tvp->ptr == ptr) {
80051c4: 28 22 00 04 lw r2,(r1+4)
80051c8: 5c 4b ff fd bne r2,r11,80051bc <rtems_task_variable_get+0x5c>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
80051cc: 28 21 00 0c lw r1,(r1+12)
80051d0: 59 81 00 00 sw (r12+0),r1
_Thread_Enable_dispatch();
80051d4: f8 00 09 39 calli 80076b8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80051d8: 34 02 00 00 mvi r2,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80051dc: b8 40 08 00 mv r1,r2
80051e0: 2b 9d 00 04 lw ra,(sp+4)
80051e4: 2b 8b 00 0c lw r11,(sp+12)
80051e8: 2b 8c 00 08 lw r12,(sp+8)
80051ec: 37 9c 00 10 addi sp,sp,16
80051f0: c3 a0 00 00 ret
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
80051f4: f8 00 09 31 calli 80076b8 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
80051f8: 34 02 00 09 mvi r2,9
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80051fc: b8 40 08 00 mv r1,r2
8005200: 2b 9d 00 04 lw ra,(sp+4)
8005204: 2b 8b 00 0c lw r11,(sp+12)
8005208: 2b 8c 00 08 lw r12,(sp+8)
800520c: 37 9c 00 10 addi sp,sp,16
8005210: c3 a0 00 00 ret
0800569c <rtems_task_wake_when>:
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
800569c: 37 9c ff ec addi sp,sp,-20
80056a0: 5b 8b 00 14 sw (sp+20),r11
80056a4: 5b 8c 00 10 sw (sp+16),r12
80056a8: 5b 8d 00 0c sw (sp+12),r13
80056ac: 5b 8e 00 08 sw (sp+8),r14
80056b0: 5b 9d 00 04 sw (sp+4),ra
Watchdog_Interval seconds;
if ( !_TOD.is_set )
80056b4: 78 0b 08 02 mvhi r11,0x802
80056b8: 39 6b 29 40 ori r11,r11,0x2940
80056bc: 41 62 00 14 lbu r2,(r11+20)
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
80056c0: b8 20 68 00 mv r13,r1
Watchdog_Interval seconds;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
80056c4: 34 0c 00 0b mvi r12,11
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD.is_set )
80056c8: 44 40 00 07 be r2,r0,80056e4 <rtems_task_wake_when+0x48>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
80056cc: 34 0c 00 09 mvi r12,9
Watchdog_Interval seconds;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
80056d0: 44 20 00 05 be r1,r0,80056e4 <rtems_task_wake_when+0x48>
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
80056d4: 58 20 00 18 sw (r1+24),r0
if ( !_TOD_Validate( time_buffer ) )
80056d8: fb ff fd 5c calli 8004c48 <_TOD_Validate>
return RTEMS_INVALID_CLOCK;
80056dc: 34 0c 00 14 mvi r12,20
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
80056e0: 5c 20 00 09 bne r1,r0,8005704 <rtems_task_wake_when+0x68>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
80056e4: b9 80 08 00 mv r1,r12
80056e8: 2b 9d 00 04 lw ra,(sp+4)
80056ec: 2b 8b 00 14 lw r11,(sp+20)
80056f0: 2b 8c 00 10 lw r12,(sp+16)
80056f4: 2b 8d 00 0c lw r13,(sp+12)
80056f8: 2b 8e 00 08 lw r14,(sp+8)
80056fc: 37 9c 00 14 addi sp,sp,20
8005700: c3 a0 00 00 ret
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
8005704: b9 a0 08 00 mv r1,r13
8005708: fb ff fc ef calli 8004ac4 <_TOD_To_seconds>
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
800570c: 78 03 08 01 mvhi r3,0x801
8005710: 38 63 f8 44 ori r3,r3,0xf844
8005714: b8 20 70 00 mv r14,r1
8005718: 28 64 00 00 lw r4,(r3+0)
800571c: 29 62 00 04 lw r2,(r11+4)
8005720: 29 61 00 00 lw r1,(r11+0)
8005724: 34 03 00 00 mvi r3,0
8005728: f8 00 4c 84 calli 8018938 <__divdi3>
if ( seconds <= _TOD_Seconds_since_epoch() )
800572c: 50 4e ff ee bgeu r2,r14,80056e4 <rtems_task_wake_when+0x48><== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
8005730: 78 02 08 02 mvhi r2,0x802
8005734: 38 42 29 c0 ori r2,r2,0x29c0
8005738: 28 41 00 00 lw r1,(r2+0)
++level;
800573c: 34 21 00 01 addi r1,r1,1
_Thread_Dispatch_disable_level = level;
8005740: 58 41 00 00 sw (r2+0),r1
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
8005744: 78 0d 08 02 mvhi r13,0x802
8005748: 39 ad 2e 60 ori r13,r13,0x2e60
800574c: 29 a1 00 10 lw r1,(r13+16)
8005750: 34 02 00 10 mvi r2,16
_Watchdog_Insert_seconds(
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
8005754: 34 0c 00 00 mvi r12,0
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
8005758: f8 00 0d 88 calli 8008d78 <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
800575c: 29 ad 00 10 lw r13,(r13+16)
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
8005760: 78 01 08 00 mvhi r1,0x800
8005764: 38 21 80 5c ori r1,r1,0x805c
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
_Watchdog_Initialize(
8005768: 29 a2 00 08 lw r2,(r13+8)
800576c: 78 03 08 01 mvhi r3,0x801
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8005770: 59 a0 00 50 sw (r13+80),r0
the_watchdog->routine = routine;
8005774: 59 a1 00 64 sw (r13+100),r1
the_watchdog->id = id;
8005778: 59 a2 00 68 sw (r13+104),r2
the_watchdog->user_data = user_data;
800577c: 59 a0 00 6c sw (r13+108),r0
8005780: 38 63 f8 44 ori r3,r3,0xf844
8005784: 28 64 00 00 lw r4,(r3+0)
8005788: 29 61 00 00 lw r1,(r11+0)
800578c: 29 62 00 04 lw r2,(r11+4)
8005790: 34 03 00 00 mvi r3,0
8005794: f8 00 4c 69 calli 8018938 <__divdi3>
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
8005798: c9 c2 70 00 sub r14,r14,r2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
800579c: 78 01 08 02 mvhi r1,0x802
80057a0: 38 21 2a 4c ori r1,r1,0x2a4c
80057a4: 35 a2 00 48 addi r2,r13,72
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
80057a8: 59 ae 00 54 sw (r13+84),r14
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
80057ac: f8 00 0e c9 calli 80092d0 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
80057b0: f8 00 0a c9 calli 80082d4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80057b4: e3 ff ff cc bi 80056e4 <rtems_task_wake_when+0x48>
080150c8 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
80150c8: 37 9c ff f8 addi sp,sp,-8
80150cc: 5b 9d 00 04 sw (sp+4),ra
80150d0: b8 20 10 00 mv r2,r1
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
80150d4: 78 01 08 04 mvhi r1,0x804
80150d8: 38 21 06 50 ori r1,r1,0x650
80150dc: 37 83 00 08 addi r3,sp,8
80150e0: f8 00 0f 02 calli 8018ce8 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
80150e4: 2b 82 00 08 lw r2,(sp+8)
80150e8: 44 40 00 05 be r2,r0,80150fc <rtems_timer_cancel+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
80150ec: 34 01 00 04 mvi r1,4
}
80150f0: 2b 9d 00 04 lw ra,(sp+4)
80150f4: 37 9c 00 08 addi sp,sp,8
80150f8: c3 a0 00 00 ret
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
80150fc: 28 23 00 38 lw r3,(r1+56)
8015100: 34 02 00 04 mvi r2,4
8015104: 44 62 00 03 be r3,r2,8015110 <rtems_timer_cancel+0x48> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
8015108: 34 21 00 10 addi r1,r1,16
801510c: f8 00 18 2b calli 801b1b8 <_Watchdog_Remove>
_Thread_Enable_dispatch();
8015110: f8 00 13 6e calli 8019ec8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8015114: 34 01 00 00 mvi r1,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8015118: 2b 9d 00 04 lw ra,(sp+4)
801511c: 37 9c 00 08 addi sp,sp,8
8015120: c3 a0 00 00 ret
0801576c <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
801576c: 37 9c ff d8 addi sp,sp,-40
8015770: 5b 8b 00 24 sw (sp+36),r11
8015774: 5b 8c 00 20 sw (sp+32),r12
8015778: 5b 8d 00 1c sw (sp+28),r13
801577c: 5b 8e 00 18 sw (sp+24),r14
8015780: 5b 8f 00 14 sw (sp+20),r15
8015784: 5b 90 00 10 sw (sp+16),r16
8015788: 5b 91 00 0c sw (sp+12),r17
801578c: 5b 92 00 08 sw (sp+8),r18
8015790: 5b 9d 00 04 sw (sp+4),ra
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
8015794: 78 05 08 04 mvhi r5,0x804
8015798: 38 a5 06 90 ori r5,r5,0x690
801579c: 28 ad 00 00 lw r13,(r5+0)
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
80157a0: b8 20 80 00 mv r16,r1
80157a4: b8 40 70 00 mv r14,r2
80157a8: b8 60 78 00 mv r15,r3
80157ac: b8 80 88 00 mv r17,r4
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
80157b0: 34 0c 00 0e mvi r12,14
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
80157b4: 45 a0 00 0c be r13,r0,80157e4 <rtems_timer_server_fire_when+0x78>
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
80157b8: 78 0b 08 03 mvhi r11,0x803
80157bc: 39 6b fc d0 ori r11,r11,0xfcd0
80157c0: 41 65 00 14 lbu r5,(r11+20)
return RTEMS_NOT_DEFINED;
80157c4: 34 0c 00 0b mvi r12,11
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
80157c8: 44 a0 00 07 be r5,r0,80157e4 <rtems_timer_server_fire_when+0x78><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
80157cc: 34 0c 00 09 mvi r12,9
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
80157d0: 44 60 00 05 be r3,r0,80157e4 <rtems_timer_server_fire_when+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
80157d4: b8 40 08 00 mv r1,r2
80157d8: fb ff ef f6 calli 80117b0 <_TOD_Validate>
return RTEMS_INVALID_CLOCK;
80157dc: 34 0c 00 14 mvi r12,20
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
80157e0: 5c 20 00 0d bne r1,r0,8015814 <rtems_timer_server_fire_when+0xa8>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80157e4: b9 80 08 00 mv r1,r12
80157e8: 2b 9d 00 04 lw ra,(sp+4)
80157ec: 2b 8b 00 24 lw r11,(sp+36)
80157f0: 2b 8c 00 20 lw r12,(sp+32)
80157f4: 2b 8d 00 1c lw r13,(sp+28)
80157f8: 2b 8e 00 18 lw r14,(sp+24)
80157fc: 2b 8f 00 14 lw r15,(sp+20)
8015800: 2b 90 00 10 lw r16,(sp+16)
8015804: 2b 91 00 0c lw r17,(sp+12)
8015808: 2b 92 00 08 lw r18,(sp+8)
801580c: 37 9c 00 28 addi sp,sp,40
8015810: c3 a0 00 00 ret
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
8015814: b9 c0 08 00 mv r1,r14
8015818: fb ff ef 85 calli 801162c <_TOD_To_seconds>
801581c: 78 03 08 03 mvhi r3,0x803
8015820: 38 63 90 8c ori r3,r3,0x908c
8015824: b8 20 90 00 mv r18,r1
8015828: 28 64 00 00 lw r4,(r3+0)
801582c: 29 62 00 04 lw r2,(r11+4)
8015830: 29 61 00 00 lw r1,(r11+0)
8015834: 34 03 00 00 mvi r3,0
8015838: f8 00 57 73 calli 802b604 <__divdi3>
if ( seconds <= _TOD_Seconds_since_epoch() )
801583c: 50 52 ff ea bgeu r2,r18,80157e4 <rtems_timer_server_fire_when+0x78>
8015840: 78 01 08 04 mvhi r1,0x804
8015844: 38 21 06 50 ori r1,r1,0x650
8015848: ba 00 10 00 mv r2,r16
801584c: 37 83 00 28 addi r3,sp,40
8015850: f8 00 0d 26 calli 8018ce8 <_Objects_Get>
8015854: b8 20 70 00 mv r14,r1
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
8015858: 2b 81 00 28 lw r1,(sp+40)
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
801585c: 34 0c 00 04 mvi r12,4
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
8015860: 5c 20 ff e1 bne r1,r0,80157e4 <rtems_timer_server_fire_when+0x78>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
8015864: 35 c1 00 10 addi r1,r14,16
8015868: f8 00 16 54 calli 801b1b8 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
801586c: 34 01 00 03 mvi r1,3
8015870: 78 03 08 03 mvhi r3,0x803
8015874: 59 c1 00 38 sw (r14+56),r1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8015878: 59 c0 00 18 sw (r14+24),r0
the_watchdog->routine = routine;
801587c: 59 cf 00 2c sw (r14+44),r15
the_watchdog->id = id;
8015880: 59 d0 00 30 sw (r14+48),r16
the_watchdog->user_data = user_data;
8015884: 59 d1 00 34 sw (r14+52),r17
8015888: 38 63 90 8c ori r3,r3,0x908c
801588c: 28 64 00 00 lw r4,(r3+0)
8015890: 29 61 00 00 lw r1,(r11+0)
8015894: 29 62 00 04 lw r2,(r11+4)
8015898: 34 03 00 00 mvi r3,0
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
(*timer_server->schedule_operation)( timer_server, the_timer );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
801589c: 34 0c 00 00 mvi r12,0
80158a0: f8 00 57 59 calli 802b604 <__divdi3>
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
(*timer_server->schedule_operation)( timer_server, the_timer );
80158a4: 29 a3 00 04 lw r3,(r13+4)
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
80158a8: ca 42 90 00 sub r18,r18,r2
(*timer_server->schedule_operation)( timer_server, the_timer );
80158ac: b9 a0 08 00 mv r1,r13
80158b0: b9 c0 10 00 mv r2,r14
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
80158b4: 59 d2 00 1c sw (r14+28),r18
(*timer_server->schedule_operation)( timer_server, the_timer );
80158b8: d8 60 00 00 call r3
_Thread_Enable_dispatch();
80158bc: f8 00 11 83 calli 8019ec8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80158c0: e3 ff ff c9 bi 80157e4 <rtems_timer_server_fire_when+0x78>
08004758 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
8004758: 37 9c ff fc addi sp,sp,-4
800475c: 5b 9d 00 04 sw (sp+4),ra
switch ( policy ) {
8004760: 48 01 00 05 bg r0,r1,8004774 <sched_get_priority_max+0x1c>
8004764: 34 02 00 02 mvi r2,2
8004768: 4c 41 00 08 bge r2,r1,8004788 <sched_get_priority_max+0x30>
800476c: 34 02 00 04 mvi r2,4
8004770: 44 22 00 06 be r1,r2,8004788 <sched_get_priority_max+0x30> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
8004774: f8 00 25 06 calli 800db8c <__errno>
8004778: 34 02 00 16 mvi r2,22
800477c: 58 22 00 00 sw (r1+0),r2
8004780: 34 01 ff ff mvi r1,-1
8004784: e0 00 00 05 bi 8004798 <sched_get_priority_max+0x40>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
8004788: 78 01 08 02 mvhi r1,0x802
800478c: 38 21 00 fc ori r1,r1,0xfc
8004790: 40 21 00 00 lbu r1,(r1+0)
8004794: 34 21 ff ff addi r1,r1,-1
}
8004798: 2b 9d 00 04 lw ra,(sp+4)
800479c: 37 9c 00 04 addi sp,sp,4
80047a0: c3 a0 00 00 ret
080047a4 <sched_get_priority_min>:
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
80047a4: 37 9c ff fc addi sp,sp,-4
80047a8: 5b 9d 00 04 sw (sp+4),ra
switch ( policy ) {
80047ac: 48 01 00 05 bg r0,r1,80047c0 <sched_get_priority_min+0x1c>
80047b0: 34 02 00 02 mvi r2,2
80047b4: 4c 41 00 08 bge r2,r1,80047d4 <sched_get_priority_min+0x30><== ALWAYS TAKEN
80047b8: 34 02 00 04 mvi r2,4 <== NOT EXECUTED
80047bc: 44 22 00 06 be r1,r2,80047d4 <sched_get_priority_min+0x30> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
80047c0: f8 00 24 f3 calli 800db8c <__errno>
80047c4: 34 02 00 16 mvi r2,22
80047c8: 58 22 00 00 sw (r1+0),r2
80047cc: 34 01 ff ff mvi r1,-1
80047d0: e0 00 00 02 bi 80047d8 <sched_get_priority_min+0x34>
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
80047d4: 34 01 00 01 mvi r1,1
}
80047d8: 2b 9d 00 04 lw ra,(sp+4)
80047dc: 37 9c 00 04 addi sp,sp,4
80047e0: c3 a0 00 00 ret
080047e4 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
80047e4: 37 9c ff f4 addi sp,sp,-12
80047e8: 5b 8b 00 08 sw (sp+8),r11
80047ec: 5b 9d 00 04 sw (sp+4),ra
80047f0: b8 20 58 00 mv r11,r1
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
80047f4: 5c 20 00 0b bne r1,r0,8004820 <sched_rr_get_interval+0x3c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
80047f8: 44 40 00 13 be r2,r0,8004844 <sched_rr_get_interval+0x60>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
80047fc: 78 01 08 02 mvhi r1,0x802
8004800: 38 21 08 80 ori r1,r1,0x880
8004804: 28 21 00 00 lw r1,(r1+0)
8004808: f8 00 0f 37 calli 80084e4 <_Timespec_From_ticks>
return 0;
800480c: 34 01 00 00 mvi r1,0
}
8004810: 2b 9d 00 04 lw ra,(sp+4)
8004814: 2b 8b 00 08 lw r11,(sp+8)
8004818: 37 9c 00 0c addi sp,sp,12
800481c: c3 a0 00 00 ret
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
8004820: 5b 82 00 0c sw (sp+12),r2
8004824: fb ff f4 a5 calli 8001ab8 <getpid>
8004828: 2b 82 00 0c lw r2,(sp+12)
800482c: 44 2b ff f3 be r1,r11,80047f8 <sched_rr_get_interval+0x14>
rtems_set_errno_and_return_minus_one( ESRCH );
8004830: f8 00 24 d7 calli 800db8c <__errno>
8004834: 34 02 00 03 mvi r2,3
8004838: 58 22 00 00 sw (r1+0),r2
800483c: 34 01 ff ff mvi r1,-1
8004840: e3 ff ff f4 bi 8004810 <sched_rr_get_interval+0x2c>
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
8004844: f8 00 24 d2 calli 800db8c <__errno>
8004848: 34 02 00 16 mvi r2,22
800484c: 58 22 00 00 sw (r1+0),r2
8004850: 34 01 ff ff mvi r1,-1
8004854: e3 ff ff ef bi 8004810 <sched_rr_get_interval+0x2c>
080051dc <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
80051dc: 37 9c ff b8 addi sp,sp,-72
80051e0: 5b 8b 00 1c sw (sp+28),r11
80051e4: 5b 8c 00 18 sw (sp+24),r12
80051e8: 5b 8d 00 14 sw (sp+20),r13
80051ec: 5b 8e 00 10 sw (sp+16),r14
80051f0: 5b 8f 00 0c sw (sp+12),r15
80051f4: 5b 90 00 08 sw (sp+8),r16
80051f8: 5b 9d 00 04 sw (sp+4),ra
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
80051fc: 78 09 08 02 mvhi r9,0x802
8005200: 39 29 53 28 ori r9,r9,0x5328
8005204: 29 2a 00 00 lw r10,(r9+0)
8005208: b8 20 78 00 mv r15,r1
800520c: 5b 82 00 30 sw (sp+48),r2
++level;
8005210: 35 41 00 01 addi r1,r10,1
8005214: 5b 83 00 34 sw (sp+52),r3
8005218: 5b 84 00 38 sw (sp+56),r4
800521c: 5b 85 00 3c sw (sp+60),r5
8005220: 5b 86 00 40 sw (sp+64),r6
8005224: 5b 87 00 44 sw (sp+68),r7
8005228: 5b 88 00 48 sw (sp+72),r8
800522c: b8 40 68 00 mv r13,r2
_Thread_Dispatch_disable_level = level;
8005230: 59 21 00 00 sw (r9+0),r1
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
8005234: 20 4e 02 00 andi r14,r2,0x200
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
8005238: 34 10 00 00 mvi r16,0
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
800523c: 5d c0 00 2a bne r14,r0,80052e4 <sem_open+0x108>
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
8005240: 78 0b 08 02 mvhi r11,0x802
8005244: 39 6b 55 64 ori r11,r11,0x5564
8005248: b9 60 08 00 mv r1,r11
800524c: b9 e0 10 00 mv r2,r15
8005250: 37 83 00 2c addi r3,sp,44
8005254: 37 84 00 20 addi r4,sp,32
8005258: fb ff fd e7 calli 80049f4 <_POSIX_Name_to_id>
800525c: b8 20 60 00 mv r12,r1
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
8005260: 44 20 00 09 be r1,r0,8005284 <sem_open+0xa8>
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
8005264: 34 01 00 02 mvi r1,2
8005268: 5d 81 00 02 bne r12,r1,8005270 <sem_open+0x94>
800526c: 5d c0 00 20 bne r14,r0,80052ec <sem_open+0x110>
_Thread_Enable_dispatch();
8005270: f8 00 0e d7 calli 8008dcc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
8005274: f8 00 29 51 calli 800f7b8 <__errno>
8005278: 58 2c 00 00 sw (r1+0),r12
800527c: 34 01 ff ff mvi r1,-1
8005280: e0 00 00 10 bi 80052c0 <sem_open+0xe4>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
8005284: 21 ad 0a 00 andi r13,r13,0xa00
8005288: 34 01 0a 00 mvi r1,2560
800528c: 45 a1 00 23 be r13,r1,8005318 <sem_open+0x13c>
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
_Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location );
8005290: 2b 82 00 2c lw r2,(sp+44)
8005294: 37 83 00 24 addi r3,sp,36
8005298: b9 60 08 00 mv r1,r11
800529c: f8 00 0a b7 calli 8007d78 <_Objects_Get>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
the_semaphore->open_count += 1;
80052a0: 28 22 00 18 lw r2,(r1+24)
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
80052a4: 5b 81 00 28 sw (sp+40),r1
the_semaphore->open_count += 1;
80052a8: 34 42 00 01 addi r2,r2,1
80052ac: 58 22 00 18 sw (r1+24),r2
_Thread_Enable_dispatch();
80052b0: f8 00 0e c7 calli 8008dcc <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
80052b4: f8 00 0e c6 calli 8008dcc <_Thread_Enable_dispatch>
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
return &the_semaphore->Semaphore_id;
#else
return (sem_t *)&the_semaphore->Object.id;
80052b8: 2b 81 00 28 lw r1,(sp+40)
80052bc: 34 21 00 08 addi r1,r1,8
#endif
}
80052c0: 2b 9d 00 04 lw ra,(sp+4)
80052c4: 2b 8b 00 1c lw r11,(sp+28)
80052c8: 2b 8c 00 18 lw r12,(sp+24)
80052cc: 2b 8d 00 14 lw r13,(sp+20)
80052d0: 2b 8e 00 10 lw r14,(sp+16)
80052d4: 2b 8f 00 0c lw r15,(sp+12)
80052d8: 2b 90 00 08 lw r16,(sp+8)
80052dc: 37 9c 00 48 addi sp,sp,72
80052e0: c3 a0 00 00 ret
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
80052e4: 2b 90 00 38 lw r16,(sp+56)
80052e8: e3 ff ff d6 bi 8005240 <sem_open+0x64>
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
80052ec: 2b 82 00 20 lw r2,(sp+32)
80052f0: 34 03 00 00 mvi r3,0
80052f4: ba 00 20 00 mv r4,r16
80052f8: 37 85 00 28 addi r5,sp,40
80052fc: b9 e0 08 00 mv r1,r15
8005300: f8 00 1c f6 calli 800c6d8 <_POSIX_Semaphore_Create_support>
8005304: b8 20 58 00 mv r11,r1
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
8005308: f8 00 0e b1 calli 8008dcc <_Thread_Enable_dispatch>
if ( status == -1 )
return SEM_FAILED;
800530c: 34 01 ff ff mvi r1,-1
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
8005310: 5d 61 ff ea bne r11,r1,80052b8 <sem_open+0xdc> <== ALWAYS TAKEN
8005314: e3 ff ff eb bi 80052c0 <sem_open+0xe4> <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
8005318: f8 00 0e ad calli 8008dcc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
800531c: f8 00 29 27 calli 800f7b8 <__errno>
8005320: 34 02 00 11 mvi r2,17
8005324: 58 22 00 00 sw (r1+0),r2
8005328: 34 01 ff ff mvi r1,-1
800532c: e3 ff ff e5 bi 80052c0 <sem_open+0xe4>
08006c5c <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
8006c5c: 37 9c ff f4 addi sp,sp,-12
8006c60: 5b 8b 00 08 sw (sp+8),r11
8006c64: 5b 9d 00 04 sw (sp+4),ra
8006c68: b8 20 58 00 mv r11,r1
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
8006c6c: b8 40 08 00 mv r1,r2
8006c70: 37 82 00 0c addi r2,sp,12
8006c74: f8 00 16 ae calli 800c72c <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
8006c78: 34 02 00 03 mvi r2,3
8006c7c: 44 22 00 09 be r1,r2,8006ca0 <sem_timedwait+0x44> <== ALWAYS TAKEN
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
8006c80: 2b 83 00 0c lw r3,(sp+12) <== NOT EXECUTED
8006c84: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8006c88: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
8006c8c: f8 00 1a bb calli 800d778 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
8006c90: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8006c94: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
8006c98: 37 9c 00 0c addi sp,sp,12 <== NOT EXECUTED
8006c9c: c3 a0 00 00 ret <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
8006ca0: 2b 83 00 0c lw r3,(sp+12)
8006ca4: b9 60 08 00 mv r1,r11
8006ca8: 34 02 00 01 mvi r2,1
8006cac: f8 00 1a b3 calli 800d778 <_POSIX_Semaphore_Wait_support>
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
8006cb0: 2b 9d 00 04 lw ra,(sp+4)
8006cb4: 2b 8b 00 08 lw r11,(sp+8)
8006cb8: 37 9c 00 0c addi sp,sp,12
8006cbc: c3 a0 00 00 ret
08004980 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
8004980: 37 9c ff f0 addi sp,sp,-16
8004984: 5b 8b 00 10 sw (sp+16),r11
8004988: 5b 8c 00 0c sw (sp+12),r12
800498c: 5b 8d 00 08 sw (sp+8),r13
8004990: 5b 9d 00 04 sw (sp+4),ra
8004994: b8 20 58 00 mv r11,r1
8004998: b8 40 60 00 mv r12,r2
ISR_Level level;
if ( oact )
800499c: 44 60 00 0e be r3,r0,80049d4 <sigaction+0x54>
*oact = _POSIX_signals_Vectors[ sig ];
80049a0: b4 21 08 00 add r1,r1,r1
80049a4: b4 2b 08 00 add r1,r1,r11
80049a8: 78 02 08 01 mvhi r2,0x801
80049ac: b4 21 08 00 add r1,r1,r1
80049b0: 38 42 9e 48 ori r2,r2,0x9e48
80049b4: b4 21 08 00 add r1,r1,r1
80049b8: b4 41 08 00 add r1,r2,r1
80049bc: 28 22 00 00 lw r2,(r1+0)
80049c0: 58 62 00 00 sw (r3+0),r2
80049c4: 28 22 00 04 lw r2,(r1+4)
80049c8: 58 62 00 04 sw (r3+4),r2
80049cc: 28 21 00 08 lw r1,(r1+8)
80049d0: 58 61 00 08 sw (r3+8),r1
if ( !sig )
80049d4: 45 60 00 04 be r11,r0,80049e4 <sigaction+0x64>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
80049d8: 35 61 ff ff addi r1,r11,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
80049dc: 34 02 00 1f mvi r2,31
80049e0: 50 41 00 06 bgeu r2,r1,80049f8 <sigaction+0x78>
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
80049e4: f8 00 26 73 calli 800e3b0 <__errno>
80049e8: 34 02 00 16 mvi r2,22
80049ec: 58 22 00 00 sw (r1+0),r2
80049f0: 34 01 ff ff mvi r1,-1
80049f4: e0 00 00 1c bi 8004a64 <sigaction+0xe4>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
80049f8: 34 01 00 09 mvi r1,9
80049fc: 45 61 ff fa be r11,r1,80049e4 <sigaction+0x64>
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
8004a00: 34 01 00 00 mvi r1,0
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
8004a04: 45 80 00 18 be r12,r0,8004a64 <sigaction+0xe4> <== NEVER TAKEN
/*
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
8004a08: 90 00 68 00 rcsr r13,IE
8004a0c: 34 01 ff fe mvi r1,-2
8004a10: a1 a1 08 00 and r1,r13,r1
8004a14: d0 01 00 00 wcsr IE,r1
if ( act->sa_handler == SIG_DFL ) {
8004a18: 29 81 00 08 lw r1,(r12+8)
8004a1c: 44 20 00 18 be r1,r0,8004a7c <sigaction+0xfc>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
8004a20: b9 60 08 00 mv r1,r11
8004a24: f8 00 18 63 calli 800abb0 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
8004a28: b5 6b 08 00 add r1,r11,r11
8004a2c: b4 2b 58 00 add r11,r1,r11
8004a30: 29 82 00 00 lw r2,(r12+0)
8004a34: 78 01 08 01 mvhi r1,0x801
8004a38: b5 6b 58 00 add r11,r11,r11
8004a3c: 38 21 9e 48 ori r1,r1,0x9e48
8004a40: b5 6b 58 00 add r11,r11,r11
8004a44: b4 2b 58 00 add r11,r1,r11
8004a48: 59 62 00 00 sw (r11+0),r2
8004a4c: 29 81 00 04 lw r1,(r12+4)
8004a50: 59 61 00 04 sw (r11+4),r1
8004a54: 29 81 00 08 lw r1,(r12+8)
8004a58: 59 61 00 08 sw (r11+8),r1
}
_ISR_Enable( level );
8004a5c: d0 0d 00 00 wcsr IE,r13
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
8004a60: 34 01 00 00 mvi r1,0
}
8004a64: 2b 9d 00 04 lw ra,(sp+4)
8004a68: 2b 8b 00 10 lw r11,(sp+16)
8004a6c: 2b 8c 00 0c lw r12,(sp+12)
8004a70: 2b 8d 00 08 lw r13,(sp+8)
8004a74: 37 9c 00 10 addi sp,sp,16
8004a78: c3 a0 00 00 ret
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
8004a7c: b5 6b 08 00 add r1,r11,r11
8004a80: b4 2b 58 00 add r11,r1,r11
8004a84: b5 6b 58 00 add r11,r11,r11
8004a88: 78 02 08 01 mvhi r2,0x801
8004a8c: b5 6b 58 00 add r11,r11,r11
8004a90: 38 42 7e 04 ori r2,r2,0x7e04
8004a94: b4 4b 10 00 add r2,r2,r11
8004a98: 28 44 00 00 lw r4,(r2+0)
8004a9c: 28 43 00 04 lw r3,(r2+4)
8004aa0: 78 01 08 01 mvhi r1,0x801
8004aa4: 28 42 00 08 lw r2,(r2+8)
8004aa8: 38 21 9e 48 ori r1,r1,0x9e48
8004aac: b4 2b 58 00 add r11,r1,r11
8004ab0: 59 64 00 00 sw (r11+0),r4
8004ab4: 59 63 00 04 sw (r11+4),r3
8004ab8: 59 62 00 08 sw (r11+8),r2
8004abc: e3 ff ff e8 bi 8004a5c <sigaction+0xdc>
08004fa8 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
8004fa8: 37 9c ff d8 addi sp,sp,-40
8004fac: 5b 8b 00 1c sw (sp+28),r11
8004fb0: 5b 8c 00 18 sw (sp+24),r12
8004fb4: 5b 8d 00 14 sw (sp+20),r13
8004fb8: 5b 8e 00 10 sw (sp+16),r14
8004fbc: 5b 8f 00 0c sw (sp+12),r15
8004fc0: 5b 90 00 08 sw (sp+8),r16
8004fc4: 5b 9d 00 04 sw (sp+4),ra
8004fc8: b8 20 68 00 mv r13,r1
8004fcc: b8 40 58 00 mv r11,r2
8004fd0: b8 60 60 00 mv r12,r3
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
8004fd4: 44 20 00 70 be r1,r0,8005194 <sigtimedwait+0x1ec> <== NEVER TAKEN
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
8004fd8: 44 60 00 5c be r3,r0,8005148 <sigtimedwait+0x1a0>
if ( !_Timespec_Is_valid( timeout ) )
8004fdc: b8 60 08 00 mv r1,r3
8004fe0: f8 00 0f 7f calli 8008ddc <_Timespec_Is_valid>
8004fe4: 44 20 00 6c be r1,r0,8005194 <sigtimedwait+0x1ec> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
8004fe8: b9 80 08 00 mv r1,r12
8004fec: f8 00 0f 88 calli 8008e0c <_Timespec_To_ticks>
if ( !interval )
8004ff0: 44 20 00 69 be r1,r0,8005194 <sigtimedwait+0x1ec> <== NEVER TAKEN
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
8004ff4: 45 60 00 57 be r11,r0,8005150 <sigtimedwait+0x1a8> <== NEVER TAKEN
the_thread = _Thread_Executing;
8004ff8: 78 0c 08 01 mvhi r12,0x801
8004ffc: 39 8c 9d c0 ori r12,r12,0x9dc0
8005000: 29 83 00 10 lw r3,(r12+16)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8005004: 28 6f 01 1c lw r15,(r3+284)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
8005008: 90 00 80 00 rcsr r16,IE
800500c: 34 02 ff fe mvi r2,-2
8005010: a2 02 10 00 and r2,r16,r2
8005014: d0 02 00 00 wcsr IE,r2
if ( *set & api->signals_pending ) {
8005018: 29 a5 00 00 lw r5,(r13+0)
800501c: 29 e4 00 d4 lw r4,(r15+212)
8005020: a0 a4 10 00 and r2,r5,r4
8005024: 5c 40 00 4d bne r2,r0,8005158 <sigtimedwait+0x1b0>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
8005028: 78 04 08 01 mvhi r4,0x801
800502c: 38 84 a0 3c ori r4,r4,0xa03c
8005030: 28 84 00 00 lw r4,(r4+0)
8005034: a0 a4 28 00 and r5,r5,r4
8005038: 5c a2 00 35 bne r5,r2,800510c <sigtimedwait+0x164>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
800503c: 78 02 08 01 mvhi r2,0x801
8005040: 38 42 99 38 ori r2,r2,0x9938
8005044: 28 44 00 00 lw r4,(r2+0)
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
8005048: 34 05 ff ff mvi r5,-1
800504c: 59 65 00 00 sw (r11+0),r5
++level;
8005050: 34 84 00 01 addi r4,r4,1
_Thread_Dispatch_disable_level = level;
8005054: 58 44 00 00 sw (r2+0),r4
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
8005058: 34 02 00 04 mvi r2,4
800505c: 58 62 00 34 sw (r3+52),r2
the_thread->Wait.option = *set;
8005060: 29 a4 00 00 lw r4,(r13+0)
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
8005064: 78 02 08 01 mvhi r2,0x801
8005068: 38 42 9f d4 ori r2,r2,0x9fd4
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
800506c: 58 64 00 30 sw (r3+48),r4
the_thread->Wait.return_argument = the_info;
8005070: 58 6b 00 28 sw (r3+40),r11
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
8005074: 58 62 00 44 sw (r3+68),r2
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8005078: 34 03 00 01 mvi r3,1
800507c: 58 43 00 30 sw (r2+48),r3
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
the_thread->Wait.return_argument = the_info;
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
8005080: d0 10 00 00 wcsr IE,r16
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
8005084: 78 03 08 00 mvhi r3,0x800
8005088: b8 20 10 00 mv r2,r1
800508c: 78 01 08 01 mvhi r1,0x801
8005090: 38 63 8b 80 ori r3,r3,0x8b80
8005094: 38 21 9f d4 ori r1,r1,0x9fd4
8005098: f8 00 0d ad calli 800874c <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
800509c: f8 00 0c 29 calli 8008140 <_Thread_Enable_dispatch>
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
80050a0: 29 62 00 00 lw r2,(r11+0)
80050a4: b9 e0 08 00 mv r1,r15
80050a8: b9 60 18 00 mv r3,r11
80050ac: 34 04 00 00 mvi r4,0
80050b0: 34 05 00 00 mvi r5,0
80050b4: f8 00 19 73 calli 800b680 <_POSIX_signals_Clear_signals>
/* Set errno only if return code is not EINTR or
* if EINTR was caused by a signal being caught, which
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
80050b8: 29 81 00 10 lw r1,(r12+16)
80050bc: 28 22 00 34 lw r2,(r1+52)
80050c0: 34 01 00 04 mvi r1,4
80050c4: 5c 41 00 39 bne r2,r1,80051a8 <sigtimedwait+0x200>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
80050c8: 29 6e 00 00 lw r14,(r11+0)
80050cc: 34 01 00 01 mvi r1,1
80050d0: 35 c2 ff ff addi r2,r14,-1
80050d4: f8 00 46 86 calli 8016aec <__ashlsi3>
80050d8: 29 a2 00 00 lw r2,(r13+0)
80050dc: a0 22 08 00 and r1,r1,r2
80050e0: 44 20 00 32 be r1,r0,80051a8 <sigtimedwait+0x200>
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
80050e4: b9 c0 08 00 mv r1,r14
80050e8: 2b 9d 00 04 lw ra,(sp+4)
80050ec: 2b 8b 00 1c lw r11,(sp+28)
80050f0: 2b 8c 00 18 lw r12,(sp+24)
80050f4: 2b 8d 00 14 lw r13,(sp+20)
80050f8: 2b 8e 00 10 lw r14,(sp+16)
80050fc: 2b 8f 00 0c lw r15,(sp+12)
8005100: 2b 90 00 08 lw r16,(sp+8)
8005104: 37 9c 00 28 addi sp,sp,40
8005108: c3 a0 00 00 ret
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
800510c: b8 80 08 00 mv r1,r4
8005110: fb ff ff 86 calli 8004f28 <_POSIX_signals_Get_lowest>
8005114: b8 20 70 00 mv r14,r1
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
8005118: b9 c0 10 00 mv r2,r14
800511c: b9 e0 08 00 mv r1,r15
8005120: b9 60 18 00 mv r3,r11
8005124: 34 04 00 01 mvi r4,1
8005128: 34 05 00 00 mvi r5,0
800512c: f8 00 19 55 calli 800b680 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
8005130: d0 10 00 00 wcsr IE,r16
the_info->si_signo = signo;
the_info->si_code = SI_USER;
8005134: 34 01 00 01 mvi r1,1
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
_ISR_Enable( level );
the_info->si_signo = signo;
8005138: 59 6e 00 00 sw (r11+0),r14
the_info->si_code = SI_USER;
800513c: 59 61 00 04 sw (r11+4),r1
the_info->si_value.sival_int = 0;
8005140: 59 60 00 08 sw (r11+8),r0
return signo;
8005144: e3 ff ff e8 bi 80050e4 <sigtimedwait+0x13c>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
8005148: 34 01 00 00 mvi r1,0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
800514c: 5d 60 ff ab bne r11,r0,8004ff8 <sigtimedwait+0x50>
8005150: 37 8b 00 20 addi r11,sp,32
8005154: e3 ff ff a9 bi 8004ff8 <sigtimedwait+0x50>
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
8005158: b8 80 08 00 mv r1,r4
800515c: fb ff ff 73 calli 8004f28 <_POSIX_signals_Get_lowest>
8005160: b8 20 10 00 mv r2,r1
8005164: 59 61 00 00 sw (r11+0),r1
_POSIX_signals_Clear_signals(
8005168: b9 60 18 00 mv r3,r11
800516c: b9 e0 08 00 mv r1,r15
8005170: 34 04 00 00 mvi r4,0
8005174: 34 05 00 00 mvi r5,0
8005178: f8 00 19 42 calli 800b680 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
800517c: d0 10 00 00 wcsr IE,r16
the_info->si_code = SI_USER;
8005180: 34 01 00 01 mvi r1,1
8005184: 59 61 00 04 sw (r11+4),r1
the_info->si_value.sival_int = 0;
8005188: 59 60 00 08 sw (r11+8),r0
return the_info->si_signo;
800518c: 29 6e 00 00 lw r14,(r11+0)
8005190: e3 ff ff d5 bi 80050e4 <sigtimedwait+0x13c>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
8005194: f8 00 26 46 calli 800eaac <__errno>
8005198: 34 02 00 16 mvi r2,22
800519c: 58 22 00 00 sw (r1+0),r2
80051a0: 34 0e ff ff mvi r14,-1
80051a4: e3 ff ff d0 bi 80050e4 <sigtimedwait+0x13c>
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
80051a8: f8 00 26 41 calli 800eaac <__errno>
80051ac: 29 82 00 10 lw r2,(r12+16)
return -1;
80051b0: 34 0e ff ff mvi r14,-1
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
80051b4: 28 42 00 34 lw r2,(r2+52)
80051b8: 58 22 00 00 sw (r1+0),r2
return -1;
80051bc: e3 ff ff ca bi 80050e4 <sigtimedwait+0x13c>
080071d0 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
80071d0: 37 9c ff f8 addi sp,sp,-8
80071d4: 5b 8b 00 08 sw (sp+8),r11
80071d8: 5b 9d 00 04 sw (sp+4),ra
int status;
status = sigtimedwait( set, NULL, NULL );
80071dc: 34 03 00 00 mvi r3,0
int sigwait(
const sigset_t *set,
int *sig
)
{
80071e0: b8 40 58 00 mv r11,r2
int status;
status = sigtimedwait( set, NULL, NULL );
80071e4: 34 02 00 00 mvi r2,0
80071e8: fb ff ff 6d calli 8006f9c <sigtimedwait>
if ( status != -1 ) {
80071ec: 34 02 ff ff mvi r2,-1
80071f0: 44 22 00 09 be r1,r2,8007214 <sigwait+0x44>
if ( sig )
*sig = status;
return 0;
80071f4: 34 03 00 00 mvi r3,0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
80071f8: 45 60 00 02 be r11,r0,8007200 <sigwait+0x30> <== NEVER TAKEN
*sig = status;
80071fc: 59 61 00 00 sw (r11+0),r1
return 0;
}
return errno;
}
8007200: b8 60 08 00 mv r1,r3
8007204: 2b 9d 00 04 lw ra,(sp+4)
8007208: 2b 8b 00 08 lw r11,(sp+8)
800720c: 37 9c 00 08 addi sp,sp,8
8007210: c3 a0 00 00 ret
if ( sig )
*sig = status;
return 0;
}
return errno;
8007214: f8 00 24 fd calli 8010608 <__errno>
8007218: 28 23 00 00 lw r3,(r1+0)
}
800721c: b8 60 08 00 mv r1,r3
8007220: 2b 9d 00 04 lw ra,(sp+4)
8007224: 2b 8b 00 08 lw r11,(sp+8)
8007228: 37 9c 00 08 addi sp,sp,8
800722c: c3 a0 00 00 ret
08003620 <sysconf>:
*/
long sysconf(
int name
)
{
8003620: 37 9c ff fc addi sp,sp,-4
8003624: 5b 9d 00 04 sw (sp+4),ra
8003628: b8 20 10 00 mv r2,r1
if ( name == _SC_CLK_TCK )
800362c: 34 01 00 02 mvi r1,2
8003630: 44 41 00 0f be r2,r1,800366c <sysconf+0x4c>
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
8003634: 34 01 00 04 mvi r1,4
8003638: 44 41 00 17 be r2,r1,8003694 <sysconf+0x74>
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
800363c: 34 03 00 33 mvi r3,51
return 1024;
8003640: 34 01 04 00 mvi r1,1024
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
8003644: 44 43 00 07 be r2,r3,8003660 <sysconf+0x40>
return 1024;
if ( name == _SC_PAGESIZE )
8003648: 34 03 00 08 mvi r3,8
return PAGE_SIZE;
800364c: 34 01 10 00 mvi r1,4096
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
return 1024;
if ( name == _SC_PAGESIZE )
8003650: 44 43 00 04 be r2,r3,8003660 <sysconf+0x40>
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
8003654: 34 03 00 4f mvi r3,79
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
8003658: 34 01 00 20 mvi r1,32
return 1024;
if ( name == _SC_PAGESIZE )
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
800365c: 5c 43 00 14 bne r2,r3,80036ac <sysconf+0x8c> <== ALWAYS TAKEN
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
8003660: 2b 9d 00 04 lw ra,(sp+4)
8003664: 37 9c 00 04 addi sp,sp,4
8003668: c3 a0 00 00 ret
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
800366c: 78 02 08 01 mvhi r2,0x801
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
8003670: 78 03 08 01 mvhi r3,0x801
8003674: 38 63 43 a8 ori r3,r3,0x43a8
rtems_configuration_get_microseconds_per_tick());
8003678: 38 42 43 14 ori r2,r2,0x4314
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
800367c: 28 61 00 00 lw r1,(r3+0)
8003680: 28 42 00 0c lw r2,(r2+12)
8003684: f8 00 3f 45 calli 8013398 <__udivsi3>
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
8003688: 2b 9d 00 04 lw ra,(sp+4)
800368c: 37 9c 00 04 addi sp,sp,4
8003690: c3 a0 00 00 ret
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
8003694: 78 01 08 01 mvhi r1,0x801
8003698: 38 21 60 10 ori r1,r1,0x6010
800369c: 28 21 00 00 lw r1,(r1+0)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
80036a0: 2b 9d 00 04 lw ra,(sp+4)
80036a4: 37 9c 00 04 addi sp,sp,4
80036a8: c3 a0 00 00 ret
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
80036ac: f8 00 26 3f calli 800cfa8 <__errno>
80036b0: 34 02 00 16 mvi r2,22
80036b4: 58 22 00 00 sw (r1+0),r2
80036b8: 34 01 ff ff mvi r1,-1
80036bc: e3 ff ff e9 bi 8003660 <sysconf+0x40>
08005330 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
8005330: 37 9c ff f0 addi sp,sp,-16
8005334: 5b 8b 00 10 sw (sp+16),r11
8005338: 5b 8c 00 0c sw (sp+12),r12
800533c: 5b 8d 00 08 sw (sp+8),r13
8005340: 5b 9d 00 04 sw (sp+4),ra
8005344: b8 40 58 00 mv r11,r2
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
8005348: 34 02 00 01 mvi r2,1
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
800534c: b8 60 68 00 mv r13,r3
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
8005350: 5c 22 00 06 bne r1,r2,8005368 <timer_create+0x38>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
8005354: 44 60 00 05 be r3,r0,8005368 <timer_create+0x38>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
8005358: 45 60 00 14 be r11,r0,80053a8 <timer_create+0x78>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
800535c: 29 62 00 00 lw r2,(r11+0)
8005360: 34 42 ff ff addi r2,r2,-1
8005364: 50 22 00 0b bgeu r1,r2,8005390 <timer_create+0x60> <== ALWAYS TAKEN
if ( !evp->sigev_signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
8005368: f8 00 29 14 calli 800f7b8 <__errno>
800536c: 34 02 00 16 mvi r2,22
8005370: 58 22 00 00 sw (r1+0),r2
8005374: 34 01 ff ff mvi r1,-1
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
_Thread_Enable_dispatch();
return 0;
}
8005378: 2b 9d 00 04 lw ra,(sp+4)
800537c: 2b 8b 00 10 lw r11,(sp+16)
8005380: 2b 8c 00 0c lw r12,(sp+12)
8005384: 2b 8d 00 08 lw r13,(sp+8)
8005388: 37 9c 00 10 addi sp,sp,16
800538c: c3 a0 00 00 ret
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
8005390: 29 61 00 04 lw r1,(r11+4)
8005394: 44 20 ff f5 be r1,r0,8005368 <timer_create+0x38> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
8005398: 34 21 ff ff addi r1,r1,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
800539c: 34 02 00 1f mvi r2,31
80053a0: 50 41 00 02 bgeu r2,r1,80053a8 <timer_create+0x78> <== ALWAYS TAKEN
80053a4: e3 ff ff f1 bi 8005368 <timer_create+0x38> <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
80053a8: 78 01 08 02 mvhi r1,0x802
80053ac: 38 21 53 28 ori r1,r1,0x5328
80053b0: 28 22 00 00 lw r2,(r1+0)
++level;
80053b4: 34 42 00 01 addi r2,r2,1
_Thread_Dispatch_disable_level = level;
80053b8: 58 22 00 00 sw (r1+0),r2
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
80053bc: 78 0c 08 02 mvhi r12,0x802
80053c0: 39 8c 55 a4 ori r12,r12,0x55a4
80053c4: b9 80 08 00 mv r1,r12
80053c8: f8 00 08 e8 calli 8007768 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
80053cc: 44 20 00 29 be r1,r0,8005470 <timer_create+0x140>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
80053d0: 78 02 08 02 mvhi r2,0x802
rtems_set_errno_and_return_minus_one( EAGAIN );
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
80053d4: 34 03 00 02 mvi r3,2
80053d8: 30 23 00 3c sb (r1+60),r3
ptimer->thread_id = _Thread_Executing->Object.id;
80053dc: 38 42 58 00 ori r2,r2,0x5800
80053e0: 28 42 00 10 lw r2,(r2+16)
80053e4: 28 42 00 08 lw r2,(r2+8)
80053e8: 58 22 00 38 sw (r1+56),r2
if ( evp != NULL ) {
80053ec: 45 60 00 07 be r11,r0,8005408 <timer_create+0xd8>
ptimer->inf.sigev_notify = evp->sigev_notify;
80053f0: 29 64 00 00 lw r4,(r11+0)
ptimer->inf.sigev_signo = evp->sigev_signo;
80053f4: 29 63 00 04 lw r3,(r11+4)
ptimer->inf.sigev_value = evp->sigev_value;
80053f8: 29 62 00 08 lw r2,(r11+8)
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
if ( evp != NULL ) {
ptimer->inf.sigev_notify = evp->sigev_notify;
80053fc: 58 24 00 40 sw (r1+64),r4
ptimer->inf.sigev_signo = evp->sigev_signo;
8005400: 58 23 00 44 sw (r1+68),r3
ptimer->inf.sigev_value = evp->sigev_value;
8005404: 58 22 00 48 sw (r1+72),r2
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
8005408: 28 23 00 08 lw r3,(r1+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
800540c: 29 84 00 1c lw r4,(r12+28)
}
ptimer->overrun = 0;
8005410: 58 20 00 68 sw (r1+104),r0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
8005414: 20 62 ff ff andi r2,r3,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8005418: b4 42 10 00 add r2,r2,r2
800541c: b4 42 10 00 add r2,r2,r2
ptimer->timer_data.it_value.tv_sec = 0;
8005420: 58 20 00 5c sw (r1+92),r0
ptimer->timer_data.it_value.tv_nsec = 0;
8005424: 58 20 00 60 sw (r1+96),r0
ptimer->timer_data.it_interval.tv_sec = 0;
8005428: 58 20 00 54 sw (r1+84),r0
ptimer->timer_data.it_interval.tv_nsec = 0;
800542c: 58 20 00 58 sw (r1+88),r0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8005430: 58 20 00 18 sw (r1+24),r0
the_watchdog->routine = routine;
8005434: 58 20 00 2c sw (r1+44),r0
the_watchdog->id = id;
8005438: 58 20 00 30 sw (r1+48),r0
the_watchdog->user_data = user_data;
800543c: 58 20 00 34 sw (r1+52),r0
8005440: b4 82 10 00 add r2,r4,r2
8005444: 58 41 00 00 sw (r2+0),r1
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
8005448: 58 20 00 0c sw (r1+12),r0
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
800544c: 59 a3 00 00 sw (r13+0),r3
_Thread_Enable_dispatch();
8005450: f8 00 0e 5f calli 8008dcc <_Thread_Enable_dispatch>
return 0;
8005454: 34 01 00 00 mvi r1,0
}
8005458: 2b 9d 00 04 lw ra,(sp+4)
800545c: 2b 8b 00 10 lw r11,(sp+16)
8005460: 2b 8c 00 0c lw r12,(sp+12)
8005464: 2b 8d 00 08 lw r13,(sp+8)
8005468: 37 9c 00 10 addi sp,sp,16
800546c: c3 a0 00 00 ret
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
8005470: f8 00 0e 57 calli 8008dcc <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
8005474: f8 00 28 d1 calli 800f7b8 <__errno>
8005478: 34 02 00 0b mvi r2,11
800547c: 58 22 00 00 sw (r1+0),r2
8005480: 34 01 ff ff mvi r1,-1
8005484: e3 ff ff f5 bi 8005458 <timer_create+0x128>
08003c2c <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
8003c2c: 37 9c ff c4 addi sp,sp,-60
8003c30: 5b 8b 00 18 sw (sp+24),r11
8003c34: 5b 8c 00 14 sw (sp+20),r12
8003c38: 5b 8d 00 10 sw (sp+16),r13
8003c3c: 5b 8e 00 0c sw (sp+12),r14
8003c40: 5b 8f 00 08 sw (sp+8),r15
8003c44: 5b 9d 00 04 sw (sp+4),ra
8003c48: b8 60 60 00 mv r12,r3
8003c4c: b8 20 70 00 mv r14,r1
8003c50: b8 40 58 00 mv r11,r2
8003c54: b8 80 68 00 mv r13,r4
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
8003c58: 44 60 00 1e be r3,r0,8003cd0 <timer_settime+0xa4> <== NEVER TAKEN
/*
* First, it verifies if the structure "value" is correct
* if the number of nanoseconds is not correct return EINVAL
*/
if ( !_Timespec_Is_valid( &(value->it_value) ) ) {
8003c5c: 34 61 00 08 addi r1,r3,8
8003c60: f8 00 0f d4 calli 8007bb0 <_Timespec_Is_valid>
8003c64: 44 20 00 1b be r1,r0,8003cd0 <timer_settime+0xa4>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
8003c68: b9 80 08 00 mv r1,r12
8003c6c: f8 00 0f d1 calli 8007bb0 <_Timespec_Is_valid>
8003c70: 44 20 00 18 be r1,r0,8003cd0 <timer_settime+0xa4>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
8003c74: 7d 62 00 00 cmpnei r2,r11,0
8003c78: 7d 61 00 04 cmpnei r1,r11,4
8003c7c: a0 41 08 00 and r1,r2,r1
8003c80: 5c 20 00 14 bne r1,r0,8003cd0 <timer_settime+0xa4> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
8003c84: 29 81 00 0c lw r1,(r12+12)
8003c88: 29 84 00 00 lw r4,(r12+0)
8003c8c: 29 83 00 04 lw r3,(r12+4)
8003c90: 29 82 00 08 lw r2,(r12+8)
8003c94: 5b 81 00 28 sw (sp+40),r1
8003c98: 5b 84 00 1c sw (sp+28),r4
8003c9c: 5b 83 00 20 sw (sp+32),r3
8003ca0: 5b 82 00 24 sw (sp+36),r2
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
8003ca4: 34 01 00 04 mvi r1,4
8003ca8: 45 61 00 5a be r11,r1,8003e10 <timer_settime+0x1e4>
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
8003cac: 78 03 08 02 mvhi r3,0x802
8003cb0: b8 60 08 00 mv r1,r3
8003cb4: 38 21 0b 84 ori r1,r1,0xb84
8003cb8: b9 c0 10 00 mv r2,r14
8003cbc: 37 83 00 3c addi r3,sp,60
8003cc0: f8 00 08 d7 calli 800601c <_Objects_Get>
8003cc4: b8 20 58 00 mv r11,r1
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
8003cc8: 2b 81 00 3c lw r1,(sp+60)
8003ccc: 44 20 00 0d be r1,r0,8003d00 <timer_settime+0xd4> <== ALWAYS TAKEN
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
8003cd0: f8 00 28 1a calli 800dd38 <__errno>
8003cd4: 34 02 00 16 mvi r2,22
8003cd8: 58 22 00 00 sw (r1+0),r2
8003cdc: 34 01 ff ff mvi r1,-1
}
8003ce0: 2b 9d 00 04 lw ra,(sp+4)
8003ce4: 2b 8b 00 18 lw r11,(sp+24)
8003ce8: 2b 8c 00 14 lw r12,(sp+20)
8003cec: 2b 8d 00 10 lw r13,(sp+16)
8003cf0: 2b 8e 00 0c lw r14,(sp+12)
8003cf4: 2b 8f 00 08 lw r15,(sp+8)
8003cf8: 37 9c 00 3c addi sp,sp,60
8003cfc: c3 a0 00 00 ret
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
8003d00: 2b 82 00 24 lw r2,(sp+36)
8003d04: 5c 41 00 03 bne r2,r1,8003d10 <timer_settime+0xe4>
8003d08: 2b 8e 00 28 lw r14,(sp+40)
8003d0c: 45 c2 00 62 be r14,r2,8003e94 <timer_settime+0x268>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
8003d10: b9 80 08 00 mv r1,r12
8003d14: f8 00 0f d4 calli 8007c64 <_Timespec_To_ticks>
8003d18: 59 61 00 64 sw (r11+100),r1
initial_period = _Timespec_To_ticks( &normalize.it_value );
8003d1c: 37 81 00 24 addi r1,sp,36
8003d20: f8 00 0f d1 calli 8007c64 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
8003d24: 29 63 00 08 lw r3,(r11+8)
8003d28: 78 04 08 00 mvhi r4,0x800
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
initial_period = _Timespec_To_ticks( &normalize.it_value );
8003d2c: b8 20 10 00 mv r2,r1
activated = _POSIX_Timer_Insert_helper(
8003d30: 38 84 3f 10 ori r4,r4,0x3f10
8003d34: 35 61 00 10 addi r1,r11,16
8003d38: b9 60 28 00 mv r5,r11
8003d3c: f8 00 1a de calli 800a8b4 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
8003d40: 44 20 00 2a be r1,r0,8003de8 <timer_settime+0x1bc>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
8003d44: 45 a0 00 09 be r13,r0,8003d68 <timer_settime+0x13c>
*ovalue = ptimer->timer_data;
8003d48: 29 61 00 54 lw r1,(r11+84)
8003d4c: 59 a1 00 00 sw (r13+0),r1
8003d50: 29 61 00 58 lw r1,(r11+88)
8003d54: 59 a1 00 04 sw (r13+4),r1
8003d58: 29 61 00 5c lw r1,(r11+92)
8003d5c: 59 a1 00 08 sw (r13+8),r1
8003d60: 29 61 00 60 lw r1,(r11+96)
8003d64: 59 a1 00 0c sw (r13+12),r1
ptimer->timer_data = normalize;
8003d68: 2b 81 00 1c lw r1,(sp+28)
)
{
Timestamp_Control tod_as_timestamp;
Timestamp_Control *tod_as_timestamp_ptr;
tod_as_timestamp_ptr =
8003d6c: 78 02 08 02 mvhi r2,0x802
8003d70: 38 42 08 c8 ori r2,r2,0x8c8
8003d74: 59 61 00 54 sw (r11+84),r1
8003d78: 2b 81 00 20 lw r1,(sp+32)
8003d7c: 59 61 00 58 sw (r11+88),r1
8003d80: 2b 81 00 24 lw r1,(sp+36)
8003d84: 59 61 00 5c sw (r11+92),r1
8003d88: 2b 81 00 28 lw r1,(sp+40)
8003d8c: 59 61 00 60 sw (r11+96),r1
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
8003d90: 34 01 00 03 mvi r1,3
8003d94: 31 61 00 3c sb (r11+60),r1
8003d98: 37 81 00 2c addi r1,sp,44
8003d9c: f8 00 05 81 calli 80053a0 <_TOD_Get_with_nanoseconds>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
8003da0: 28 2d 00 00 lw r13,(r1+0)
8003da4: 28 2c 00 04 lw r12,(r1+4)
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
8003da8: 78 01 08 01 mvhi r1,0x801
8003dac: 38 21 e6 08 ori r1,r1,0xe608
8003db0: 28 24 00 00 lw r4,(r1+0)
8003db4: 34 03 00 00 mvi r3,0
8003db8: b9 a0 08 00 mv r1,r13
8003dbc: b9 80 10 00 mv r2,r12
8003dc0: f8 00 4e ab calli 801786c <__divdi3>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
8003dc4: 78 01 08 01 mvhi r1,0x801
8003dc8: 38 21 e6 08 ori r1,r1,0xe608
8003dcc: 28 24 00 00 lw r4,(r1+0)
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
8003dd0: 59 62 00 6c sw (r11+108),r2
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
8003dd4: 34 03 00 00 mvi r3,0
8003dd8: b9 a0 08 00 mv r1,r13
8003ddc: b9 80 10 00 mv r2,r12
8003de0: f8 00 50 a5 calli 8018074 <__moddi3>
8003de4: 59 62 00 70 sw (r11+112),r2
ptimer->timer_data = normalize;
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
_TOD_Get( &ptimer->time );
_Thread_Enable_dispatch();
8003de8: f8 00 0c 5b calli 8006f54 <_Thread_Enable_dispatch>
return 0;
8003dec: 34 01 00 00 mvi r1,0
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
8003df0: 2b 9d 00 04 lw ra,(sp+4)
8003df4: 2b 8b 00 18 lw r11,(sp+24)
8003df8: 2b 8c 00 14 lw r12,(sp+20)
8003dfc: 2b 8d 00 10 lw r13,(sp+16)
8003e00: 2b 8e 00 0c lw r14,(sp+12)
8003e04: 2b 8f 00 08 lw r15,(sp+8)
8003e08: 37 9c 00 3c addi sp,sp,60
8003e0c: c3 a0 00 00 ret
8003e10: 78 02 08 02 mvhi r2,0x802
8003e14: 38 42 08 c8 ori r2,r2,0x8c8
8003e18: 37 81 00 2c addi r1,sp,44
8003e1c: f8 00 05 61 calli 80053a0 <_TOD_Get_with_nanoseconds>
8003e20: 28 2f 00 00 lw r15,(r1+0)
8003e24: 28 2b 00 04 lw r11,(r1+4)
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
8003e28: 78 01 08 01 mvhi r1,0x801
8003e2c: 38 21 e6 08 ori r1,r1,0xe608
8003e30: 28 24 00 00 lw r4,(r1+0)
8003e34: 34 03 00 00 mvi r3,0
8003e38: b9 e0 08 00 mv r1,r15
8003e3c: b9 60 10 00 mv r2,r11
8003e40: f8 00 4e 8b calli 801786c <__divdi3>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
8003e44: 78 01 08 01 mvhi r1,0x801
8003e48: 38 21 e6 08 ori r1,r1,0xe608
8003e4c: 28 24 00 00 lw r4,(r1+0)
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
8003e50: 5b 82 00 34 sw (sp+52),r2
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
8003e54: b9 e0 08 00 mv r1,r15
8003e58: b9 60 10 00 mv r2,r11
8003e5c: 34 03 00 00 mvi r3,0
8003e60: f8 00 50 85 calli 8018074 <__moddi3>
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
8003e64: 37 8f 00 24 addi r15,sp,36
8003e68: 37 8b 00 34 addi r11,sp,52
8003e6c: 5b 82 00 38 sw (sp+56),r2
8003e70: b9 e0 08 00 mv r1,r15
8003e74: b9 60 10 00 mv r2,r11
8003e78: f8 00 0f 5a calli 8007be0 <_Timespec_Less_than>
8003e7c: 5c 20 ff 95 bne r1,r0,8003cd0 <timer_settime+0xa4> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
8003e80: b9 e0 10 00 mv r2,r15
8003e84: b9 60 08 00 mv r1,r11
8003e88: b9 e0 18 00 mv r3,r15
8003e8c: f8 00 0f 60 calli 8007c0c <_Timespec_Subtract>
8003e90: e3 ff ff 87 bi 8003cac <timer_settime+0x80>
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
8003e94: 35 61 00 10 addi r1,r11,16
8003e98: f8 00 10 96 calli 80080f0 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
8003e9c: 45 ae 00 09 be r13,r14,8003ec0 <timer_settime+0x294>
*ovalue = ptimer->timer_data;
8003ea0: 29 61 00 54 lw r1,(r11+84)
8003ea4: 59 a1 00 00 sw (r13+0),r1
8003ea8: 29 61 00 58 lw r1,(r11+88)
8003eac: 59 a1 00 04 sw (r13+4),r1
8003eb0: 29 61 00 5c lw r1,(r11+92)
8003eb4: 59 a1 00 08 sw (r13+8),r1
8003eb8: 29 61 00 60 lw r1,(r11+96)
8003ebc: 59 a1 00 0c sw (r13+12),r1
/* The new data are set */
ptimer->timer_data = normalize;
8003ec0: 2b 81 00 1c lw r1,(sp+28)
8003ec4: 59 61 00 54 sw (r11+84),r1
8003ec8: 2b 81 00 20 lw r1,(sp+32)
8003ecc: 59 61 00 58 sw (r11+88),r1
8003ed0: 2b 81 00 24 lw r1,(sp+36)
8003ed4: 59 61 00 5c sw (r11+92),r1
8003ed8: 2b 81 00 28 lw r1,(sp+40)
8003edc: 59 61 00 60 sw (r11+96),r1
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
8003ee0: 34 01 00 04 mvi r1,4
8003ee4: 31 61 00 3c sb (r11+60),r1
/* Returns with success */
_Thread_Enable_dispatch();
8003ee8: f8 00 0c 1b calli 8006f54 <_Thread_Enable_dispatch>
return 0;
8003eec: 34 01 00 00 mvi r1,0
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
8003ef0: 2b 9d 00 04 lw ra,(sp+4)
8003ef4: 2b 8b 00 18 lw r11,(sp+24)
8003ef8: 2b 8c 00 14 lw r12,(sp+20)
8003efc: 2b 8d 00 10 lw r13,(sp+16)
8003f00: 2b 8e 00 0c lw r14,(sp+12)
8003f04: 2b 8f 00 08 lw r15,(sp+8)
8003f08: 37 9c 00 3c addi sp,sp,60
8003f0c: c3 a0 00 00 ret
08003d74 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
8003d74: 37 9c ff e4 addi sp,sp,-28
8003d78: 5b 8b 00 14 sw (sp+20),r11
8003d7c: 5b 8c 00 10 sw (sp+16),r12
8003d80: 5b 8d 00 0c sw (sp+12),r13
8003d84: 5b 8e 00 08 sw (sp+8),r14
8003d88: 5b 9d 00 04 sw (sp+4),ra
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
8003d8c: 78 0b 08 01 mvhi r11,0x801
8003d90: 39 6b 81 e0 ori r11,r11,0x81e0
8003d94: 29 62 00 1c lw r2,(r11+28)
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
8003d98: b8 20 60 00 mv r12,r1
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
8003d9c: 44 40 00 55 be r2,r0,8003ef0 <ualarm+0x17c>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
8003da0: b9 60 08 00 mv r1,r11
8003da4: f8 00 10 2a calli 8007e4c <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
8003da8: 34 21 ff fe addi r1,r1,-2
8003dac: 34 02 00 01 mvi r2,1
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
8003db0: 34 0d 00 00 mvi r13,0
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
8003db4: 54 22 00 24 bgu r1,r2,8003e44 <ualarm+0xd0> <== NEVER TAKEN
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
8003db8: 29 64 00 14 lw r4,(r11+20)
8003dbc: 29 61 00 0c lw r1,(r11+12)
8003dc0: 29 63 00 18 lw r3,(r11+24)
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
8003dc4: 37 82 00 18 addi r2,sp,24
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
8003dc8: b4 81 08 00 add r1,r4,r1
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
8003dcc: c8 23 08 00 sub r1,r1,r3
8003dd0: f8 00 0e 98 calli 8007830 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
8003dd4: 2b 85 00 18 lw r5,(sp+24)
remaining += tp.tv_nsec / 1000;
8003dd8: 2b 81 00 1c lw r1,(sp+28)
8003ddc: 34 02 03 e8 mvi r2,1000
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
8003de0: b4 a5 18 00 add r3,r5,r5
8003de4: b4 63 18 00 add r3,r3,r3
8003de8: b4 63 18 00 add r3,r3,r3
8003dec: b4 63 20 00 add r4,r3,r3
8003df0: b4 84 20 00 add r4,r4,r4
8003df4: b4 84 20 00 add r4,r4,r4
8003df8: b4 84 20 00 add r4,r4,r4
8003dfc: b4 84 20 00 add r4,r4,r4
8003e00: c8 83 20 00 sub r4,r4,r3
8003e04: b4 84 18 00 add r3,r4,r4
8003e08: b4 63 18 00 add r3,r3,r3
8003e0c: b4 63 18 00 add r3,r3,r3
8003e10: b4 63 18 00 add r3,r3,r3
8003e14: b4 63 18 00 add r3,r3,r3
8003e18: b4 63 18 00 add r3,r3,r3
8003e1c: c8 64 18 00 sub r3,r3,r4
8003e20: b4 65 68 00 add r13,r3,r5
8003e24: b5 ad 68 00 add r13,r13,r13
8003e28: b5 ad 68 00 add r13,r13,r13
8003e2c: b5 ad 68 00 add r13,r13,r13
8003e30: b5 ad 68 00 add r13,r13,r13
8003e34: b5 ad 68 00 add r13,r13,r13
8003e38: b5 ad 68 00 add r13,r13,r13
remaining += tp.tv_nsec / 1000;
8003e3c: f8 00 44 6e calli 8014ff4 <__divsi3>
8003e40: b4 2d 68 00 add r13,r1,r13
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
8003e44: 45 80 00 23 be r12,r0,8003ed0 <ualarm+0x15c>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
8003e48: 78 01 08 01 mvhi r1,0x801
8003e4c: 38 21 62 98 ori r1,r1,0x6298
8003e50: 28 22 00 00 lw r2,(r1+0)
8003e54: b9 80 08 00 mv r1,r12
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ticks = _Timespec_To_ticks( &tp );
8003e58: 37 8e 00 18 addi r14,sp,24
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
8003e5c: f8 00 44 bf calli 8015158 <__udivsi3>
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
8003e60: 78 03 08 01 mvhi r3,0x801
8003e64: 38 63 62 98 ori r3,r3,0x6298
8003e68: 28 62 00 00 lw r2,(r3+0)
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
8003e6c: 5b 81 00 18 sw (sp+24),r1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
8003e70: b9 80 08 00 mv r1,r12
8003e74: f8 00 44 c9 calli 8015198 <__umodsi3>
8003e78: b4 21 10 00 add r2,r1,r1
8003e7c: b4 42 10 00 add r2,r2,r2
8003e80: b4 42 10 00 add r2,r2,r2
8003e84: b4 42 18 00 add r3,r2,r2
8003e88: b4 63 18 00 add r3,r3,r3
8003e8c: b4 43 10 00 add r2,r2,r3
8003e90: b4 42 18 00 add r3,r2,r2
8003e94: b4 63 18 00 add r3,r3,r3
8003e98: b4 43 10 00 add r2,r2,r3
8003e9c: b4 42 18 00 add r3,r2,r2
8003ea0: b4 63 18 00 add r3,r3,r3
8003ea4: b4 43 18 00 add r3,r2,r3
ticks = _Timespec_To_ticks( &tp );
8003ea8: b9 c0 08 00 mv r1,r14
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
8003eac: 5b 83 00 1c sw (sp+28),r3
ticks = _Timespec_To_ticks( &tp );
8003eb0: f8 00 0e 86 calli 80078c8 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
8003eb4: b9 c0 08 00 mv r1,r14
8003eb8: f8 00 0e 84 calli 80078c8 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
8003ebc: 59 61 00 0c sw (r11+12),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8003ec0: 78 01 08 01 mvhi r1,0x801
8003ec4: b9 60 10 00 mv r2,r11
8003ec8: 38 21 79 e0 ori r1,r1,0x79e0
8003ecc: f8 00 0f 7a calli 8007cb4 <_Watchdog_Insert>
}
return remaining;
}
8003ed0: b9 a0 08 00 mv r1,r13
8003ed4: 2b 9d 00 04 lw ra,(sp+4)
8003ed8: 2b 8b 00 14 lw r11,(sp+20)
8003edc: 2b 8c 00 10 lw r12,(sp+16)
8003ee0: 2b 8d 00 0c lw r13,(sp+12)
8003ee4: 2b 8e 00 08 lw r14,(sp+8)
8003ee8: 37 9c 00 1c addi sp,sp,28
8003eec: c3 a0 00 00 ret
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
8003ef0: 78 01 08 00 mvhi r1,0x800
8003ef4: 38 21 3d 2c ori r1,r1,0x3d2c
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8003ef8: 59 60 00 08 sw (r11+8),r0
the_watchdog->routine = routine;
8003efc: 59 61 00 1c sw (r11+28),r1
the_watchdog->id = id;
8003f00: 59 60 00 20 sw (r11+32),r0
the_watchdog->user_data = user_data;
8003f04: 59 60 00 24 sw (r11+36),r0
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
8003f08: 34 0d 00 00 mvi r13,0
8003f0c: e3 ff ff ce bi 8003e44 <ualarm+0xd0>