RTEMS 4.11Annotated Report
Mon Jan 10 11:21:23 2011
080036c4 <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
80036c4: 37 9c ff f4 addi sp,sp,-12
80036c8: 5b 8b 00 0c sw (sp+12),r11
80036cc: 5b 8c 00 08 sw (sp+8),r12
80036d0: 5b 9d 00 04 sw (sp+4),ra
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
80036d4: 78 01 08 01 mvhi r1,0x801
80036d8: 38 21 4a 30 ori r1,r1,0x4a30
80036dc: 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 );
80036e0: 78 0c 08 01 mvhi r12,0x801
80036e4: 39 8c 4a 34 ori r12,r12,0x4a34
80036e8: 45 6c 00 05 be r11,r12,80036fc <_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)();
80036ec: 29 61 00 08 lw r1,(r11+8)
80036f0: 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 ) {
80036f4: 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 );
80036f8: 5d 6c ff fd bne r11,r12,80036ec <_API_extensions_Run_postdriver+0x28>
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
80036fc: 2b 9d 00 04 lw ra,(sp+4)
8003700: 2b 8b 00 0c lw r11,(sp+12)
8003704: 2b 8c 00 08 lw r12,(sp+8)
8003708: 37 9c 00 0c addi sp,sp,12
800370c: c3 a0 00 00 ret
08003710 <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
8003710: 37 9c ff f0 addi sp,sp,-16
8003714: 5b 8b 00 10 sw (sp+16),r11
8003718: 5b 8c 00 0c sw (sp+12),r12
800371c: 5b 8d 00 08 sw (sp+8),r13
8003720: 5b 9d 00 04 sw (sp+4),ra
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
8003724: 78 01 08 01 mvhi r1,0x801
8003728: 38 21 4a 30 ori r1,r1,0x4a30
800372c: 28 2b 00 00 lw r11,(r1+0)
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
8003730: 78 0c 08 01 mvhi r12,0x801
8003734: 39 8c 4a 34 ori r12,r12,0x4a34
8003738: 45 6c 00 08 be r11,r12,8003758 <_API_extensions_Run_postswitch+0x48><== NEVER TAKEN
800373c: 78 0d 08 01 mvhi r13,0x801
8003740: 39 ad 4d 74 ori r13,r13,0x4d74
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
8003744: 29 62 00 0c lw r2,(r11+12)
8003748: 29 a1 00 0c lw r1,(r13+12)
800374c: d8 40 00 00 call r2
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 ) {
8003750: 29 6b 00 00 lw r11,(r11+0)
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
8003754: 5d 6c ff fc bne r11,r12,8003744 <_API_extensions_Run_postswitch+0x34>
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
8003758: 2b 9d 00 04 lw ra,(sp+4)
800375c: 2b 8b 00 10 lw r11,(sp+16)
8003760: 2b 8c 00 0c lw r12,(sp+12)
8003764: 2b 8d 00 08 lw r13,(sp+8)
8003768: 37 9c 00 10 addi sp,sp,16
800376c: c3 a0 00 00 ret
08006464 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
8006464: 37 9c ff f4 addi sp,sp,-12
8006468: 5b 8b 00 0c sw (sp+12),r11
800646c: 5b 8c 00 08 sw (sp+8),r12
8006470: 5b 9d 00 04 sw (sp+4),ra
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
8006474: 78 02 08 01 mvhi r2,0x801
8006478: 38 42 9d 44 ori r2,r2,0x9d44
800647c: 28 43 00 0c lw r3,(r2+12)
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
8006480: 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 );
8006484: 90 00 08 00 rcsr r1,IE
8006488: 34 02 ff fe mvi r2,-2
800648c: a0 22 10 00 and r2,r1,r2
8006490: d0 02 00 00 wcsr IE,r2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
8006494: 29 62 00 44 lw r2,(r11+68)
8006498: 44 40 00 2f be r2,r0,8006554 <_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 ) {
800649c: 34 04 00 01 mvi r4,1
80064a0: 44 44 00 22 be r2,r4,8006528 <_CORE_RWLock_Release+0xc4>
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
80064a4: 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;
80064a8: 59 60 00 44 sw (r11+68),r0
_ISR_Enable( level );
80064ac: d0 01 00 00 wcsr IE,r1
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
80064b0: b9 60 08 00 mv r1,r11
80064b4: f8 00 07 e8 calli 8008454 <_Thread_queue_Dequeue>
if ( next ) {
80064b8: 44 20 00 16 be r1,r0,8006510 <_CORE_RWLock_Release+0xac>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
80064bc: 28 22 00 30 lw r2,(r1+48)
80064c0: 34 01 00 01 mvi r1,1
80064c4: 44 41 00 2d be r2,r1,8006578 <_CORE_RWLock_Release+0x114>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
80064c8: 29 62 00 48 lw r2,(r11+72)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
80064cc: 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 ||
80064d0: 34 0c 00 01 mvi r12,1
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
80064d4: 34 41 00 01 addi r1,r2,1
80064d8: 59 61 00 48 sw (r11+72),r1
80064dc: e0 00 00 07 bi 80064f8 <_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 ||
80064e0: 28 63 00 30 lw r3,(r3+48)
80064e4: 44 6c 00 0b be r3,r12,8006510 <_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;
80064e8: 29 63 00 48 lw r3,(r11+72)
80064ec: 34 63 00 01 addi r3,r3,1
80064f0: 59 63 00 48 sw (r11+72),r3
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
80064f4: f8 00 09 00 calli 80088f4 <_Thread_queue_Extract>
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
80064f8: b9 60 08 00 mv r1,r11
80064fc: f8 00 09 51 calli 8008a40 <_Thread_queue_First>
8006500: 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 );
8006504: b8 20 10 00 mv r2,r1
8006508: 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 ||
800650c: 5c 60 ff f5 bne r3,r0,80064e0 <_CORE_RWLock_Release+0x7c>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
8006510: 34 01 00 00 mvi r1,0
8006514: 2b 9d 00 04 lw ra,(sp+4)
8006518: 2b 8b 00 0c lw r11,(sp+12)
800651c: 2b 8c 00 08 lw r12,(sp+8)
8006520: 37 9c 00 0c addi sp,sp,12
8006524: 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;
8006528: 29 62 00 48 lw r2,(r11+72)
800652c: 34 42 ff ff addi r2,r2,-1
8006530: 59 62 00 48 sw (r11+72),r2
if ( the_rwlock->number_of_readers != 0 ) {
8006534: 44 40 ff dc be r2,r0,80064a4 <_CORE_RWLock_Release+0x40>
/* must be unlocked again */
_ISR_Enable( level );
8006538: d0 01 00 00 wcsr IE,r1
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
800653c: 34 01 00 00 mvi r1,0
8006540: 2b 9d 00 04 lw ra,(sp+4)
8006544: 2b 8b 00 0c lw r11,(sp+12)
8006548: 2b 8c 00 08 lw r12,(sp+8)
800654c: 37 9c 00 0c addi sp,sp,12
8006550: 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 );
8006554: d0 01 00 00 wcsr IE,r1
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
8006558: 34 01 00 02 mvi r1,2
800655c: 58 61 00 34 sw (r3+52),r1
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
8006560: 34 01 00 00 mvi r1,0
8006564: 2b 9d 00 04 lw ra,(sp+4)
8006568: 2b 8b 00 0c lw r11,(sp+12)
800656c: 2b 8c 00 08 lw r12,(sp+8)
8006570: 37 9c 00 0c addi sp,sp,12
8006574: 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;
8006578: 34 01 00 02 mvi r1,2
800657c: 59 61 00 44 sw (r11+68),r1
return CORE_RWLOCK_SUCCESSFUL;
8006580: e3 ff ff e4 bi 8006510 <_CORE_RWLock_Release+0xac>
08006584 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
8006584: 37 9c ff f8 addi sp,sp,-8
8006588: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
800658c: 37 82 00 08 addi r2,sp,8
8006590: f8 00 06 b1 calli 8008054 <_Thread_Get>
switch ( location ) {
8006594: 2b 82 00 08 lw r2,(sp+8)
8006598: 5c 40 00 07 bne r2,r0,80065b4 <_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 );
800659c: f8 00 09 67 calli 8008b38 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
80065a0: 78 01 08 01 mvhi r1,0x801
80065a4: 38 21 98 78 ori r1,r1,0x9878
80065a8: 28 22 00 00 lw r2,(r1+0)
80065ac: 34 42 ff ff addi r2,r2,-1
80065b0: 58 22 00 00 sw (r1+0),r2
_Thread_Unnest_dispatch();
break;
}
}
80065b4: 2b 9d 00 04 lw ra,(sp+4)
80065b8: 37 9c 00 08 addi sp,sp,8
80065bc: c3 a0 00 00 ret
080153a0 <_CORE_message_queue_Broadcast>:
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
80153a0: 37 9c ff e4 addi sp,sp,-28
80153a4: 5b 8b 00 1c sw (sp+28),r11
80153a8: 5b 8c 00 18 sw (sp+24),r12
80153ac: 5b 8d 00 14 sw (sp+20),r13
80153b0: 5b 8e 00 10 sw (sp+16),r14
80153b4: 5b 8f 00 0c sw (sp+12),r15
80153b8: 5b 90 00 08 sw (sp+8),r16
80153bc: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
80153c0: 28 24 00 4c lw r4,(r1+76)
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
80153c4: b8 20 68 00 mv r13,r1
80153c8: b8 60 60 00 mv r12,r3
80153cc: b8 40 78 00 mv r15,r2
80153d0: b8 c0 80 00 mv r16,r6
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
80153d4: 34 01 00 01 mvi r1,1
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
80153d8: 54 64 00 06 bgu r3,r4,80153f0 <_CORE_message_queue_Broadcast+0x50><== NEVER TAKEN
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
80153dc: 29 a1 00 48 lw r1,(r13+72)
80153e0: 34 0e 00 00 mvi r14,0
80153e4: 44 20 00 11 be r1,r0,8015428 <_CORE_message_queue_Broadcast+0x88>
*count = 0;
80153e8: 58 c0 00 00 sw (r6+0),r0
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
80153ec: 34 01 00 00 mvi r1,0
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
80153f0: 2b 9d 00 04 lw ra,(sp+4)
80153f4: 2b 8b 00 1c lw r11,(sp+28)
80153f8: 2b 8c 00 18 lw r12,(sp+24)
80153fc: 2b 8d 00 14 lw r13,(sp+20)
8015400: 2b 8e 00 10 lw r14,(sp+16)
8015404: 2b 8f 00 0c lw r15,(sp+12)
8015408: 2b 90 00 08 lw r16,(sp+8)
801540c: 37 9c 00 1c addi sp,sp,28
8015410: c3 a0 00 00 ret
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
8015414: 29 61 00 2c lw r1,(r11+44)
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
8015418: 35 ce 00 01 addi r14,r14,1
801541c: f8 00 2b b9 calli 8020300 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
8015420: 29 61 00 28 lw r1,(r11+40)
8015424: 58 2c 00 00 sw (r1+0),r12
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
8015428: b9 a0 08 00 mv r1,r13
801542c: f8 00 0d 79 calli 8018a10 <_Thread_queue_Dequeue>
8015430: b8 20 58 00 mv r11,r1
8015434: b9 e0 10 00 mv r2,r15
8015438: b9 80 18 00 mv r3,r12
801543c: 5c 20 ff f6 bne r1,r0,8015414 <_CORE_message_queue_Broadcast+0x74>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
8015440: 5a 0e 00 00 sw (r16+0),r14
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
8015444: 34 01 00 00 mvi r1,0
8015448: e3 ff ff ea bi 80153f0 <_CORE_message_queue_Broadcast+0x50>
0800ed70 <_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
)
{
800ed70: 37 9c ff e4 addi sp,sp,-28
800ed74: 5b 8b 00 1c sw (sp+28),r11
800ed78: 5b 8c 00 18 sw (sp+24),r12
800ed7c: 5b 8d 00 14 sw (sp+20),r13
800ed80: 5b 8e 00 10 sw (sp+16),r14
800ed84: 5b 8f 00 0c sw (sp+12),r15
800ed88: 5b 90 00 08 sw (sp+8),r16
800ed8c: 5b 9d 00 04 sw (sp+4),ra
800ed90: b8 20 58 00 mv r11,r1
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
800ed94: 58 20 00 48 sw (r1+72),r0
the_message_queue->maximum_message_size = maximum_message_size;
800ed98: 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;
800ed9c: 58 20 00 60 sw (r1+96),r0
the_message_queue->notify_argument = the_argument;
800eda0: 58 20 00 64 sw (r1+100),r0
)
{
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
800eda4: 59 63 00 44 sw (r11+68),r3
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
800eda8: 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
)
{
800edac: b8 60 70 00 mv r14,r3
800edb0: b8 40 80 00 mv r16,r2
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
800edb4: b8 80 60 00 mv r12,r4
800edb8: 44 20 00 06 be r1,r0,800edd0 <_CORE_message_queue_Initialize+0x60>
allocated_message_size += sizeof(uint32_t);
800edbc: 34 8c 00 04 addi r12,r4,4
allocated_message_size &= ~(sizeof(uint32_t) - 1);
800edc0: 34 01 ff fc mvi r1,-4
800edc4: a1 81 60 00 and r12,r12,r1
}
if (allocated_message_size < maximum_message_size)
return false;
800edc8: 34 0d 00 00 mvi r13,0
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
allocated_message_size += sizeof(uint32_t);
allocated_message_size &= ~(sizeof(uint32_t) - 1);
}
if (allocated_message_size < maximum_message_size)
800edcc: 54 8c 00 1c bgu r4,r12,800ee3c <_CORE_message_queue_Initialize+0xcc><== NEVER TAKEN
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
800edd0: 35 8f 00 14 addi r15,r12,20
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
800edd4: b9 e0 08 00 mv r1,r15
800edd8: b9 c0 10 00 mv r2,r14
800eddc: f8 00 5e 54 calli 802672c <__mulsi3>
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
800ede0: 34 0d 00 00 mvi r13,0
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
800ede4: 55 81 00 16 bgu r12,r1,800ee3c <_CORE_message_queue_Initialize+0xcc><== NEVER TAKEN
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
800ede8: f8 00 0e f8 calli 80129c8 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
800edec: 59 61 00 5c sw (r11+92),r1
_Workspace_Allocate( message_buffering_required );
800edf0: b8 20 18 00 mv r3,r1
if (the_message_queue->message_buffers == 0)
800edf4: 44 20 00 12 be r1,r0,800ee3c <_CORE_message_queue_Initialize+0xcc>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
800edf8: b8 60 10 00 mv r2,r3
800edfc: 35 61 00 68 addi r1,r11,104
800ee00: b9 c0 18 00 mv r3,r14
800ee04: b9 e0 20 00 mv r4,r15
800ee08: f8 00 1a 67 calli 80157a4 <_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 );
800ee0c: 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 );
800ee10: 35 61 00 50 addi r1,r11,80
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
800ee14: 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;
800ee18: 59 62 00 50 sw (r11+80),r2
head->previous = NULL;
800ee1c: 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(
800ee20: 2a 02 00 00 lw r2,(r16+0)
800ee24: b9 60 08 00 mv r1,r11
800ee28: 34 03 00 80 mvi r3,128
800ee2c: 64 42 00 01 cmpei r2,r2,1
800ee30: 34 04 00 06 mvi r4,6
800ee34: f8 00 0b 88 calli 8011c54 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
800ee38: 34 0d 00 01 mvi r13,1
}
800ee3c: b9 a0 08 00 mv r1,r13
800ee40: 2b 9d 00 04 lw ra,(sp+4)
800ee44: 2b 8b 00 1c lw r11,(sp+28)
800ee48: 2b 8c 00 18 lw r12,(sp+24)
800ee4c: 2b 8d 00 14 lw r13,(sp+20)
800ee50: 2b 8e 00 10 lw r14,(sp+16)
800ee54: 2b 8f 00 0c lw r15,(sp+12)
800ee58: 2b 90 00 08 lw r16,(sp+8)
800ee5c: 37 9c 00 1c addi sp,sp,28
800ee60: c3 a0 00 00 ret
08003a88 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
8003a88: 37 9c ff e4 addi sp,sp,-28
8003a8c: 5b 8b 00 18 sw (sp+24),r11
8003a90: 5b 8c 00 14 sw (sp+20),r12
8003a94: 5b 8d 00 10 sw (sp+16),r13
8003a98: 5b 8e 00 0c sw (sp+12),r14
8003a9c: 5b 8f 00 08 sw (sp+8),r15
8003aa0: 5b 9d 00 04 sw (sp+4),ra
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
8003aa4: 78 0b 08 01 mvhi r11,0x801
8003aa8: 39 6b 48 a8 ori r11,r11,0x48a8
8003aac: 29 66 00 00 lw r6,(r11+0)
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
8003ab0: 5b 85 00 1c sw (sp+28),r5
8003ab4: b8 20 60 00 mv r12,r1
8003ab8: b8 40 78 00 mv r15,r2
8003abc: b8 80 70 00 mv r14,r4
8003ac0: 20 6d 00 ff andi r13,r3,0xff
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
8003ac4: 44 c0 00 02 be r6,r0,8003acc <_CORE_mutex_Seize+0x44>
8003ac8: 5d a0 00 15 bne r13,r0,8003b1c <_CORE_mutex_Seize+0x94> <== ALWAYS TAKEN
8003acc: b9 80 08 00 mv r1,r12
8003ad0: 37 82 00 1c addi r2,sp,28
8003ad4: f8 00 18 ec calli 8009e84 <_CORE_mutex_Seize_interrupt_trylock>
8003ad8: 44 20 00 09 be r1,r0,8003afc <_CORE_mutex_Seize+0x74>
8003adc: 5d a0 00 19 bne r13,r0,8003b40 <_CORE_mutex_Seize+0xb8>
8003ae0: 2b 81 00 1c lw r1,(sp+28)
8003ae4: d0 01 00 00 wcsr IE,r1
8003ae8: 78 01 08 01 mvhi r1,0x801
8003aec: 38 21 4d 74 ori r1,r1,0x4d74
8003af0: 28 21 00 0c lw r1,(r1+12)
8003af4: 34 02 00 01 mvi r2,1
8003af8: 58 22 00 34 sw (r1+52),r2
}
8003afc: 2b 9d 00 04 lw ra,(sp+4)
8003b00: 2b 8b 00 18 lw r11,(sp+24)
8003b04: 2b 8c 00 14 lw r12,(sp+20)
8003b08: 2b 8d 00 10 lw r13,(sp+16)
8003b0c: 2b 8e 00 0c lw r14,(sp+12)
8003b10: 2b 8f 00 08 lw r15,(sp+8)
8003b14: 37 9c 00 1c addi sp,sp,28
8003b18: c3 a0 00 00 ret
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
8003b1c: 78 01 08 01 mvhi r1,0x801
8003b20: 38 21 4a 20 ori r1,r1,0x4a20
8003b24: 28 21 00 00 lw r1,(r1+0)
8003b28: 34 02 00 01 mvi r2,1
8003b2c: 50 41 ff e8 bgeu r2,r1,8003acc <_CORE_mutex_Seize+0x44>
8003b30: 34 01 00 00 mvi r1,0
8003b34: 34 02 00 00 mvi r2,0
8003b38: 34 03 00 12 mvi r3,18
8003b3c: f8 00 02 31 calli 8004400 <_Internal_error_Occurred>
8003b40: 78 01 08 01 mvhi r1,0x801
8003b44: 29 62 00 00 lw r2,(r11+0)
8003b48: 38 21 4d 74 ori r1,r1,0x4d74
8003b4c: 28 21 00 0c lw r1,(r1+12)
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;
8003b50: 34 03 00 01 mvi r3,1
8003b54: 59 83 00 30 sw (r12+48),r3
8003b58: 34 42 00 01 addi r2,r2,1
8003b5c: 58 2c 00 44 sw (r1+68),r12
8003b60: 58 2f 00 20 sw (r1+32),r15
8003b64: 59 62 00 00 sw (r11+0),r2
8003b68: 2b 81 00 1c lw r1,(sp+28)
8003b6c: d0 01 00 00 wcsr IE,r1
8003b70: b9 80 08 00 mv r1,r12
8003b74: b9 c0 10 00 mv r2,r14
8003b78: fb ff ff a3 calli 8003a04 <_CORE_mutex_Seize_interrupt_blocking>
}
8003b7c: 2b 9d 00 04 lw ra,(sp+4)
8003b80: 2b 8b 00 18 lw r11,(sp+24)
8003b84: 2b 8c 00 14 lw r12,(sp+20)
8003b88: 2b 8d 00 10 lw r13,(sp+16)
8003b8c: 2b 8e 00 0c lw r14,(sp+12)
8003b90: 2b 8f 00 08 lw r15,(sp+8)
8003b94: 37 9c 00 1c addi sp,sp,28
8003b98: c3 a0 00 00 ret
08003d08 <_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
)
{
8003d08: 37 9c ff f8 addi sp,sp,-8
8003d0c: 5b 8b 00 08 sw (sp+8),r11
8003d10: 5b 9d 00 04 sw (sp+4),ra
8003d14: 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)) ) {
8003d18: f8 00 07 f9 calli 8005cfc <_Thread_queue_Dequeue>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
8003d1c: 34 02 00 00 mvi r2,0
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
8003d20: 44 20 00 06 be r1,r0,8003d38 <_CORE_semaphore_Surrender+0x30>
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
8003d24: b8 40 08 00 mv r1,r2
8003d28: 2b 9d 00 04 lw ra,(sp+4)
8003d2c: 2b 8b 00 08 lw r11,(sp+8)
8003d30: 37 9c 00 08 addi sp,sp,8
8003d34: 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 );
8003d38: 90 00 08 00 rcsr r1,IE
8003d3c: 34 02 ff fe mvi r2,-2
8003d40: a0 22 10 00 and r2,r1,r2
8003d44: d0 02 00 00 wcsr IE,r2
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
8003d48: 29 63 00 48 lw r3,(r11+72)
8003d4c: 29 64 00 40 lw r4,(r11+64)
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
8003d50: 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 )
8003d54: 50 64 00 04 bgeu r3,r4,8003d64 <_CORE_semaphore_Surrender+0x5c><== NEVER TAKEN
the_semaphore->count += 1;
8003d58: 34 63 00 01 addi r3,r3,1
8003d5c: 59 63 00 48 sw (r11+72),r3
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
8003d60: 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 );
8003d64: d0 01 00 00 wcsr IE,r1
}
return status;
}
8003d68: b8 40 08 00 mv r1,r2
8003d6c: 2b 9d 00 04 lw ra,(sp+4)
8003d70: 2b 8b 00 08 lw r11,(sp+8)
8003d74: 37 9c 00 08 addi sp,sp,8
8003d78: c3 a0 00 00 ret
08009de8 <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
8009de8: 37 9c ff f0 addi sp,sp,-16
8009dec: 5b 8b 00 10 sw (sp+16),r11
8009df0: 5b 8c 00 0c sw (sp+12),r12
8009df4: 5b 8d 00 08 sw (sp+8),r13
8009df8: 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;
8009dfc: 58 20 00 04 sw (r1+4),r0
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
8009e00: b8 20 58 00 mv r11,r1
8009e04: 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 );
8009e08: 34 2d 00 04 addi r13,r1,4
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
8009e0c: 44 60 00 10 be r3,r0,8009e4c <_Chain_Initialize+0x64> <== NEVER TAKEN
8009e10: 34 63 ff ff addi r3,r3,-1
8009e14: 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;
8009e18: 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;
8009e1c: b9 60 30 00 mv r6,r11
8009e20: e0 00 00 04 bi 8009e30 <_Chain_Initialize+0x48>
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
8009e24: b8 a0 30 00 mv r6,r5
8009e28: 34 63 ff ff addi r3,r3,-1
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
8009e2c: b8 e0 28 00 mv r5,r7
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
current->next = next;
8009e30: 58 c5 00 00 sw (r6+0),r5
next->previous = current;
8009e34: 58 a6 00 04 sw (r5+4),r6
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
8009e38: b4 a4 38 00 add r7,r5,r4
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
8009e3c: 5c 60 ff fa bne r3,r0,8009e24 <_Chain_Initialize+0x3c>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
8009e40: b8 80 08 00 mv r1,r4
8009e44: f8 00 21 0c calli 8012274 <__mulsi3>
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
8009e48: b5 81 08 00 add r1,r12,r1
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
8009e4c: 58 2d 00 00 sw (r1+0),r13
tail->previous = current;
8009e50: 59 61 00 08 sw (r11+8),r1
}
8009e54: 2b 9d 00 04 lw ra,(sp+4)
8009e58: 2b 8b 00 10 lw r11,(sp+16)
8009e5c: 2b 8c 00 0c lw r12,(sp+12)
8009e60: 2b 8d 00 08 lw r13,(sp+8)
8009e64: 37 9c 00 10 addi sp,sp,16
8009e68: c3 a0 00 00 ret
0800e0f0 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
800e0f0: 37 9c ff f8 addi sp,sp,-8
800e0f4: 5b 8b 00 08 sw (sp+8),r11
800e0f8: 5b 9d 00 04 sw (sp+4),ra
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
800e0fc: 28 25 01 1c lw r5,(r1+284)
option_set = (rtems_option) the_thread->Wait.option;
800e100: 28 28 00 30 lw r8,(r1+48)
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
800e104: b8 20 58 00 mv r11,r1
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
800e108: 90 00 08 00 rcsr r1,IE
800e10c: 34 07 ff fe mvi r7,-2
800e110: a0 27 38 00 and r7,r1,r7
800e114: d0 07 00 00 wcsr IE,r7
pending_events = api->pending_events;
800e118: 28 a6 00 00 lw r6,(r5+0)
event_condition = (rtems_event_set) the_thread->Wait.count;
800e11c: 29 64 00 24 lw r4,(r11+36)
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 );
800e120: a0 86 10 00 and r2,r4,r6
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
800e124: 44 40 00 27 be r2,r0,800e1c0 <_Event_Surrender+0xd0>
/*
* 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() &&
800e128: 78 03 08 01 mvhi r3,0x801
800e12c: 38 63 ad ec ori r3,r3,0xadec
800e130: 28 69 00 08 lw r9,(r3+8)
800e134: 45 20 00 03 be r9,r0,800e140 <_Event_Surrender+0x50>
800e138: 28 63 00 0c lw r3,(r3+12)
800e13c: 45 63 00 31 be r11,r3,800e200 <_Event_Surrender+0x110>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
800e140: 29 63 00 10 lw r3,(r11+16)
800e144: 20 63 01 00 andi r3,r3,0x100
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
800e148: 44 60 00 19 be r3,r0,800e1ac <_Event_Surrender+0xbc>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
800e14c: 44 82 00 03 be r4,r2,800e158 <_Event_Surrender+0x68>
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_any (
rtems_option option_set
)
{
return (option_set & RTEMS_EVENT_ANY) ? true : false;
800e150: 21 08 00 02 andi r8,r8,0x2
800e154: 45 00 00 16 be r8,r0,800e1ac <_Event_Surrender+0xbc> <== 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) );
800e158: a4 40 18 00 not r3,r2
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800e15c: 29 64 00 28 lw r4,(r11+40)
800e160: a0 66 30 00 and r6,r3,r6
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
800e164: 58 a6 00 00 sw (r5+0),r6
the_thread->Wait.count = 0;
800e168: 59 60 00 24 sw (r11+36),r0
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800e16c: 58 82 00 00 sw (r4+0),r2
_ISR_Flash( level );
800e170: d0 01 00 00 wcsr IE,r1
800e174: d0 07 00 00 wcsr IE,r7
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
800e178: 29 63 00 50 lw r3,(r11+80)
800e17c: 34 02 00 02 mvi r2,2
800e180: 44 62 00 15 be r3,r2,800e1d4 <_Event_Surrender+0xe4>
_ISR_Enable( level );
800e184: d0 01 00 00 wcsr IE,r1
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
800e188: 78 01 08 01 mvhi r1,0x801
800e18c: 38 21 8a bc ori r1,r1,0x8abc
800e190: 28 22 00 00 lw r2,(r1+0)
800e194: b9 60 08 00 mv r1,r11
800e198: f8 00 05 99 calli 800f7fc <_Thread_Clear_state>
}
return;
}
}
_ISR_Enable( level );
}
800e19c: 2b 9d 00 04 lw ra,(sp+4)
800e1a0: 2b 8b 00 08 lw r11,(sp+8)
800e1a4: 37 9c 00 08 addi sp,sp,8
800e1a8: c3 a0 00 00 ret
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
800e1ac: d0 01 00 00 wcsr IE,r1
}
800e1b0: 2b 9d 00 04 lw ra,(sp+4)
800e1b4: 2b 8b 00 08 lw r11,(sp+8)
800e1b8: 37 9c 00 08 addi sp,sp,8
800e1bc: c3 a0 00 00 ret
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
_ISR_Enable( level );
800e1c0: d0 01 00 00 wcsr IE,r1
}
return;
}
}
_ISR_Enable( level );
}
800e1c4: 2b 9d 00 04 lw ra,(sp+4)
800e1c8: 2b 8b 00 08 lw r11,(sp+8)
800e1cc: 37 9c 00 08 addi sp,sp,8
800e1d0: c3 a0 00 00 ret
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
800e1d4: 34 02 00 03 mvi r2,3
800e1d8: 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 );
800e1dc: d0 01 00 00 wcsr IE,r1
(void) _Watchdog_Remove( &the_thread->Timer );
800e1e0: 35 61 00 48 addi r1,r11,72
800e1e4: fb ff e7 69 calli 8007f88 <_Watchdog_Remove>
800e1e8: 78 03 08 01 mvhi r3,0x801
800e1ec: 38 63 8a bc ori r3,r3,0x8abc
800e1f0: 28 62 00 00 lw r2,(r3+0)
800e1f4: b9 60 08 00 mv r1,r11
800e1f8: f8 00 05 81 calli 800f7fc <_Thread_Clear_state>
800e1fc: e3 ff ff ed bi 800e1b0 <_Event_Surrender+0xc0>
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
800e200: 78 03 08 01 mvhi r3,0x801
800e204: 38 63 b2 e0 ori r3,r3,0xb2e0
800e208: 28 6a 00 00 lw r10,(r3+0)
/*
* 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 ) &&
800e20c: 34 09 00 02 mvi r9,2
800e210: 45 49 00 04 be r10,r9,800e220 <_Event_Surrender+0x130> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
800e214: 28 6a 00 00 lw r10,(r3+0)
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
800e218: 34 09 00 01 mvi r9,1
800e21c: 5d 49 ff c9 bne r10,r9,800e140 <_Event_Surrender+0x50>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
800e220: 44 82 00 03 be r4,r2,800e22c <_Event_Surrender+0x13c> <== ALWAYS TAKEN
800e224: 21 08 00 02 andi r8,r8,0x2 <== NOT EXECUTED
800e228: 45 00 00 09 be r8,r0,800e24c <_Event_Surrender+0x15c> <== NOT EXECUTED
800e22c: a4 40 20 00 not r4,r2
800e230: a0 86 30 00 and r6,r4,r6
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800e234: 29 64 00 28 lw r4,(r11+40)
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
800e238: 58 a6 00 00 sw (r5+0),r6
the_thread->Wait.count = 0;
800e23c: 59 60 00 24 sw (r11+36),r0
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
800e240: 58 82 00 00 sw (r4+0),r2
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
800e244: 34 02 00 03 mvi r2,3
800e248: 58 62 00 00 sw (r3+0),r2
}
_ISR_Enable( level );
800e24c: d0 01 00 00 wcsr IE,r1
return;
800e250: e3 ff ff d8 bi 800e1b0 <_Event_Surrender+0xc0>
0800e254 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
800e254: 37 9c ff f8 addi sp,sp,-8
800e258: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
800e25c: 37 82 00 08 addi r2,sp,8
800e260: fb ff e2 88 calli 8006c80 <_Thread_Get>
switch ( location ) {
800e264: 2b 82 00 08 lw r2,(sp+8)
800e268: 44 40 00 04 be r2,r0,800e278 <_Event_Timeout+0x24> <== ALWAYS TAKEN
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
800e26c: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
800e270: 37 9c 00 08 addi sp,sp,8 <== NOT EXECUTED
800e274: 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 );
800e278: 90 00 18 00 rcsr r3,IE
800e27c: 34 02 ff fe mvi r2,-2
800e280: a0 62 10 00 and r2,r3,r2
800e284: d0 02 00 00 wcsr IE,r2
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
800e288: 78 02 08 01 mvhi r2,0x801
800e28c: 38 42 ad ec ori r2,r2,0xadec
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
800e290: 28 42 00 0c lw r2,(r2+12)
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
800e294: 58 20 00 24 sw (r1+36),r0
if ( _Thread_Is_executing( the_thread ) ) {
800e298: 44 22 00 10 be r1,r2,800e2d8 <_Event_Timeout+0x84> <== NEVER TAKEN
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
800e29c: 34 02 00 06 mvi r2,6
800e2a0: 58 22 00 34 sw (r1+52),r2
_ISR_Enable( level );
800e2a4: d0 03 00 00 wcsr IE,r3
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
800e2a8: 78 03 08 01 mvhi r3,0x801
800e2ac: 38 63 8a bc ori r3,r3,0x8abc
800e2b0: 28 62 00 00 lw r2,(r3+0)
800e2b4: f8 00 05 52 calli 800f7fc <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
800e2b8: 78 01 08 01 mvhi r1,0x801
800e2bc: 38 21 a9 20 ori r1,r1,0xa920
800e2c0: 28 22 00 00 lw r2,(r1+0)
800e2c4: 34 42 ff ff addi r2,r2,-1
800e2c8: 58 22 00 00 sw (r1+0),r2
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
800e2cc: 2b 9d 00 04 lw ra,(sp+4)
800e2d0: 37 9c 00 08 addi sp,sp,8
800e2d4: c3 a0 00 00 ret
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
800e2d8: 78 02 08 01 mvhi r2,0x801 <== NOT EXECUTED
800e2dc: 38 42 b2 e0 ori r2,r2,0xb2e0 <== NOT EXECUTED
800e2e0: 28 45 00 00 lw r5,(r2+0) <== NOT EXECUTED
800e2e4: 34 04 00 01 mvi r4,1 <== NOT EXECUTED
800e2e8: 5c a4 ff ed bne r5,r4,800e29c <_Event_Timeout+0x48> <== NOT EXECUTED
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
800e2ec: 34 04 00 02 mvi r4,2 <== NOT EXECUTED
800e2f0: 58 44 00 00 sw (r2+0),r4 <== NOT EXECUTED
800e2f4: e3 ff ff ea bi 800e29c <_Event_Timeout+0x48> <== NOT EXECUTED
0800a07c <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
800a07c: 37 9c ff bc addi sp,sp,-68
800a080: 5b 8b 00 44 sw (sp+68),r11
800a084: 5b 8c 00 40 sw (sp+64),r12
800a088: 5b 8d 00 3c sw (sp+60),r13
800a08c: 5b 8e 00 38 sw (sp+56),r14
800a090: 5b 8f 00 34 sw (sp+52),r15
800a094: 5b 90 00 30 sw (sp+48),r16
800a098: 5b 91 00 2c sw (sp+44),r17
800a09c: 5b 92 00 28 sw (sp+40),r18
800a0a0: 5b 93 00 24 sw (sp+36),r19
800a0a4: 5b 94 00 20 sw (sp+32),r20
800a0a8: 5b 95 00 1c sw (sp+28),r21
800a0ac: 5b 96 00 18 sw (sp+24),r22
800a0b0: 5b 97 00 14 sw (sp+20),r23
800a0b4: 5b 98 00 10 sw (sp+16),r24
800a0b8: 5b 99 00 0c sw (sp+12),r25
800a0bc: 5b 9b 00 08 sw (sp+8),fp
800a0c0: 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
800a0c4: 34 54 00 04 addi r20,r2,4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
800a0c8: 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;
800a0cc: 28 37 00 10 lw r23,(r1+16)
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
800a0d0: b8 40 70 00 mv r14,r2
800a0d4: b8 60 80 00 mv r16,r3
800a0d8: 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;
800a0dc: 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 ) {
800a0e0: 54 54 00 5b bgu r2,r20,800a24c <_Heap_Allocate_aligned_with_boundary+0x1d0>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
800a0e4: 5c 80 00 6f bne r4,r0,800a2a0 <_Heap_Allocate_aligned_with_boundary+0x224>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
800a0e8: 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 ) {
800a0ec: 34 01 00 00 mvi r1,0
800a0f0: 45 ec 00 57 be r15,r12,800a24c <_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;
800a0f4: 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 ) {
800a0f8: 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;
800a0fc: 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
800a100: 36 f9 00 07 addi r25,r23,7
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
800a104: 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 ) {
800a108: 29 81 00 04 lw r1,(r12+4)
800a10c: 52 81 00 3b bgeu r20,r1,800a1f8 <_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;
800a110: 35 8b 00 08 addi r11,r12,8
if ( alignment == 0 ) {
800a114: 46 00 00 3e be r16,r0,800a20c <_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;
800a118: a0 3b 68 00 and r13,r1,fp
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
800a11c: 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;
800a120: 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;
800a124: 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;
800a128: 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);
800a12c: b9 60 08 00 mv r1,r11
800a130: 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
800a134: b4 6d 68 00 add r13,r3,r13
800a138: f8 00 20 c4 calli 8012448 <__umodsi3>
800a13c: 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;
800a140: 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 ) {
800a144: 51 ab 00 05 bgeu r13,r11,800a158 <_Heap_Allocate_aligned_with_boundary+0xdc>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a148: b9 a0 08 00 mv r1,r13
800a14c: ba 00 10 00 mv r2,r16
800a150: f8 00 20 be calli 8012448 <__umodsi3>
800a154: c9 a1 58 00 sub r11,r13,r1
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
800a158: 46 40 00 1c be r18,r0,800a1c8 <_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;
800a15c: b5 6e 68 00 add r13,r11,r14
800a160: b9 a0 08 00 mv r1,r13
800a164: ba 40 10 00 mv r2,r18
800a168: f8 00 20 b8 calli 8012448 <__umodsi3>
800a16c: 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 ) {
800a170: f5 a5 68 00 cmpgu r13,r13,r5
800a174: f4 ab 08 00 cmpgu r1,r5,r11
800a178: a1 a1 68 00 and r13,r13,r1
800a17c: 45 a0 00 13 be r13,r0,800a1c8 <_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;
800a180: 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 ) {
800a184: 56 65 00 1d bgu r19,r5,800a1f8 <_Heap_Allocate_aligned_with_boundary+0x17c>
800a188: e0 00 00 02 bi 800a190 <_Heap_Allocate_aligned_with_boundary+0x114>
800a18c: 56 65 00 1b bgu r19,r5,800a1f8 <_Heap_Allocate_aligned_with_boundary+0x17c><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
800a190: c8 ae 58 00 sub r11,r5,r14
800a194: ba 00 10 00 mv r2,r16
800a198: b9 60 08 00 mv r1,r11
800a19c: f8 00 20 ab calli 8012448 <__umodsi3>
800a1a0: c9 61 58 00 sub r11,r11,r1
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
800a1a4: b5 6e 68 00 add r13,r11,r14
800a1a8: b9 a0 08 00 mv r1,r13
800a1ac: ba 40 10 00 mv r2,r18
800a1b0: f8 00 20 a6 calli 8012448 <__umodsi3>
800a1b4: 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 ) {
800a1b8: f5 a5 68 00 cmpgu r13,r13,r5
800a1bc: f4 ab 08 00 cmpgu r1,r5,r11
800a1c0: a1 a1 68 00 and r13,r13,r1
800a1c4: 5d a0 ff f2 bne r13,r0,800a18c <_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 ) {
800a1c8: 56 cb 00 0c bgu r22,r11,800a1f8 <_Heap_Allocate_aligned_with_boundary+0x17c>
800a1cc: 34 01 ff f8 mvi r1,-8
800a1d0: c8 2c 68 00 sub r13,r1,r12
800a1d4: ba e0 10 00 mv r2,r23
800a1d8: b9 60 08 00 mv r1,r11
800a1dc: f8 00 20 9b calli 8012448 <__umodsi3>
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
800a1e0: 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;
800a1e4: c9 a1 08 00 sub r1,r13,r1
if ( free_size >= min_block_size || free_size == 0 ) {
800a1e8: 64 22 00 00 cmpei r2,r1,0
800a1ec: f0 35 a8 00 cmpgeu r21,r1,r21
800a1f0: b8 55 08 00 or r1,r2,r21
800a1f4: 5c 20 00 06 bne r1,r0,800a20c <_Heap_Allocate_aligned_with_boundary+0x190>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
800a1f8: 29 8c 00 08 lw r12,(r12+8)
800a1fc: 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 ) {
800a200: 45 ec 00 26 be r15,r12,800a298 <_Heap_Allocate_aligned_with_boundary+0x21c>
800a204: b8 20 88 00 mv r17,r1
800a208: e3 ff ff c0 bi 800a108 <_Heap_Allocate_aligned_with_boundary+0x8c>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
800a20c: 45 60 ff fb be r11,r0,800a1f8 <_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;
800a210: 29 e3 00 48 lw r3,(r15+72)
stats->searches += search_count;
800a214: 29 e2 00 4c lw r2,(r15+76)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
800a218: 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;
800a21c: 34 63 00 01 addi r3,r3,1
stats->searches += search_count;
800a220: 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;
800a224: 59 e3 00 48 sw (r15+72),r3
stats->searches += search_count;
800a228: 59 e2 00 4c sw (r15+76),r2
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
800a22c: b9 60 18 00 mv r3,r11
800a230: b9 80 10 00 mv r2,r12
800a234: b9 c0 20 00 mv r4,r14
800a238: fb ff e8 16 calli 8004290 <_Heap_Block_allocate>
800a23c: b9 60 08 00 mv r1,r11
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
800a240: 29 e2 00 44 lw r2,(r15+68)
800a244: 50 51 00 02 bgeu r2,r17,800a24c <_Heap_Allocate_aligned_with_boundary+0x1d0>
stats->max_search = search_count;
800a248: 59 f1 00 44 sw (r15+68),r17
}
return (void *) alloc_begin;
}
800a24c: 2b 9d 00 04 lw ra,(sp+4)
800a250: 2b 8b 00 44 lw r11,(sp+68)
800a254: 2b 8c 00 40 lw r12,(sp+64)
800a258: 2b 8d 00 3c lw r13,(sp+60)
800a25c: 2b 8e 00 38 lw r14,(sp+56)
800a260: 2b 8f 00 34 lw r15,(sp+52)
800a264: 2b 90 00 30 lw r16,(sp+48)
800a268: 2b 91 00 2c lw r17,(sp+44)
800a26c: 2b 92 00 28 lw r18,(sp+40)
800a270: 2b 93 00 24 lw r19,(sp+36)
800a274: 2b 94 00 20 lw r20,(sp+32)
800a278: 2b 95 00 1c lw r21,(sp+28)
800a27c: 2b 96 00 18 lw r22,(sp+24)
800a280: 2b 97 00 14 lw r23,(sp+20)
800a284: 2b 98 00 10 lw r24,(sp+16)
800a288: 2b 99 00 0c lw r25,(sp+12)
800a28c: 2b 9b 00 08 lw fp,(sp+8)
800a290: 37 9c 00 44 addi sp,sp,68
800a294: 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 ) {
800a298: 34 01 00 00 mvi r1,0
800a29c: e3 ff ff e9 bi 800a240 <_Heap_Allocate_aligned_with_boundary+0x1c4>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
800a2a0: 54 44 ff eb bgu r2,r4,800a24c <_Heap_Allocate_aligned_with_boundary+0x1d0>
return NULL;
}
if ( alignment == 0 ) {
800a2a4: 5c 60 ff 91 bne r3,r0,800a0e8 <_Heap_Allocate_aligned_with_boundary+0x6c>
alignment = page_size;
800a2a8: ba e0 80 00 mv r16,r23
800a2ac: e3 ff ff 8f bi 800a0e8 <_Heap_Allocate_aligned_with_boundary+0x6c>
0800a50c <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
800a50c: 37 9c ff b8 addi sp,sp,-72
800a510: 5b 8b 00 40 sw (sp+64),r11
800a514: 5b 8c 00 3c sw (sp+60),r12
800a518: 5b 8d 00 38 sw (sp+56),r13
800a51c: 5b 8e 00 34 sw (sp+52),r14
800a520: 5b 8f 00 30 sw (sp+48),r15
800a524: 5b 90 00 2c sw (sp+44),r16
800a528: 5b 91 00 28 sw (sp+40),r17
800a52c: 5b 92 00 24 sw (sp+36),r18
800a530: 5b 93 00 20 sw (sp+32),r19
800a534: 5b 94 00 1c sw (sp+28),r20
800a538: 5b 95 00 18 sw (sp+24),r21
800a53c: 5b 96 00 14 sw (sp+20),r22
800a540: 5b 97 00 10 sw (sp+16),r23
800a544: 5b 98 00 0c sw (sp+12),r24
800a548: 5b 99 00 08 sw (sp+8),r25
800a54c: 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;
800a550: 5b 80 00 48 sw (sp+72),r0
Heap_Block *extend_last_block = NULL;
800a554: 5b 80 00 44 sw (sp+68),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;
800a558: b4 43 70 00 add r14,r2,r3
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
800a55c: b8 40 68 00 mv r13,r2
800a560: b8 20 58 00 mv r11,r1
800a564: b8 80 b8 00 mv r23,r4
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
800a568: 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;
800a56c: 28 32 00 10 lw r18,(r1+16)
uintptr_t const min_block_size = heap->min_block_size;
800a570: 28 25 00 14 lw r5,(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;
800a574: 28 38 00 30 lw r24,(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 false;
800a578: 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 ) {
800a57c: 54 4e 00 76 bgu r2,r14,800a754 <_Heap_Extend+0x248>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
800a580: b8 40 08 00 mv r1,r2
800a584: b8 a0 20 00 mv r4,r5
800a588: b8 60 10 00 mv r2,r3
800a58c: 37 85 00 48 addi r5,sp,72
800a590: ba 40 18 00 mv r3,r18
800a594: 37 86 00 44 addi r6,sp,68
800a598: fb ff e7 a6 calli 8004430 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
800a59c: 44 20 00 6e be r1,r0,800a754 <_Heap_Extend+0x248>
800a5a0: ba 00 60 00 mv r12,r16
800a5a4: 34 16 00 00 mvi r22,0
800a5a8: 34 19 00 00 mvi r25,0
800a5ac: 34 11 00 00 mvi r17,0
800a5b0: 34 14 00 00 mvi r20,0
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
800a5b4: 34 15 ff fe mvi r21,-2
800a5b8: e0 00 00 0d bi 800a5ec <_Heap_Extend+0xe0>
return false;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
800a5bc: 55 ee 00 7b bgu r15,r14,800a7a8 <_Heap_Extend+0x29c>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a5c0: b9 e0 08 00 mv r1,r15
800a5c4: ba 40 10 00 mv r2,r18
800a5c8: 35 f3 ff f8 addi r19,r15,-8
800a5cc: f8 00 21 23 calli 8012a58 <__umodsi3>
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
800a5d0: ca 61 08 00 sub r1,r19,r1
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
800a5d4: 45 af 00 15 be r13,r15,800a628 <_Heap_Extend+0x11c>
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
800a5d8: 55 af 00 72 bgu r13,r15,800a7a0 <_Heap_Extend+0x294>
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
800a5dc: 28 2c 00 04 lw r12,(r1+4)
800a5e0: 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);
800a5e4: 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 );
800a5e8: 46 0c 00 16 be r16,r12,800a640 <_Heap_Extend+0x134>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
800a5ec: b9 80 08 00 mv r1,r12
800a5f0: 45 90 00 70 be r12,r16,800a7b0 <_Heap_Extend+0x2a4>
uintptr_t const sub_area_end = start_block->prev_size;
800a5f4: 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
800a5f8: f5 c1 30 00 cmpgu r6,r14,r1
800a5fc: f5 ed 28 00 cmpgu r5,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 (
800a600: a0 c5 28 00 and r5,r6,r5
800a604: 5c a0 00 75 bne r5,r0,800a7d8 <_Heap_Extend+0x2cc>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
800a608: 5c 2e ff ed bne r1,r14,800a5bc <_Heap_Extend+0xb0>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a60c: b9 e0 08 00 mv r1,r15
800a610: ba 40 10 00 mv r2,r18
800a614: 35 f3 ff f8 addi r19,r15,-8
800a618: f8 00 21 10 calli 8012a58 <__umodsi3>
800a61c: 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);
800a620: 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 ) {
800a624: 5d af ff ed bne r13,r15,800a5d8 <_Heap_Extend+0xcc> <== ALWAYS TAKEN
start_block->prev_size = extend_area_end;
800a628: 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;
800a62c: 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 )
800a630: 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;
800a634: 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);
800a638: 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 );
800a63c: 5e 0c ff ec bne r16,r12,800a5ec <_Heap_Extend+0xe0> <== NEVER TAKEN
if ( extend_area_begin < heap->area_begin ) {
800a640: 29 61 00 18 lw r1,(r11+24)
800a644: 51 a1 00 61 bgeu r13,r1,800a7c8 <_Heap_Extend+0x2bc>
heap->area_begin = extend_area_begin;
800a648: 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;
800a64c: 2b 81 00 44 lw r1,(sp+68)
800a650: 2b 82 00 48 lw r2,(sp+72)
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 ) {
800a654: 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 =
800a658: 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;
800a65c: 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;
800a660: 58 4e 00 00 sw (r2+0),r14
extend_first_block->size_and_flag =
800a664: 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;
800a668: 58 23 00 00 sw (r1+0),r3
extend_last_block->size_and_flag = 0;
800a66c: 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 ) {
800a670: 50 45 00 52 bgeu r2,r5,800a7b8 <_Heap_Extend+0x2ac>
heap->first_block = extend_first_block;
800a674: 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 ) {
800a678: 46 80 00 6a be r20,r0,800a820 <_Heap_Extend+0x314>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
800a67c: 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 );
800a680: 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;
800a684: b9 a0 08 00 mv r1,r13
800a688: b9 80 10 00 mv r2,r12
800a68c: f8 00 20 f3 calli 8012a58 <__umodsi3>
if ( remainder != 0 ) {
800a690: 44 20 00 03 be r1,r0,800a69c <_Heap_Extend+0x190> <== ALWAYS TAKEN
return value - remainder + alignment;
800a694: b5 ac 68 00 add r13,r13,r12 <== NOT EXECUTED
800a698: c9 a1 68 00 sub r13,r13,r1 <== NOT EXECUTED
uintptr_t const new_first_block_begin =
800a69c: 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;
800a6a0: 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 =
800a6a4: 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;
800a6a8: 38 21 00 01 ori r1,r1,0x1
800a6ac: 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;
800a6b0: 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 );
800a6b4: b9 60 08 00 mv r1,r11
800a6b8: fb ff ff 88 calli 800a4d8 <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
800a6bc: 46 20 00 49 be r17,r0,800a7e0 <_Heap_Extend+0x2d4>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a6c0: 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,
800a6c4: 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(
800a6c8: c9 d1 70 00 sub r14,r14,r17
800a6cc: b9 c0 08 00 mv r1,r14
800a6d0: f8 00 20 e2 calli 8012a58 <__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)
800a6d4: 2a 22 00 04 lw r2,(r17+4)
800a6d8: 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 =
800a6dc: b5 d1 08 00 add r1,r14,r17
(last_block->size_and_flag - last_block_new_size)
800a6e0: c8 4e 10 00 sub r2,r2,r14
| HEAP_PREV_BLOCK_USED;
800a6e4: 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 =
800a6e8: 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;
800a6ec: 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 );
800a6f0: b9 60 08 00 mv r1,r11
800a6f4: ba 20 10 00 mv r2,r17
800a6f8: 20 63 00 01 andi r3,r3,0x1
block->size_and_flag = size | flag;
800a6fc: b9 c3 70 00 or r14,r14,r3
800a700: 5a 2e 00 04 sw (r17+4),r14
800a704: fb ff ff 75 calli 800a4d8 <_Heap_Free_block>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
800a708: 66 31 00 00 cmpei r17,r17,0
800a70c: 66 94 00 00 cmpei r20,r20,0
800a710: a2 34 88 00 and r17,r17,r20
800a714: 5e 20 00 3f bne r17,r0,800a810 <_Heap_Extend+0x304>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
800a718: 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(
800a71c: 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;
800a720: 29 65 00 30 lw r5,(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;
800a724: 28 22 00 04 lw r2,(r1+4)
/* Statistics */
stats->size += extended_size;
800a728: 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(
800a72c: 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;
800a730: 20 42 00 01 andi r2,r2,0x1
block->size_and_flag = size | flag;
800a734: 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;
800a738: c8 b8 c0 00 sub r24,r5,r24
800a73c: 58 22 00 04 sw (r1+4),r2
/* Statistics */
stats->size += extended_size;
800a740: b4 98 08 00 add r1,r4,r24
800a744: 59 61 00 2c sw (r11+44),r1
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
800a748: 34 0c 00 01 mvi r12,1
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
800a74c: 46 e0 00 02 be r23,r0,800a754 <_Heap_Extend+0x248> <== NEVER TAKEN
*extended_size_ptr = extended_size;
800a750: 5a f8 00 00 sw (r23+0),r24
return true;
}
800a754: b9 80 08 00 mv r1,r12
800a758: 2b 9d 00 04 lw ra,(sp+4)
800a75c: 2b 8b 00 40 lw r11,(sp+64)
800a760: 2b 8c 00 3c lw r12,(sp+60)
800a764: 2b 8d 00 38 lw r13,(sp+56)
800a768: 2b 8e 00 34 lw r14,(sp+52)
800a76c: 2b 8f 00 30 lw r15,(sp+48)
800a770: 2b 90 00 2c lw r16,(sp+44)
800a774: 2b 91 00 28 lw r17,(sp+40)
800a778: 2b 92 00 24 lw r18,(sp+36)
800a77c: 2b 93 00 20 lw r19,(sp+32)
800a780: 2b 94 00 1c lw r20,(sp+28)
800a784: 2b 95 00 18 lw r21,(sp+24)
800a788: 2b 96 00 14 lw r22,(sp+20)
800a78c: 2b 97 00 10 lw r23,(sp+16)
800a790: 2b 98 00 0c lw r24,(sp+12)
800a794: 2b 99 00 08 lw r25,(sp+8)
800a798: 37 9c 00 48 addi sp,sp,72
800a79c: 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 )
800a7a0: b8 20 b0 00 mv r22,r1
800a7a4: e3 ff ff 8e bi 800a5dc <_Heap_Extend+0xd0>
return false;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
800a7a8: b9 80 c8 00 mv r25,r12
800a7ac: e3 ff ff 85 bi 800a5c0 <_Heap_Extend+0xb4>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
800a7b0: 29 61 00 18 lw r1,(r11+24)
800a7b4: e3 ff ff 90 bi 800a5f4 <_Heap_Extend+0xe8>
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 ) {
800a7b8: 29 62 00 24 lw r2,(r11+36)
800a7bc: 50 41 ff af bgeu r2,r1,800a678 <_Heap_Extend+0x16c>
heap->last_block = extend_last_block;
800a7c0: 59 61 00 24 sw (r11+36),r1
800a7c4: e3 ff ff ad bi 800a678 <_Heap_Extend+0x16c>
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 ) {
800a7c8: 29 61 00 1c lw r1,(r11+28)
800a7cc: 50 2e ff a0 bgeu r1,r14,800a64c <_Heap_Extend+0x140>
heap->area_end = extend_area_end;
800a7d0: 59 6e 00 1c sw (r11+28),r14
800a7d4: e3 ff ff 9e bi 800a64c <_Heap_Extend+0x140>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
800a7d8: 34 0c 00 00 mvi r12,0
800a7dc: e3 ff ff de bi 800a754 <_Heap_Extend+0x248>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
800a7e0: 46 d1 ff ca be r22,r17,800a708 <_Heap_Extend+0x1fc>
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;
800a7e4: 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 );
800a7e8: 2b 82 00 48 lw r2,(sp+72)
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
800a7ec: 2b 81 00 44 lw r1,(sp+68)
800a7f0: 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 );
800a7f4: c8 56 10 00 sub r2,r2,r22
block->size_and_flag = size | flag;
800a7f8: b8 43 10 00 or r2,r2,r3
800a7fc: 5a c2 00 04 sw (r22+4),r2
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
800a800: 28 22 00 04 lw r2,(r1+4)
800a804: 38 42 00 01 ori r2,r2,0x1
800a808: 58 22 00 04 sw (r1+4),r2
800a80c: e3 ff ff bf bi 800a708 <_Heap_Extend+0x1fc>
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
_Heap_Free_block( heap, extend_first_block );
800a810: 2b 82 00 48 lw r2,(sp+72)
800a814: b9 60 08 00 mv r1,r11
800a818: fb ff ff 30 calli 800a4d8 <_Heap_Free_block>
800a81c: e3 ff ff bf bi 800a718 <_Heap_Extend+0x20c>
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 ) {
800a820: 47 34 ff a7 be r25,r20,800a6bc <_Heap_Extend+0x1b0>
{
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;
800a824: cb 21 c8 00 sub r25,r25,r1
800a828: 3b 39 00 01 ori r25,r25,0x1
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
800a82c: 58 39 00 04 sw (r1+4),r25
800a830: e3 ff ff a3 bi 800a6bc <_Heap_Extend+0x1b0>
0800a2b0 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
800a2b0: 37 9c ff f4 addi sp,sp,-12
800a2b4: 5b 8b 00 0c sw (sp+12),r11
800a2b8: 5b 8c 00 08 sw (sp+8),r12
800a2bc: 5b 9d 00 04 sw (sp+4),ra
800a2c0: b8 40 18 00 mv r3,r2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
800a2c4: 28 22 00 10 lw r2,(r1+16)
800a2c8: b8 20 58 00 mv r11,r1
800a2cc: b8 60 08 00 mv r1,r3
800a2d0: 34 6c ff f8 addi r12,r3,-8
800a2d4: f8 00 20 5d calli 8012448 <__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
800a2d8: 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);
800a2dc: c9 81 10 00 sub r2,r12,r1
bool next_is_free = false;
_Heap_Protection_block_check( heap, block );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
800a2e0: 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;
800a2e4: 54 82 00 43 bgu r4,r2,800a3f0 <_Heap_Free+0x140>
800a2e8: 29 65 00 24 lw r5,(r11+36)
800a2ec: 54 45 00 41 bgu r2,r5,800a3f0 <_Heap_Free+0x140>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800a2f0: 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;
800a2f4: 34 07 ff fe mvi r7,-2
800a2f8: 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);
800a2fc: 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;
800a300: 54 83 00 3c bgu r4,r3,800a3f0 <_Heap_Free+0x140> <== NEVER TAKEN
800a304: 54 65 00 3b bgu r3,r5,800a3f0 <_Heap_Free+0x140> <== NEVER TAKEN
800a308: 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;
800a30c: 21 2a 00 01 andi r10,r9,0x1
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
800a310: 45 40 00 38 be r10,r0,800a3f0 <_Heap_Free+0x140> <== 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;
800a314: 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 ));
800a318: 34 07 00 00 mvi r7,0
800a31c: 44 a3 00 05 be r5,r3,800a330 <_Heap_Free+0x80>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800a320: 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;
800a324: 28 27 00 04 lw r7,(r1+4)
800a328: 20 e7 00 01 andi r7,r7,0x1
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
800a32c: 18 e7 00 01 xori r7,r7,0x1
800a330: 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 ) ) {
800a334: 5d 00 00 19 bne r8,r0,800a398 <_Heap_Free+0xe8>
uintptr_t const prev_size = block->prev_size;
800a338: 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 );
800a33c: 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);
800a340: 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;
800a344: 54 82 00 2b bgu r4,r2,800a3f0 <_Heap_Free+0x140> <== NEVER TAKEN
800a348: b9 00 08 00 mv r1,r8
800a34c: 54 45 00 29 bgu r2,r5,800a3f0 <_Heap_Free+0x140> <== 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;
800a350: 28 44 00 04 lw r4,(r2+4)
800a354: 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) ) {
800a358: 44 80 00 26 be r4,r0,800a3f0 <_Heap_Free+0x140> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
800a35c: 44 e0 00 3d be r7,r0,800a450 <_Heap_Free+0x1a0>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
800a360: 29 64 00 38 lw r4,(r11+56)
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800a364: 28 61 00 08 lw r1,(r3+8)
800a368: 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;
800a36c: b4 c9 48 00 add r9,r6,r9
800a370: 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;
800a374: 58 61 00 08 sw (r3+8),r1
next->prev = prev;
800a378: 58 23 00 0c sw (r1+12),r3
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
800a37c: 34 81 ff ff addi r1,r4,-1
800a380: 59 61 00 38 sw (r11+56),r1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
800a384: 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;
800a388: 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;
800a38c: 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;
800a390: 58 2a 00 00 sw (r1+0),r10
800a394: e0 00 00 0d bi 800a3c8 <_Heap_Free+0x118>
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 */
800a398: 44 e0 00 1b be r7,r0,800a404 <_Heap_Free+0x154>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
800a39c: 28 64 00 08 lw r4,(r3+8)
800a3a0: 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;
800a3a4: b5 26 48 00 add r9,r9,r6
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
800a3a8: 58 44 00 08 sw (r2+8),r4
new_block->prev = prev;
800a3ac: 58 41 00 0c sw (r2+12),r1
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
800a3b0: 39 25 00 01 ori r5,r9,0x1
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
800a3b4: b4 49 18 00 add r3,r2,r9
next->prev = new_block;
800a3b8: 58 82 00 0c sw (r4+12),r2
prev->next = new_block;
800a3bc: 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;
800a3c0: 58 45 00 04 sw (r2+4),r5
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
800a3c4: 58 69 00 00 sw (r3+0),r9
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
800a3c8: 29 62 00 40 lw r2,(r11+64)
++stats->frees;
800a3cc: 29 61 00 50 lw r1,(r11+80)
stats->free_size += block_size;
800a3d0: 29 63 00 30 lw r3,(r11+48)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
800a3d4: 34 42 ff ff addi r2,r2,-1
++stats->frees;
800a3d8: 34 21 00 01 addi r1,r1,1
stats->free_size += block_size;
800a3dc: b4 66 30 00 add r6,r3,r6
}
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
800a3e0: 59 61 00 50 sw (r11+80),r1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
800a3e4: 59 62 00 40 sw (r11+64),r2
++stats->frees;
stats->free_size += block_size;
800a3e8: 59 66 00 30 sw (r11+48),r6
return( true );
800a3ec: 34 01 00 01 mvi r1,1
}
800a3f0: 2b 9d 00 04 lw ra,(sp+4)
800a3f4: 2b 8b 00 0c lw r11,(sp+12)
800a3f8: 2b 8c 00 08 lw r12,(sp+8)
800a3fc: 37 9c 00 0c addi sp,sp,12
800a400: 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;
800a404: 38 c1 00 01 ori r1,r6,0x1
800a408: 58 41 00 04 sw (r2+4),r1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
800a40c: 28 67 00 04 lw r7,(r3+4)
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
800a410: 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;
800a414: 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;
800a418: 34 05 ff fe mvi r5,-2
new_block->next = next;
new_block->prev = block_before;
800a41c: 58 4b 00 0c sw (r2+12),r11
800a420: 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 ) {
800a424: 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;
800a428: 34 21 00 01 addi r1,r1,1
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
800a42c: 58 44 00 08 sw (r2+8),r4
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
800a430: 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;
800a434: 58 65 00 04 sw (r3+4),r5
next_block->prev_size = block_size;
800a438: 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;
800a43c: 59 62 00 08 sw (r11+8),r2
/* Statistics */
++stats->free_blocks;
800a440: 59 61 00 38 sw (r11+56),r1
if ( stats->max_free_blocks < stats->free_blocks ) {
800a444: 50 e1 ff e1 bgeu r7,r1,800a3c8 <_Heap_Free+0x118>
stats->max_free_blocks = stats->free_blocks;
800a448: 59 61 00 3c sw (r11+60),r1
800a44c: e3 ff ff df bi 800a3c8 <_Heap_Free+0x118>
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;
800a450: b4 ca 50 00 add r10,r6,r10
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
800a454: 39 41 00 01 ori r1,r10,0x1
800a458: 58 41 00 04 sw (r2+4),r1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
800a45c: 28 62 00 04 lw r2,(r3+4)
800a460: 34 01 ff fe mvi r1,-2
next_block->prev_size = size;
800a464: 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;
800a468: a0 41 08 00 and r1,r2,r1
800a46c: 58 61 00 04 sw (r3+4),r1
800a470: e3 ff ff d6 bi 800a3c8 <_Heap_Free+0x118>
0800ae88 <_Heap_Get_information>:
void _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
Heap_Block *the_block = the_heap->first_block;
800ae88: 28 24 00 20 lw r4,(r1+32)
Heap_Block *const end = the_heap->last_block;
800ae8c: 28 28 00 24 lw r8,(r1+36)
memset(the_info, 0, sizeof(*the_info));
800ae90: 58 40 00 00 sw (r2+0),r0
800ae94: 58 40 00 04 sw (r2+4),r0
800ae98: 58 40 00 08 sw (r2+8),r0
800ae9c: 58 40 00 0c sw (r2+12),r0
800aea0: 58 40 00 10 sw (r2+16),r0
800aea4: 58 40 00 14 sw (r2+20),r0
while ( the_block != end ) {
800aea8: 44 88 00 14 be r4,r8,800aef8 <_Heap_Get_information+0x70> <== NEVER TAKEN
800aeac: 28 85 00 04 lw r5,(r4+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;
800aeb0: 34 09 ff fe mvi r9,-2
800aeb4: a0 a9 18 00 and r3,r5,r9
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
800aeb8: b4 83 20 00 add r4,r4,r3
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
800aebc: 28 85 00 04 lw r5,(r4+4)
Heap_Information *info;
if ( _Heap_Is_prev_used(next_block) )
info = &the_info->Used;
else
info = &the_info->Free;
800aec0: b8 40 08 00 mv r1,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;
800aec4: 20 a6 00 01 andi r6,r5,0x1
while ( the_block != end ) {
uintptr_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
Heap_Information *info;
if ( _Heap_Is_prev_used(next_block) )
800aec8: 44 c0 00 02 be r6,r0,800aed0 <_Heap_Get_information+0x48>
info = &the_info->Used;
800aecc: 34 41 00 0c addi r1,r2,12
else
info = &the_info->Free;
info->number++;
800aed0: 28 27 00 00 lw r7,(r1+0)
info->total += the_size;
800aed4: 28 26 00 08 lw r6,(r1+8)
if ( info->largest < the_size )
800aed8: 28 2a 00 04 lw r10,(r1+4)
if ( _Heap_Is_prev_used(next_block) )
info = &the_info->Used;
else
info = &the_info->Free;
info->number++;
800aedc: 34 e7 00 01 addi r7,r7,1
info->total += the_size;
800aee0: b4 c3 30 00 add r6,r6,r3
if ( _Heap_Is_prev_used(next_block) )
info = &the_info->Used;
else
info = &the_info->Free;
info->number++;
800aee4: 58 27 00 00 sw (r1+0),r7
info->total += the_size;
800aee8: 58 26 00 08 sw (r1+8),r6
if ( info->largest < the_size )
800aeec: 51 43 00 02 bgeu r10,r3,800aef4 <_Heap_Get_information+0x6c>
info->largest = the_size;
800aef0: 58 23 00 04 sw (r1+4),r3
Heap_Block *the_block = the_heap->first_block;
Heap_Block *const end = the_heap->last_block;
memset(the_info, 0, sizeof(*the_info));
while ( the_block != end ) {
800aef4: 5d 04 ff f0 bne r8,r4,800aeb4 <_Heap_Get_information+0x2c>
800aef8: c3 a0 00 00 ret
08012e74 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
8012e74: 37 9c ff f0 addi sp,sp,-16
8012e78: 5b 8b 00 10 sw (sp+16),r11
8012e7c: 5b 8c 00 0c sw (sp+12),r12
8012e80: 5b 8d 00 08 sw (sp+8),r13
8012e84: 5b 9d 00 04 sw (sp+4),ra
8012e88: 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);
8012e8c: 28 22 00 10 lw r2,(r1+16)
8012e90: b8 20 58 00 mv r11,r1
8012e94: b9 80 08 00 mv r1,r12
8012e98: b8 60 68 00 mv r13,r3
8012e9c: fb ff fd 6b calli 8012448 <__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
8012ea0: 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);
8012ea4: 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);
8012ea8: 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;
8012eac: 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;
8012eb0: 54 44 00 10 bgu r2,r4,8012ef0 <_Heap_Size_of_alloc_area+0x7c>
8012eb4: 29 65 00 24 lw r5,(r11+36)
8012eb8: 54 85 00 0e bgu r4,r5,8012ef0 <_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;
8012ebc: 28 86 00 04 lw r6,(r4+4)
8012ec0: 34 03 ff fe mvi r3,-2
8012ec4: 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);
8012ec8: 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;
8012ecc: 54 44 00 09 bgu r2,r4,8012ef0 <_Heap_Size_of_alloc_area+0x7c><== NEVER TAKEN
8012ed0: 54 85 00 08 bgu r4,r5,8012ef0 <_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;
8012ed4: 28 82 00 04 lw r2,(r4+4)
8012ed8: 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 )
8012edc: 44 40 00 05 be r2,r0,8012ef0 <_Heap_Size_of_alloc_area+0x7c><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
8012ee0: c8 8c 20 00 sub r4,r4,r12
8012ee4: 34 84 00 04 addi r4,r4,4
8012ee8: 59 a4 00 00 sw (r13+0),r4
return true;
8012eec: 34 01 00 01 mvi r1,1
}
8012ef0: 2b 9d 00 04 lw ra,(sp+4)
8012ef4: 2b 8b 00 10 lw r11,(sp+16)
8012ef8: 2b 8c 00 0c lw r12,(sp+12)
8012efc: 2b 8d 00 08 lw r13,(sp+8)
8012f00: 37 9c 00 10 addi sp,sp,16
8012f04: c3 a0 00 00 ret
08004e78 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
8004e78: 37 9c ff 9c addi sp,sp,-100
8004e7c: 5b 8b 00 50 sw (sp+80),r11
8004e80: 5b 8c 00 4c sw (sp+76),r12
8004e84: 5b 8d 00 48 sw (sp+72),r13
8004e88: 5b 8e 00 44 sw (sp+68),r14
8004e8c: 5b 8f 00 40 sw (sp+64),r15
8004e90: 5b 90 00 3c sw (sp+60),r16
8004e94: 5b 91 00 38 sw (sp+56),r17
8004e98: 5b 92 00 34 sw (sp+52),r18
8004e9c: 5b 93 00 30 sw (sp+48),r19
8004ea0: 5b 94 00 2c sw (sp+44),r20
8004ea4: 5b 95 00 28 sw (sp+40),r21
8004ea8: 5b 96 00 24 sw (sp+36),r22
8004eac: 5b 97 00 20 sw (sp+32),r23
8004eb0: 5b 98 00 1c sw (sp+28),r24
8004eb4: 5b 99 00 18 sw (sp+24),r25
8004eb8: 5b 9b 00 14 sw (sp+20),fp
8004ebc: 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;
8004ec0: 78 0f 08 00 mvhi r15,0x800
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
8004ec4: 20 63 00 ff andi r3,r3,0xff
8004ec8: b8 20 68 00 mv r13,r1
8004ecc: b8 40 98 00 mv r19,r2
uintptr_t const page_size = heap->page_size;
8004ed0: 28 35 00 10 lw r21,(r1+16)
uintptr_t const min_block_size = heap->min_block_size;
8004ed4: 28 36 00 14 lw r22,(r1+20)
Heap_Block *const first_block = heap->first_block;
8004ed8: 28 34 00 20 lw r20,(r1+32)
Heap_Block *const last_block = heap->last_block;
8004edc: 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;
8004ee0: 39 ef 4d d0 ori r15,r15,0x4dd0
8004ee4: 44 60 00 03 be r3,r0,8004ef0 <_Heap_Walk+0x78>
8004ee8: 78 0f 08 00 mvhi r15,0x800
8004eec: 39 ef 4d f4 ori r15,r15,0x4df4
if ( !_System_state_Is_up( _System_state_Get() ) ) {
8004ef0: 78 03 08 01 mvhi r3,0x801
8004ef4: 38 63 7a 68 ori r3,r3,0x7a68
8004ef8: 28 69 00 00 lw r9,(r3+0)
8004efc: 34 07 00 03 mvi r7,3
return true;
8004f00: 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() ) ) {
8004f04: 45 27 00 15 be r9,r7,8004f58 <_Heap_Walk+0xe0>
block = next_block;
} while ( block != first_block );
return true;
}
8004f08: b8 60 08 00 mv r1,r3
8004f0c: 2b 9d 00 10 lw ra,(sp+16)
8004f10: 2b 8b 00 50 lw r11,(sp+80)
8004f14: 2b 8c 00 4c lw r12,(sp+76)
8004f18: 2b 8d 00 48 lw r13,(sp+72)
8004f1c: 2b 8e 00 44 lw r14,(sp+68)
8004f20: 2b 8f 00 40 lw r15,(sp+64)
8004f24: 2b 90 00 3c lw r16,(sp+60)
8004f28: 2b 91 00 38 lw r17,(sp+56)
8004f2c: 2b 92 00 34 lw r18,(sp+52)
8004f30: 2b 93 00 30 lw r19,(sp+48)
8004f34: 2b 94 00 2c lw r20,(sp+44)
8004f38: 2b 95 00 28 lw r21,(sp+40)
8004f3c: 2b 96 00 24 lw r22,(sp+36)
8004f40: 2b 97 00 20 lw r23,(sp+32)
8004f44: 2b 98 00 1c lw r24,(sp+28)
8004f48: 2b 99 00 18 lw r25,(sp+24)
8004f4c: 2b 9b 00 14 lw fp,(sp+20)
8004f50: 37 9c 00 64 addi sp,sp,100
8004f54: 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)(
8004f58: 29 a2 00 08 lw r2,(r13+8)
8004f5c: 29 a1 00 0c lw r1,(r13+12)
8004f60: 29 a6 00 18 lw r6,(r13+24)
8004f64: 29 a7 00 1c lw r7,(r13+28)
8004f68: 78 03 08 01 mvhi r3,0x801
8004f6c: 5b 82 00 08 sw (sp+8),r2
8004f70: 5b 81 00 0c sw (sp+12),r1
8004f74: 5b 97 00 04 sw (sp+4),r23
8004f78: ba 60 08 00 mv r1,r19
8004f7c: 34 02 00 00 mvi r2,0
8004f80: 38 63 48 40 ori r3,r3,0x4840
8004f84: ba a0 20 00 mv r4,r21
8004f88: ba c0 28 00 mv r5,r22
8004f8c: ba 80 40 00 mv r8,r20
8004f90: 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 ) {
8004f94: 46 a0 00 26 be r21,r0,800502c <_Heap_Walk+0x1b4> <== NEVER TAKEN
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
8004f98: 22 ab 00 07 andi r11,r21,0x7
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
8004f9c: 5d 60 00 2b bne r11,r0,8005048 <_Heap_Walk+0x1d0> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8004fa0: ba c0 08 00 mv r1,r22
8004fa4: ba a0 10 00 mv r2,r21
8004fa8: fb ff ee 92 calli 80009f0 <__umodsi3>
8004fac: b8 20 60 00 mv r12,r1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
8004fb0: 5c 2b 00 2e bne r1,r11,8005068 <_Heap_Walk+0x1f0> <== NEVER TAKEN
8004fb4: 36 81 00 08 addi r1,r20,8
8004fb8: ba a0 10 00 mv r2,r21
8004fbc: fb ff ee 8d calli 80009f0 <__umodsi3>
8004fc0: b8 20 18 00 mv r3,r1
);
return false;
}
if (
8004fc4: 5c 2c 00 31 bne r1,r12,8005088 <_Heap_Walk+0x210> <== NEVER TAKEN
block = next_block;
} while ( block != first_block );
return true;
}
8004fc8: 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;
8004fcc: 21 81 00 01 andi r1,r12,0x1
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
8004fd0: 44 23 00 fe be r1,r3,80053c8 <_Heap_Walk+0x550> <== 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;
8004fd4: 2a e2 00 04 lw r2,(r23+4)
8004fd8: 34 01 ff fe mvi r1,-2
8004fdc: 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);
8004fe0: 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;
8004fe4: 28 22 00 04 lw r2,(r1+4)
8004fe8: 20 42 00 01 andi r2,r2,0x1
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
8004fec: 44 43 00 09 be r2,r3,8005010 <_Heap_Walk+0x198> <== NEVER TAKEN
);
return false;
}
if (
8004ff0: 46 81 00 2e be r20,r1,80050a8 <_Heap_Walk+0x230> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
8004ff4: 78 03 08 01 mvhi r3,0x801 <== NOT EXECUTED
8004ff8: 38 63 49 a8 ori r3,r3,0x49a8 <== NOT EXECUTED
8004ffc: ba 60 08 00 mv r1,r19 <== NOT EXECUTED
8005000: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
8005004: d9 e0 00 00 call r15 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
8005008: 34 03 00 00 mvi r3,0 <== NOT EXECUTED
800500c: e3 ff ff bf bi 8004f08 <_Heap_Walk+0x90> <== NOT EXECUTED
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
8005010: 78 03 08 01 mvhi r3,0x801
8005014: 38 63 49 90 ori r3,r3,0x4990
8005018: ba 60 08 00 mv r1,r19
800501c: 34 02 00 01 mvi r2,1
8005020: 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;
8005024: 34 03 00 00 mvi r3,0
8005028: e3 ff ff b8 bi 8004f08 <_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" );
800502c: 78 03 08 01 mvhi r3,0x801
8005030: 38 63 48 d4 ori r3,r3,0x48d4
8005034: ba 60 08 00 mv r1,r19
8005038: 34 02 00 01 mvi r2,1
800503c: 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;
8005040: 34 03 00 00 mvi r3,0
8005044: e3 ff ff b1 bi 8004f08 <_Heap_Walk+0x90>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
8005048: 78 03 08 01 mvhi r3,0x801
800504c: 38 63 48 e8 ori r3,r3,0x48e8
8005050: ba 60 08 00 mv r1,r19
8005054: 34 02 00 01 mvi r2,1
8005058: ba a0 20 00 mv r4,r21
800505c: 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;
8005060: 34 03 00 00 mvi r3,0
8005064: e3 ff ff a9 bi 8004f08 <_Heap_Walk+0x90>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
8005068: 78 03 08 01 mvhi r3,0x801
800506c: 38 63 49 08 ori r3,r3,0x4908
8005070: ba 60 08 00 mv r1,r19
8005074: 34 02 00 01 mvi r2,1
8005078: ba c0 20 00 mv r4,r22
800507c: 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;
8005080: 34 03 00 00 mvi r3,0
8005084: e3 ff ff a1 bi 8004f08 <_Heap_Walk+0x90>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
8005088: 78 03 08 01 mvhi r3,0x801
800508c: 38 63 49 2c ori r3,r3,0x492c
8005090: ba 60 08 00 mv r1,r19
8005094: 34 02 00 01 mvi r2,1
8005098: ba 80 20 00 mv r4,r20
800509c: 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;
80050a0: 34 03 00 00 mvi r3,0
80050a4: e3 ff ff 99 bi 8004f08 <_Heap_Walk+0x90>
block = next_block;
} while ( block != first_block );
return true;
}
80050a8: 29 b0 00 08 lw r16,(r13+8)
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
80050ac: 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 ) {
80050b0: 45 b0 00 2f be r13,r16,800516c <_Heap_Walk+0x2f4>
block = next_block;
} while ( block != first_block );
return true;
}
80050b4: 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;
80050b8: ba 00 58 00 mv r11,r16
80050bc: 55 d0 00 dc bgu r14,r16,800542c <_Heap_Walk+0x5b4> <== NEVER TAKEN
80050c0: 29 b8 00 24 lw r24,(r13+36)
80050c4: 56 18 00 da bgu r16,r24,800542c <_Heap_Walk+0x5b4> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
80050c8: 36 01 00 08 addi r1,r16,8
80050cc: ba 40 10 00 mv r2,r18
80050d0: fb ff ee 48 calli 80009f0 <__umodsi3>
);
return false;
}
if (
80050d4: 5c 20 00 de bne r1,r0,800544c <_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;
80050d8: 2a 03 00 04 lw r3,(r16+4)
80050dc: 34 02 ff fe mvi r2,-2
80050e0: 34 11 ff fe mvi r17,-2
80050e4: a0 43 10 00 and r2,r2,r3
block = next_block;
} while ( block != first_block );
return true;
}
80050e8: b6 02 10 00 add r2,r16,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;
80050ec: 28 42 00 04 lw r2,(r2+4)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
80050f0: b9 a0 18 00 mv r3,r13
80050f4: 20 42 00 01 andi r2,r2,0x1
80050f8: 44 41 00 12 be r2,r1,8005140 <_Heap_Walk+0x2c8> <== ALWAYS TAKEN
80050fc: e0 00 00 dc bi 800546c <_Heap_Walk+0x5f4> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
8005100: 2a 0b 00 08 lw r11,(r16+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 ) {
8005104: 45 ab 00 1b be r13,r11,8005170 <_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;
8005108: 55 cb 00 c9 bgu r14,r11,800542c <_Heap_Walk+0x5b4>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
800510c: 35 61 00 08 addi r1,r11,8
8005110: 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;
8005114: 55 78 00 c6 bgu r11,r24,800542c <_Heap_Walk+0x5b4> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8005118: fb ff ee 36 calli 80009f0 <__umodsi3>
);
return false;
}
if (
800511c: 5c 20 00 cc bne r1,r0,800544c <_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;
8005120: 29 64 00 04 lw r4,(r11+4)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
8005124: ba 00 18 00 mv r3,r16
8005128: b9 60 80 00 mv r16,r11
800512c: a2 24 20 00 and r4,r17,r4
block = next_block;
} while ( block != first_block );
return true;
}
8005130: 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;
8005134: 28 84 00 04 lw r4,(r4+4)
8005138: 20 84 00 01 andi r4,r4,0x1
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
800513c: 5c 81 00 cc bne r4,r1,800546c <_Heap_Walk+0x5f4>
);
return false;
}
if ( free_block->prev != prev_block ) {
8005140: 2a 07 00 0c lw r7,(r16+12)
8005144: 44 e3 ff ef be r7,r3,8005100 <_Heap_Walk+0x288>
(*printer)(
8005148: 78 03 08 01 mvhi r3,0x801
800514c: 38 63 4a 44 ori r3,r3,0x4a44
8005150: ba 60 08 00 mv r1,r19
8005154: 34 02 00 01 mvi r2,1
8005158: ba 00 20 00 mv r4,r16
800515c: b8 e0 28 00 mv r5,r7
8005160: 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;
8005164: 34 03 00 00 mvi r3,0
8005168: e3 ff ff 68 bi 8004f08 <_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 ) {
800516c: 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)(
8005170: 78 01 08 01 mvhi r1,0x801
8005174: 5b 81 00 54 sw (sp+84),r1
8005178: 78 01 08 01 mvhi r1,0x801
800517c: 5b 81 00 58 sw (sp+88),r1
8005180: 78 01 08 01 mvhi r1,0x801
8005184: 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)" : "")
8005188: 78 01 08 01 mvhi r1,0x801
800518c: 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)" : ""),
8005190: 78 01 08 01 mvhi r1,0x801
8005194: 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)(
8005198: 2b 81 00 54 lw r1,(sp+84)
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
800519c: 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)(
80051a0: 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)(
80051a4: 38 21 48 08 ori r1,r1,0x4808
80051a8: 5b 81 00 54 sw (sp+84),r1
80051ac: 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)" : "")
80051b0: 78 18 08 01 mvhi r24,0x801
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
80051b4: 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)(
80051b8: 38 21 48 24 ori r1,r1,0x4824
80051bc: 5b 81 00 58 sw (sp+88),r1
80051c0: 2b 81 00 5c lw r1,(sp+92)
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
80051c4: 3b 7b 4b f4 ori fp,fp,0x4bf4
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
80051c8: 3b 39 4b dc ori r25,r25,0x4bdc
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)(
80051cc: 38 21 4b 38 ori r1,r1,0x4b38
80051d0: 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)" : "")
80051d4: 2b 81 00 60 lw r1,(sp+96)
80051d8: 3b 18 4b a8 ori r24,r24,0x4ba8
80051dc: 38 21 48 34 ori r1,r1,0x4834
80051e0: 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)" : ""),
80051e4: 2b 81 00 64 lw r1,(sp+100)
80051e8: 38 21 48 18 ori r1,r1,0x4818
80051ec: 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;
80051f0: 34 01 ff fe mvi r1,-2
80051f4: 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);
80051f8: 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;
80051fc: 55 d0 00 7a bgu r14,r16,80053e4 <_Heap_Walk+0x56c> <== NEVER TAKEN
8005200: 29 a4 00 24 lw r4,(r13+36)
8005204: 56 04 00 78 bgu r16,r4,80053e4 <_Heap_Walk+0x56c>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
8005208: ba 40 08 00 mv r1,r18
800520c: 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;
8005210: fe 37 58 00 cmpne r11,r17,r23
8005214: fb ff ed f7 calli 80009f0 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
8005218: 44 20 00 02 be r1,r0,8005220 <_Heap_Walk+0x3a8>
800521c: 5d 60 00 15 bne r11,r0,8005270 <_Heap_Walk+0x3f8>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
8005220: 52 56 00 02 bgeu r18,r22,8005228 <_Heap_Walk+0x3b0>
8005224: 5d 60 00 1c bne r11,r0,8005294 <_Heap_Walk+0x41c> <== ALWAYS TAKEN
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
8005228: 56 11 00 02 bgu r16,r17,8005230 <_Heap_Walk+0x3b8>
800522c: 5d 60 00 77 bne r11,r0,8005408 <_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;
8005230: 2a 06 00 04 lw r6,(r16+4)
8005234: 21 8c 00 01 andi r12,r12,0x1
8005238: 20 c6 00 01 andi r6,r6,0x1
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
800523c: 44 c0 00 28 be r6,r0,80052dc <_Heap_Walk+0x464>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
8005240: 45 80 00 1f be r12,r0,80052bc <_Heap_Walk+0x444>
(*printer)(
8005244: ba 60 08 00 mv r1,r19
8005248: 34 02 00 00 mvi r2,0
800524c: bb 20 18 00 mv r3,r25
8005250: ba 20 20 00 mv r4,r17
8005254: ba 40 28 00 mv r5,r18
8005258: d9 e0 00 00 call r15
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
800525c: 46 90 00 43 be r20,r16,8005368 <_Heap_Walk+0x4f0>
8005260: 2a 0c 00 04 lw r12,(r16+4)
8005264: 29 ae 00 20 lw r14,(r13+32)
8005268: ba 00 88 00 mv r17,r16
800526c: e3 ff ff e1 bi 80051f0 <_Heap_Walk+0x378>
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
8005270: 78 03 08 01 mvhi r3,0x801
8005274: 38 63 4a a8 ori r3,r3,0x4aa8
8005278: ba 60 08 00 mv r1,r19
800527c: 34 02 00 01 mvi r2,1
8005280: ba 20 20 00 mv r4,r17
8005284: ba 40 28 00 mv r5,r18
8005288: d9 e0 00 00 call r15
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
800528c: 34 03 00 00 mvi r3,0
8005290: e3 ff ff 1e bi 8004f08 <_Heap_Walk+0x90>
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
8005294: 78 03 08 01 mvhi r3,0x801
8005298: 38 63 4a d8 ori r3,r3,0x4ad8
800529c: ba 60 08 00 mv r1,r19
80052a0: 34 02 00 01 mvi r2,1
80052a4: ba 20 20 00 mv r4,r17
80052a8: ba 40 28 00 mv r5,r18
80052ac: ba c0 30 00 mv r6,r22
80052b0: d9 e0 00 00 call r15
block,
block_size,
min_block_size
);
return false;
80052b4: 34 03 00 00 mvi r3,0
80052b8: e3 ff ff 14 bi 8004f08 <_Heap_Walk+0x90>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
80052bc: 2a 26 00 00 lw r6,(r17+0)
80052c0: ba 20 20 00 mv r4,r17
80052c4: ba 60 08 00 mv r1,r19
80052c8: 34 02 00 00 mvi r2,0
80052cc: bb 60 18 00 mv r3,fp
80052d0: ba 40 28 00 mv r5,r18
80052d4: d9 e0 00 00 call r15
80052d8: e3 ff ff e1 bi 800525c <_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 ?
80052dc: 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)(
80052e0: 29 a4 00 08 lw r4,(r13+8)
block = next_block;
} while ( block != first_block );
return true;
}
80052e4: 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)(
80052e8: 2b 87 00 54 lw r7,(sp+84)
80052ec: 44 86 00 03 be r4,r6,80052f8 <_Heap_Walk+0x480>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
80052f0: bb 00 38 00 mv r7,r24
80052f4: 45 a6 00 29 be r13,r6,8005398 <_Heap_Walk+0x520>
block->next,
block->next == last_free_block ?
80052f8: 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)(
80052fc: 2b 84 00 58 lw r4,(sp+88)
8005300: 44 a8 00 03 be r5,r8,800530c <_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)" : "")
8005304: bb 00 20 00 mv r4,r24
8005308: 45 a8 00 26 be r13,r8,80053a0 <_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)(
800530c: 2b 83 00 5c lw r3,(sp+92)
8005310: 5b 84 00 04 sw (sp+4),r4
8005314: ba 60 08 00 mv r1,r19
8005318: 34 02 00 00 mvi r2,0
800531c: ba 20 20 00 mv r4,r17
8005320: ba 40 28 00 mv r5,r18
8005324: 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 ) {
8005328: 2a 06 00 00 lw r6,(r16+0)
800532c: 5e 46 00 11 bne r18,r6,8005370 <_Heap_Walk+0x4f8>
);
return false;
}
if ( !prev_used ) {
8005330: 45 80 00 1e be r12,r0,80053a8 <_Heap_Walk+0x530>
block = next_block;
} while ( block != first_block );
return true;
}
8005334: 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 ) {
8005338: 45 a5 00 04 be r13,r5,8005348 <_Heap_Walk+0x4d0> <== NEVER TAKEN
if ( free_block == block ) {
800533c: 46 25 ff c8 be r17,r5,800525c <_Heap_Walk+0x3e4>
return true;
}
free_block = free_block->next;
8005340: 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 ) {
8005344: 5d a5 ff fe bne r13,r5,800533c <_Heap_Walk+0x4c4>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
8005348: 78 03 08 01 mvhi r3,0x801
800534c: 38 63 4c 1c ori r3,r3,0x4c1c
8005350: ba 60 08 00 mv r1,r19
8005354: 34 02 00 01 mvi r2,1
8005358: ba 20 20 00 mv r4,r17
800535c: 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;
8005360: 34 03 00 00 mvi r3,0
8005364: e3 ff fe e9 bi 8004f08 <_Heap_Walk+0x90>
}
block = next_block;
} while ( block != first_block );
return true;
8005368: 34 03 00 01 mvi r3,1
800536c: e3 ff fe e7 bi 8004f08 <_Heap_Walk+0x90>
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
8005370: 78 03 08 01 mvhi r3,0x801
8005374: 38 63 4b 70 ori r3,r3,0x4b70
8005378: ba 60 08 00 mv r1,r19
800537c: 34 02 00 01 mvi r2,1
8005380: ba 20 20 00 mv r4,r17
8005384: ba 40 28 00 mv r5,r18
8005388: ba 00 38 00 mv r7,r16
800538c: 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;
8005390: 34 03 00 00 mvi r3,0
8005394: e3 ff fe dd bi 8004f08 <_Heap_Walk+0x90>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
8005398: 2b 87 00 64 lw r7,(sp+100)
800539c: e3 ff ff d7 bi 80052f8 <_Heap_Walk+0x480>
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
80053a0: 2b 84 00 60 lw r4,(sp+96)
80053a4: e3 ff ff da bi 800530c <_Heap_Walk+0x494>
return false;
}
if ( !prev_used ) {
(*printer)(
80053a8: 78 03 08 01 mvhi r3,0x801
80053ac: 38 63 4b ac ori r3,r3,0x4bac
80053b0: ba 60 08 00 mv r1,r19
80053b4: 34 02 00 01 mvi r2,1
80053b8: ba 20 20 00 mv r4,r17
80053bc: 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;
80053c0: 34 03 00 00 mvi r3,0
80053c4: e3 ff fe d1 bi 8004f08 <_Heap_Walk+0x90>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
80053c8: 78 03 08 01 mvhi r3,0x801
80053cc: 38 63 49 60 ori r3,r3,0x4960
80053d0: ba 60 08 00 mv r1,r19
80053d4: 34 02 00 01 mvi r2,1
80053d8: 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;
80053dc: 34 03 00 00 mvi r3,0
80053e0: e3 ff fe ca bi 8004f08 <_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)(
80053e4: 78 03 08 01 mvhi r3,0x801
80053e8: 38 63 4a 78 ori r3,r3,0x4a78
80053ec: ba 60 08 00 mv r1,r19
80053f0: 34 02 00 01 mvi r2,1
80053f4: ba 20 20 00 mv r4,r17
80053f8: ba 00 28 00 mv r5,r16
80053fc: d9 e0 00 00 call r15
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
8005400: 34 03 00 00 mvi r3,0
8005404: e3 ff fe c1 bi 8004f08 <_Heap_Walk+0x90>
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
8005408: 78 03 08 01 mvhi r3,0x801
800540c: 38 63 4b 04 ori r3,r3,0x4b04
8005410: ba 60 08 00 mv r1,r19
8005414: 34 02 00 01 mvi r2,1
8005418: ba 20 20 00 mv r4,r17
800541c: ba 00 28 00 mv r5,r16
8005420: d9 e0 00 00 call r15
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
8005424: 34 03 00 00 mvi r3,0
8005428: e3 ff fe b8 bi 8004f08 <_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)(
800542c: 78 03 08 01 mvhi r3,0x801
8005430: 38 63 49 d8 ori r3,r3,0x49d8
8005434: ba 60 08 00 mv r1,r19
8005438: 34 02 00 01 mvi r2,1
800543c: b9 60 20 00 mv r4,r11
8005440: 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;
8005444: 34 03 00 00 mvi r3,0
8005448: e3 ff fe b0 bi 8004f08 <_Heap_Walk+0x90>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
800544c: 78 03 08 01 mvhi r3,0x801
8005450: 38 63 49 f8 ori r3,r3,0x49f8
8005454: ba 60 08 00 mv r1,r19
8005458: 34 02 00 01 mvi r2,1
800545c: b9 60 20 00 mv r4,r11
8005460: 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;
8005464: 34 03 00 00 mvi r3,0
8005468: e3 ff fe a8 bi 8004f08 <_Heap_Walk+0x90>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
800546c: 78 03 08 01 mvhi r3,0x801
8005470: 38 63 4a 28 ori r3,r3,0x4a28
8005474: ba 60 08 00 mv r1,r19
8005478: 34 02 00 01 mvi r2,1
800547c: b9 60 20 00 mv r4,r11
8005480: 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;
8005484: 34 03 00 00 mvi r3,0
8005488: e3 ff fe a0 bi 8004f08 <_Heap_Walk+0x90>
08003584 <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
8003584: 37 9c ff f4 addi sp,sp,-12
8003588: 5b 8b 00 0c sw (sp+12),r11
800358c: 5b 8c 00 08 sw (sp+8),r12
8003590: 5b 9d 00 04 sw (sp+4),ra
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
8003594: 78 0c 08 01 mvhi r12,0x801
8003598: 39 8c 51 a0 ori r12,r12,0x51a0
800359c: 29 81 00 00 lw r1,(r12+0)
80035a0: 44 20 00 09 be r1,r0,80035c4 <_IO_Initialize_all_drivers+0x40><== NEVER TAKEN
80035a4: 34 0b 00 00 mvi r11,0
(void) rtems_io_initialize( major, 0, NULL );
80035a8: b9 60 08 00 mv r1,r11
80035ac: 34 02 00 00 mvi r2,0
80035b0: 34 03 00 00 mvi r3,0
80035b4: f8 00 19 f4 calli 8009d84 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
80035b8: 29 81 00 00 lw r1,(r12+0)
80035bc: 35 6b 00 01 addi r11,r11,1
80035c0: 54 2b ff fa bgu r1,r11,80035a8 <_IO_Initialize_all_drivers+0x24>
(void) rtems_io_initialize( major, 0, NULL );
}
80035c4: 2b 9d 00 04 lw ra,(sp+4)
80035c8: 2b 8b 00 0c lw r11,(sp+12)
80035cc: 2b 8c 00 08 lw r12,(sp+8)
80035d0: 37 9c 00 0c addi sp,sp,12
80035d4: c3 a0 00 00 ret
08003464 <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
8003464: 37 9c ff e8 addi sp,sp,-24
8003468: 5b 8b 00 18 sw (sp+24),r11
800346c: 5b 8c 00 14 sw (sp+20),r12
8003470: 5b 8d 00 10 sw (sp+16),r13
8003474: 5b 8e 00 0c sw (sp+12),r14
8003478: 5b 8f 00 08 sw (sp+8),r15
800347c: 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 = Configuration.Device_driver_table;
8003480: 78 01 08 01 mvhi r1,0x801
8003484: 38 21 40 c4 ori r1,r1,0x40c4
drivers_in_table = Configuration.number_of_device_drivers;
8003488: 28 2b 00 34 lw r11,(r1+52)
number_of_drivers = Configuration.maximum_drivers;
800348c: 28 2e 00 30 lw r14,(r1+48)
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = Configuration.Device_driver_table;
8003490: 28 2d 00 38 lw r13,(r1+56)
/*
* 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 )
8003494: 51 6e 00 2e bgeu r11,r14,800354c <_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 )
8003498: b5 ce 60 00 add r12,r14,r14
800349c: b5 8e 60 00 add r12,r12,r14
80034a0: b5 8c 60 00 add r12,r12,r12
80034a4: b5 8c 60 00 add r12,r12,r12
80034a8: 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(
80034ac: b9 80 08 00 mv r1,r12
80034b0: f8 00 0e bc calli 8006fa0 <_Workspace_Allocate_or_fatal_error>
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
80034b4: 78 04 08 01 mvhi r4,0x801
/*
* 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 *)
80034b8: 78 0f 08 01 mvhi r15,0x801
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
80034bc: 38 84 51 a0 ori r4,r4,0x51a0
/*
* 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 *)
80034c0: 39 ef 51 a4 ori r15,r15,0x51a4
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
80034c4: 34 02 00 00 mvi r2,0
80034c8: 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;
80034cc: 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 *)
80034d0: 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(
80034d4: f8 00 29 37 calli 800d9b0 <memset>
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
80034d8: 45 60 00 15 be r11,r0,800352c <_IO_Manager_initialization+0xc8><== NEVER TAKEN
80034dc: 29 e5 00 00 lw r5,(r15+0)
80034e0: 34 03 00 00 mvi r3,0
80034e4: 34 04 00 00 mvi r4,0
* registration. The driver table is now allocated in the
* workspace.
*
*/
void _IO_Manager_initialization(void)
80034e8: 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];
80034ec: 28 26 00 00 lw r6,(r1+0)
* registration. The driver table is now allocated in the
* workspace.
*
*/
void _IO_Manager_initialization(void)
80034f0: 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++ )
80034f4: 34 84 00 01 addi r4,r4,1
_IO_Driver_address_table[index] = driver_table[index];
80034f8: 58 46 00 00 sw (r2+0),r6
80034fc: 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++ )
8003500: 34 63 00 18 addi r3,r3,24
_IO_Driver_address_table[index] = driver_table[index];
8003504: 58 46 00 04 sw (r2+4),r6
8003508: 28 26 00 08 lw r6,(r1+8)
800350c: 58 46 00 08 sw (r2+8),r6
8003510: 28 26 00 0c lw r6,(r1+12)
8003514: 58 46 00 0c sw (r2+12),r6
8003518: 28 26 00 10 lw r6,(r1+16)
800351c: 58 46 00 10 sw (r2+16),r6
8003520: 28 21 00 14 lw r1,(r1+20)
8003524: 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++ )
8003528: 55 64 ff f0 bgu r11,r4,80034e8 <_IO_Manager_initialization+0x84>
_IO_Driver_address_table[index] = driver_table[index];
}
800352c: 2b 9d 00 04 lw ra,(sp+4)
8003530: 2b 8b 00 18 lw r11,(sp+24)
8003534: 2b 8c 00 14 lw r12,(sp+20)
8003538: 2b 8d 00 10 lw r13,(sp+16)
800353c: 2b 8e 00 0c lw r14,(sp+12)
8003540: 2b 8f 00 08 lw r15,(sp+8)
8003544: 37 9c 00 18 addi sp,sp,24
8003548: 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;
800354c: 78 02 08 01 mvhi r2,0x801
_IO_Number_of_drivers = number_of_drivers;
8003550: 78 01 08 01 mvhi r1,0x801
* 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;
8003554: 38 42 51 a4 ori r2,r2,0x51a4
_IO_Number_of_drivers = number_of_drivers;
8003558: 38 21 51 a0 ori r1,r1,0x51a0
* 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;
800355c: 58 4d 00 00 sw (r2+0),r13
_IO_Number_of_drivers = number_of_drivers;
8003560: 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];
}
8003564: 2b 9d 00 04 lw ra,(sp+4)
8003568: 2b 8b 00 18 lw r11,(sp+24)
800356c: 2b 8c 00 14 lw r12,(sp+20)
8003570: 2b 8d 00 10 lw r13,(sp+16)
8003574: 2b 8e 00 0c lw r14,(sp+12)
8003578: 2b 8f 00 08 lw r15,(sp+8)
800357c: 37 9c 00 18 addi sp,sp,24
8003580: c3 a0 00 00 ret
080044cc <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
80044cc: 37 9c ff ec addi sp,sp,-20
80044d0: 5b 8b 00 14 sw (sp+20),r11
80044d4: 5b 8c 00 10 sw (sp+16),r12
80044d8: 5b 8d 00 0c sw (sp+12),r13
80044dc: 5b 8e 00 08 sw (sp+8),r14
80044e0: 5b 9d 00 04 sw (sp+4),ra
80044e4: 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 )
80044e8: 28 21 00 18 lw r1,(r1+24)
return NULL;
80044ec: 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 )
80044f0: 5c 20 00 09 bne r1,r0,8004514 <_Objects_Allocate+0x48> <== ALWAYS TAKEN
);
}
#endif
return the_object;
}
80044f4: b9 80 08 00 mv r1,r12
80044f8: 2b 9d 00 04 lw ra,(sp+4)
80044fc: 2b 8b 00 14 lw r11,(sp+20)
8004500: 2b 8c 00 10 lw r12,(sp+16)
8004504: 2b 8d 00 0c lw r13,(sp+12)
8004508: 2b 8e 00 08 lw r14,(sp+8)
800450c: 37 9c 00 14 addi sp,sp,20
8004510: 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 );
8004514: 35 6d 00 20 addi r13,r11,32
8004518: b9 a0 08 00 mv r1,r13
800451c: fb ff fc fb calli 8003908 <_Chain_Get>
8004520: b8 20 60 00 mv r12,r1
if ( information->auto_extend ) {
8004524: 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 );
8004528: b9 80 70 00 mv r14,r12
if ( information->auto_extend ) {
800452c: 44 20 ff f2 be r1,r0,80044f4 <_Objects_Allocate+0x28>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
8004530: 45 80 00 18 be r12,r0,8004590 <_Objects_Allocate+0xc4>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
8004534: 2d 83 00 0a lhu r3,(r12+10)
8004538: 2d 61 00 0a lhu r1,(r11+10)
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
800453c: 2d 62 00 14 lhu r2,(r11+20)
8004540: c8 61 08 00 sub r1,r3,r1
8004544: f8 00 37 b1 calli 8012408 <__udivsi3>
information->inactive_per_block[ block ]--;
8004548: 29 62 00 30 lw r2,(r11+48)
800454c: b4 21 08 00 add r1,r1,r1
8004550: b4 21 08 00 add r1,r1,r1
8004554: b4 41 08 00 add r1,r2,r1
8004558: 28 22 00 00 lw r2,(r1+0)
information->inactive--;
800455c: 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 ]--;
8004560: 34 42 ff ff addi r2,r2,-1
8004564: 58 22 00 00 sw (r1+0),r2
information->inactive--;
8004568: 34 61 ff ff addi r1,r3,-1
800456c: 0d 61 00 2c sh (r11+44),r1
);
}
#endif
return the_object;
}
8004570: b9 80 08 00 mv r1,r12
8004574: 2b 9d 00 04 lw ra,(sp+4)
8004578: 2b 8b 00 14 lw r11,(sp+20)
800457c: 2b 8c 00 10 lw r12,(sp+16)
8004580: 2b 8d 00 0c lw r13,(sp+12)
8004584: 2b 8e 00 08 lw r14,(sp+8)
8004588: 37 9c 00 14 addi sp,sp,20
800458c: 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 );
8004590: b9 60 08 00 mv r1,r11
8004594: f8 00 00 06 calli 80045ac <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
8004598: b9 a0 08 00 mv r1,r13
800459c: fb ff fc db calli 8003908 <_Chain_Get>
80045a0: b8 20 60 00 mv r12,r1
}
if ( the_object ) {
80045a4: 44 2e ff d4 be r1,r14,80044f4 <_Objects_Allocate+0x28>
80045a8: e3 ff ff e3 bi 8004534 <_Objects_Allocate+0x68>
080045ac <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
80045ac: 37 9c ff c8 addi sp,sp,-56
80045b0: 5b 8b 00 2c sw (sp+44),r11
80045b4: 5b 8c 00 28 sw (sp+40),r12
80045b8: 5b 8d 00 24 sw (sp+36),r13
80045bc: 5b 8e 00 20 sw (sp+32),r14
80045c0: 5b 8f 00 1c sw (sp+28),r15
80045c4: 5b 90 00 18 sw (sp+24),r16
80045c8: 5b 91 00 14 sw (sp+20),r17
80045cc: 5b 92 00 10 sw (sp+16),r18
80045d0: 5b 93 00 0c sw (sp+12),r19
80045d4: 5b 94 00 08 sw (sp+8),r20
80045d8: 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 )
80045dc: 28 2c 00 34 lw r12,(r1+52)
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
80045e0: 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 );
80045e4: 2c 30 00 0a lhu r16,(r1+10)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
80045e8: 45 80 00 aa be r12,r0,8004890 <_Objects_Extend_information+0x2e4>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
80045ec: 2c 2f 00 14 lhu r15,(r1+20)
80045f0: 2c 31 00 10 lhu r17,(r1+16)
80045f4: b9 e0 10 00 mv r2,r15
80045f8: ba 20 08 00 mv r1,r17
80045fc: f8 00 37 83 calli 8012408 <__udivsi3>
8004600: 20 2e ff ff andi r14,r1,0xffff
for ( ; block < block_count; block++ ) {
8004604: 45 c0 00 a9 be r14,r0,80048a8 <_Objects_Extend_information+0x2fc><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
8004608: 29 81 00 00 lw r1,(r12+0)
800460c: 44 20 00 ac be r1,r0,80048bc <_Objects_Extend_information+0x310><== NEVER TAKEN
8004610: b9 80 18 00 mv r3,r12
8004614: 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 );
8004618: ba 00 68 00 mv r13,r16
index_base = minimum_index;
block = 0;
800461c: 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++ ) {
8004620: 35 8c 00 01 addi r12,r12,1
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
8004624: 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++ ) {
8004628: 55 cc 00 81 bgu r14,r12,800482c <_Objects_Extend_information+0x280>
/*
* 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;
800462c: 34 12 00 01 mvi r18,1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
8004630: 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 ) {
8004634: 38 02 ff ff mvu r2,0xffff
8004638: 56 22 00 70 bgu r17,r2,80047f8 <_Objects_Extend_information+0x24c>
/*
* 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;
800463c: 29 62 00 18 lw r2,(r11+24)
8004640: f8 00 37 0d calli 8012274 <__mulsi3>
if ( information->auto_extend ) {
8004644: 41 62 00 12 lbu r2,(r11+18)
8004648: 44 40 00 7e be r2,r0,8004840 <_Objects_Extend_information+0x294>
new_object_block = _Workspace_Allocate( block_size );
800464c: f8 00 0a 41 calli 8006f50 <_Workspace_Allocate>
8004650: b8 20 78 00 mv r15,r1
if ( !new_object_block )
8004654: 44 20 00 69 be r1,r0,80047f8 <_Objects_Extend_information+0x24c>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
8004658: 46 40 00 41 be r18,r0,800475c <_Objects_Extend_information+0x1b0>
*/
/*
* Up the block count and maximum
*/
block_count++;
800465c: 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 *)) +
8004660: b4 21 98 00 add r19,r1,r1
8004664: b6 61 08 00 add r1,r19,r1
((maximum + minimum_index) * sizeof(Objects_Control *));
8004668: b6 21 08 00 add r1,r17,r1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
800466c: b4 30 08 00 add r1,r1,r16
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
8004670: b4 21 08 00 add r1,r1,r1
8004674: b4 21 08 00 add r1,r1,r1
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
8004678: f8 00 0a 36 calli 8006f50 <_Workspace_Allocate>
800467c: b8 20 90 00 mv r18,r1
if ( !object_blocks ) {
8004680: 44 20 00 94 be r1,r0,80048d0 <_Objects_Extend_information+0x324>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
8004684: 2d 62 00 10 lhu r2,(r11+16)
}
/*
* Break the block into the various sections.
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
8004688: b6 73 a0 00 add r20,r19,r19
800468c: b4 34 98 00 add r19,r1,r20
8004690: 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 ) {
8004694: 54 50 00 6e bgu r2,r16,800484c <_Objects_Extend_information+0x2a0>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
8004698: ba 80 20 00 mv r4,r20
800469c: 34 03 00 00 mvi r3,0
80046a0: 46 00 00 05 be r16,r0,80046b4 <_Objects_Extend_information+0x108><== NEVER TAKEN
local_table[ index ] = NULL;
80046a4: 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++ ) {
80046a8: 34 63 00 01 addi r3,r3,1
80046ac: 34 84 00 04 addi r4,r4,4
80046b0: 56 03 ff fd bgu r16,r3,80046a4 <_Objects_Extend_information+0xf8><== NEVER TAKEN
80046b4: b5 ce 70 00 add r14,r14,r14
80046b8: 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 );
80046bc: 2d 65 00 14 lhu r5,(r11+20)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
80046c0: b6 4e 08 00 add r1,r18,r14
80046c4: 58 20 00 00 sw (r1+0),r0
inactive_per_block[block_count] = 0;
80046c8: b6 6e 70 00 add r14,r19,r14
80046cc: 59 c0 00 00 sw (r14+0),r0
for ( index=index_base ;
index < ( information->allocation_size + index_base );
80046d0: 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 ;
80046d4: 51 a5 00 09 bgeu r13,r5,80046f8 <_Objects_Extend_information+0x14c><== NEVER TAKEN
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
80046d8: b5 ad 20 00 add r4,r13,r13
80046dc: 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 ;
80046e0: b6 84 20 00 add r4,r20,r4
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
80046e4: 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;
80046e8: 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++ ) {
80046ec: 34 63 00 01 addi r3,r3,1
80046f0: 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 ;
80046f4: 54 a3 ff fd bgu r5,r3,80046e8 <_Objects_Extend_information+0x13c>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
80046f8: 90 00 70 00 rcsr r14,IE
80046fc: 34 01 ff fe mvi r1,-2
8004700: a1 c1 08 00 and r1,r14,r1
8004704: 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) |
8004708: 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;
800470c: 22 31 ff ff andi r17,r17,0xffff
8004710: 0d 71 00 10 sh (r11+16),r17
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
8004714: 29 70 00 34 lw r16,(r11+52)
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
8004718: 59 73 00 30 sw (r11+48),r19
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
800471c: 59 72 00 34 sw (r11+52),r18
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
8004720: 59 74 00 1c sw (r11+28),r20
8004724: 34 02 00 18 mvi r2,24
8004728: f8 00 36 5e calli 80120a0 <__ashlsi3>
800472c: 78 12 00 01 mvhi r18,0x1
8004730: b8 32 90 00 or r18,r1,r18
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
8004734: 2d 61 00 04 lhu r1,(r11+4)
8004738: 34 02 00 1b mvi r2,27
800473c: f8 00 36 59 calli 80120a0 <__ashlsi3>
8004740: ba 41 08 00 or r1,r18,r1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
8004744: b8 31 88 00 or r17,r1,r17
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
8004748: 59 71 00 0c sw (r11+12),r17
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
800474c: d0 0e 00 00 wcsr IE,r14
if ( old_tables )
8004750: 46 00 00 03 be r16,r0,800475c <_Objects_Extend_information+0x1b0>
_Workspace_Free( old_tables );
8004754: ba 00 08 00 mv r1,r16
8004758: f8 00 0a 09 calli 8006f7c <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
800475c: 29 61 00 34 lw r1,(r11+52)
8004760: b5 8c 60 00 add r12,r12,r12
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
8004764: 2d 63 00 14 lhu r3,(r11+20)
8004768: 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;
800476c: b5 8c 60 00 add r12,r12,r12
8004770: b4 2c 08 00 add r1,r1,r12
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
8004774: 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;
8004778: 58 2f 00 00 sw (r1+0),r15
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
800477c: b9 e0 10 00 mv r2,r15
8004780: ba 00 08 00 mv r1,r16
8004784: f8 00 15 99 calli 8009de8 <_Chain_Initialize>
8004788: 78 12 00 01 mvhi r18,0x1
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
800478c: 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 ) {
8004790: e0 00 00 0e bi 80047c8 <_Objects_Extend_information+0x21c>
8004794: 29 61 00 00 lw r1,(r11+0)
8004798: f8 00 36 42 calli 80120a0 <__ashlsi3>
800479c: b8 32 78 00 or r15,r1,r18
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
80047a0: 2d 61 00 04 lhu r1,(r11+4)
80047a4: 34 02 00 1b mvi r2,27
80047a8: f8 00 36 3e calli 80120a0 <__ashlsi3>
80047ac: 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) |
80047b0: b8 4d 10 00 or r2,r2,r13
the_object->id = _Objects_Build_id(
80047b4: 59 c2 00 08 sw (r14+8),r2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
80047b8: ba 20 08 00 mv r1,r17
80047bc: b9 c0 10 00 mv r2,r14
80047c0: fb ff fc 3c calli 80038b0 <_Chain_Append>
index++;
80047c4: 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 ) {
80047c8: ba 00 08 00 mv r1,r16
80047cc: fb ff fc 4f calli 8003908 <_Chain_Get>
80047d0: b8 20 70 00 mv r14,r1
80047d4: 34 02 00 18 mvi r2,24
80047d8: 5c 20 ff ef bne r1,r0,8004794 <_Objects_Extend_information+0x1e8>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
80047dc: 29 63 00 30 lw r3,(r11+48)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
80047e0: 2d 62 00 2c lhu r2,(r11+44)
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
80047e4: 2d 61 00 14 lhu r1,(r11+20)
80047e8: b4 6c 60 00 add r12,r3,r12
80047ec: 59 81 00 00 sw (r12+0),r1
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
80047f0: b4 22 08 00 add r1,r1,r2
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
80047f4: 0d 61 00 2c sh (r11+44),r1
(Objects_Maximum)(information->inactive + information->allocation_size);
}
80047f8: 2b 9d 00 04 lw ra,(sp+4)
80047fc: 2b 8b 00 2c lw r11,(sp+44)
8004800: 2b 8c 00 28 lw r12,(sp+40)
8004804: 2b 8d 00 24 lw r13,(sp+36)
8004808: 2b 8e 00 20 lw r14,(sp+32)
800480c: 2b 8f 00 1c lw r15,(sp+28)
8004810: 2b 90 00 18 lw r16,(sp+24)
8004814: 2b 91 00 14 lw r17,(sp+20)
8004818: 2b 92 00 10 lw r18,(sp+16)
800481c: 2b 93 00 0c lw r19,(sp+12)
8004820: 2b 94 00 08 lw r20,(sp+8)
8004824: 37 9c 00 38 addi sp,sp,56
8004828: 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 ) {
800482c: 28 62 00 04 lw r2,(r3+4)
8004830: 34 63 00 04 addi r3,r3,4
8004834: 5c 40 ff 7b bne r2,r0,8004620 <_Objects_Extend_information+0x74>
do_extend = false;
8004838: 34 12 00 00 mvi r18,0
800483c: e3 ff ff 7d bi 8004630 <_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 );
8004840: f8 00 09 d8 calli 8006fa0 <_Workspace_Allocate_or_fatal_error>
8004844: b8 20 78 00 mv r15,r1
8004848: e3 ff ff 84 bi 8004658 <_Objects_Extend_information+0xac>
/*
* 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,
800484c: 29 62 00 34 lw r2,(r11+52)
information->object_blocks,
block_count * sizeof(void*) );
8004850: b5 ce 70 00 add r14,r14,r14
8004854: 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,
8004858: b9 c0 18 00 mv r3,r14
800485c: f8 00 24 14 calli 800d8ac <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
8004860: 29 62 00 30 lw r2,(r11+48)
8004864: b9 c0 18 00 mv r3,r14
8004868: ba 60 08 00 mv r1,r19
800486c: f8 00 24 10 calli 800d8ac <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
8004870: 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,
8004874: 29 62 00 1c lw r2,(r11+28)
8004878: ba 80 08 00 mv r1,r20
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
800487c: b6 03 18 00 add r3,r16,r3
8004880: b4 63 18 00 add r3,r3,r3
8004884: 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,
8004888: f8 00 24 09 calli 800d8ac <memcpy>
800488c: e3 ff ff 8c bi 80046bc <_Objects_Extend_information+0x110>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
8004890: 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 );
8004894: ba 00 68 00 mv r13,r16
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
8004898: 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;
800489c: 34 12 00 01 mvi r18,1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
80048a0: 34 0e 00 00 mvi r14,0
80048a4: e3 ff ff 63 bi 8004630 <_Objects_Extend_information+0x84>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
80048a8: 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 );
80048ac: 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;
80048b0: 34 12 00 01 mvi r18,1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
80048b4: 34 0c 00 00 mvi r12,0 <== NOT EXECUTED
80048b8: e3 ff ff 5e bi 8004630 <_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 ) {
80048bc: 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 );
80048c0: 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;
80048c4: 34 12 00 00 mvi r18,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;
80048c8: 34 0c 00 00 mvi r12,0 <== NOT EXECUTED
80048cc: e3 ff ff 59 bi 8004630 <_Objects_Extend_information+0x84> <== NOT EXECUTED
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
80048d0: b9 e0 08 00 mv r1,r15
80048d4: f8 00 09 aa calli 8006f7c <_Workspace_Free>
return;
80048d8: e3 ff ff c8 bi 80047f8 <_Objects_Extend_information+0x24c>
080049c4 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
80049c4: 37 9c ff f0 addi sp,sp,-16
80049c8: 5b 8b 00 10 sw (sp+16),r11
80049cc: 5b 8c 00 0c sw (sp+12),r12
80049d0: 5b 8d 00 08 sw (sp+8),r13
80049d4: 5b 9d 00 04 sw (sp+4),ra
80049d8: 20 4c ff ff andi r12,r2,0xffff
80049dc: b8 20 68 00 mv r13,r1
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
80049e0: 34 0b 00 00 mvi r11,0
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
80049e4: 5d 80 00 08 bne r12,r0,8004a04 <_Objects_Get_information+0x40>
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
80049e8: b9 60 08 00 mv r1,r11
80049ec: 2b 9d 00 04 lw ra,(sp+4)
80049f0: 2b 8b 00 10 lw r11,(sp+16)
80049f4: 2b 8c 00 0c lw r12,(sp+12)
80049f8: 2b 8d 00 08 lw r13,(sp+8)
80049fc: 37 9c 00 10 addi sp,sp,16
8004a00: 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 );
8004a04: f8 00 16 9c calli 800a474 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
8004a08: 44 20 ff f8 be r1,r0,80049e8 <_Objects_Get_information+0x24>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
8004a0c: 55 81 ff f7 bgu r12,r1,80049e8 <_Objects_Get_information+0x24>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
8004a10: 78 01 08 01 mvhi r1,0x801
8004a14: b5 ad 68 00 add r13,r13,r13
8004a18: 38 21 48 44 ori r1,r1,0x4844
8004a1c: b5 ad 68 00 add r13,r13,r13
8004a20: b4 2d 08 00 add r1,r1,r13
8004a24: 28 21 00 00 lw r1,(r1+0)
8004a28: 44 20 ff f0 be r1,r0,80049e8 <_Objects_Get_information+0x24><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
8004a2c: b5 8c 60 00 add r12,r12,r12
8004a30: b5 8c 60 00 add r12,r12,r12
8004a34: b4 2c 08 00 add r1,r1,r12
8004a38: 28 2b 00 00 lw r11,(r1+0)
if ( !info )
8004a3c: 45 60 ff eb be r11,r0,80049e8 <_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 )
8004a40: 2d 61 00 10 lhu r1,(r11+16)
return NULL;
8004a44: 7c 21 00 00 cmpnei r1,r1,0
8004a48: c8 01 08 00 sub r1,r0,r1
8004a4c: a1 61 58 00 and r11,r11,r1
8004a50: e3 ff ff e6 bi 80049e8 <_Objects_Get_information+0x24>
08006a18 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
8006a18: 37 9c ff e0 addi sp,sp,-32
8006a1c: 5b 8b 00 14 sw (sp+20),r11
8006a20: 5b 8c 00 10 sw (sp+16),r12
8006a24: 5b 8d 00 0c sw (sp+12),r13
8006a28: 5b 8e 00 08 sw (sp+8),r14
8006a2c: 5b 9d 00 04 sw (sp+4),ra
8006a30: b8 40 60 00 mv r12,r2
8006a34: b8 60 58 00 mv r11,r3
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
8006a38: 5c 40 00 0a bne r2,r0,8006a60 <_Objects_Get_name_as_string+0x48>
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
8006a3c: 34 0b 00 00 mvi r11,0
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
8006a40: b9 60 08 00 mv r1,r11
8006a44: 2b 9d 00 04 lw ra,(sp+4)
8006a48: 2b 8b 00 14 lw r11,(sp+20)
8006a4c: 2b 8c 00 10 lw r12,(sp+16)
8006a50: 2b 8d 00 0c lw r13,(sp+12)
8006a54: 2b 8e 00 08 lw r14,(sp+8)
8006a58: 37 9c 00 20 addi sp,sp,32
8006a5c: c3 a0 00 00 ret
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
8006a60: 44 60 ff f8 be r3,r0,8006a40 <_Objects_Get_name_as_string+0x28>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
8006a64: b8 20 68 00 mv r13,r1
8006a68: 5c 20 00 05 bne r1,r0,8006a7c <_Objects_Get_name_as_string+0x64>
8006a6c: 78 01 08 02 mvhi r1,0x802
8006a70: 38 21 ab a4 ori r1,r1,0xaba4
8006a74: 28 21 00 0c lw r1,(r1+12)
8006a78: 28 2d 00 08 lw r13,(r1+8)
information = _Objects_Get_information_id( tmpId );
8006a7c: b9 a0 08 00 mv r1,r13
8006a80: fb ff ff 94 calli 80068d0 <_Objects_Get_information_id>
8006a84: b8 20 70 00 mv r14,r1
if ( !information )
8006a88: 44 20 ff ed be r1,r0,8006a3c <_Objects_Get_name_as_string+0x24>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
8006a8c: b9 a0 10 00 mv r2,r13
8006a90: 37 83 00 20 addi r3,sp,32
8006a94: f8 00 00 36 calli 8006b6c <_Objects_Get>
switch ( location ) {
8006a98: 2b 82 00 20 lw r2,(sp+32)
8006a9c: 5c 40 ff e8 bne r2,r0,8006a3c <_Objects_Get_name_as_string+0x24>
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
8006aa0: 41 c3 00 38 lbu r3,(r14+56)
8006aa4: 44 62 00 1c be r3,r2,8006b14 <_Objects_Get_name_as_string+0xfc>
s = the_object->name.name_p;
8006aa8: 28 27 00 0c lw r7,(r1+12)
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
8006aac: b9 60 08 00 mv r1,r11
8006ab0: 44 e0 00 16 be r7,r0,8006b08 <_Objects_Get_name_as_string+0xf0>
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
8006ab4: 35 8c ff ff addi r12,r12,-1
8006ab8: b9 60 08 00 mv r1,r11
8006abc: 45 80 00 13 be r12,r0,8006b08 <_Objects_Get_name_as_string+0xf0><== NEVER TAKEN
8006ac0: 40 e3 00 00 lbu r3,(r7+0)
8006ac4: 44 60 00 11 be r3,r0,8006b08 <_Objects_Get_name_as_string+0xf0>
8006ac8: 78 04 08 02 mvhi r4,0x802
8006acc: 34 02 00 00 mvi r2,0
8006ad0: 38 84 22 04 ori r4,r4,0x2204
*d = (isprint((unsigned char)*s)) ? *s : '*';
8006ad4: 28 85 00 00 lw r5,(r4+0)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
8006ad8: 34 42 00 01 addi r2,r2,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(
8006adc: b4 e2 30 00 add r6,r7,r2
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint((unsigned char)*s)) ? *s : '*';
8006ae0: b4 a3 28 00 add r5,r5,r3
8006ae4: 40 a5 00 01 lbu r5,(r5+1)
8006ae8: 20 a5 00 97 andi r5,r5,0x97
8006aec: 5c a0 00 02 bne r5,r0,8006af4 <_Objects_Get_name_as_string+0xdc>
8006af0: 34 03 00 2a mvi r3,42
8006af4: 30 23 00 00 sb (r1+0),r3
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
8006af8: 34 21 00 01 addi r1,r1,1
8006afc: 50 4c 00 03 bgeu r2,r12,8006b08 <_Objects_Get_name_as_string+0xf0>
8006b00: 40 c3 00 00 lbu r3,(r6+0)
8006b04: 5c 60 ff f4 bne r3,r0,8006ad4 <_Objects_Get_name_as_string+0xbc>
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
8006b08: 30 20 00 00 sb (r1+0),r0
_Thread_Enable_dispatch();
8006b0c: f8 00 03 43 calli 8007818 <_Thread_Enable_dispatch>
return name;
8006b10: e3 ff ff cc bi 8006a40 <_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;
8006b14: 28 2d 00 0c lw r13,(r1+12)
lname[ 0 ] = (u32_name >> 24) & 0xff;
8006b18: 34 02 00 18 mvi r2,24
8006b1c: b9 a0 08 00 mv r1,r13
8006b20: fb ff e9 a3 calli 80011ac <__lshrsi3>
8006b24: 33 81 00 18 sb (sp+24),r1
lname[ 1 ] = (u32_name >> 16) & 0xff;
8006b28: 34 02 00 10 mvi r2,16
8006b2c: b9 a0 08 00 mv r1,r13
8006b30: fb ff e9 9f calli 80011ac <__lshrsi3>
lname[ 2 ] = (u32_name >> 8) & 0xff;
8006b34: 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;
8006b38: 33 81 00 19 sb (sp+25),r1
lname[ 2 ] = (u32_name >> 8) & 0xff;
8006b3c: 00 42 00 01 srui r2,r2,1
lname[ 3 ] = (u32_name >> 0) & 0xff;
8006b40: 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;
8006b44: 00 42 00 01 srui r2,r2,1
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
8006b48: 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;
8006b4c: 00 42 00 01 srui r2,r2,1
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
s = lname;
8006b50: 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;
8006b54: 00 42 00 01 srui r2,r2,1
8006b58: 00 42 00 01 srui r2,r2,1
8006b5c: 00 42 00 01 srui r2,r2,1
8006b60: 00 42 00 01 srui r2,r2,1
8006b64: 33 82 00 1a sb (sp+26),r2
8006b68: e3 ff ff d3 bi 8006ab4 <_Objects_Get_name_as_string+0x9c>
0801763c <_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;
801763c: 28 25 00 08 lw r5,(r1+8)
if ( information->maximum >= index ) {
8017640: 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;
8017644: c8 45 10 00 sub r2,r2,r5
8017648: 34 42 00 01 addi r2,r2,1
if ( information->maximum >= index ) {
801764c: 54 44 00 09 bgu r2,r4,8017670 <_Objects_Get_no_protection+0x34>
if ( (the_object = information->local_table[ index ]) != NULL ) {
8017650: 28 24 00 1c lw r4,(r1+28)
8017654: b4 42 08 00 add r1,r2,r2
8017658: b4 21 08 00 add r1,r1,r1
801765c: b4 81 08 00 add r1,r4,r1
8017660: 28 21 00 00 lw r1,(r1+0)
8017664: 44 20 00 03 be r1,r0,8017670 <_Objects_Get_no_protection+0x34><== NEVER TAKEN
*location = OBJECTS_LOCAL;
8017668: 58 60 00 00 sw (r3+0),r0
return the_object;
801766c: 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;
8017670: 34 01 00 01 mvi r1,1
8017674: 58 61 00 00 sw (r3+0),r1
return NULL;
8017678: 34 01 00 00 mvi r1,0
}
801767c: c3 a0 00 00 ret
08006558 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
8006558: 37 9c ff e8 addi sp,sp,-24
800655c: 5b 8b 00 14 sw (sp+20),r11
8006560: 5b 8c 00 10 sw (sp+16),r12
8006564: 5b 8d 00 0c sw (sp+12),r13
8006568: 5b 8e 00 08 sw (sp+8),r14
800656c: 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;
8006570: b8 20 58 00 mv r11,r1
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
8006574: b8 40 70 00 mv r14,r2
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
8006578: 5c 20 00 05 bne r1,r0,800658c <_Objects_Id_to_name+0x34>
800657c: 78 01 08 02 mvhi r1,0x802
8006580: 38 21 0d cc ori r1,r1,0xdcc
8006584: 28 21 00 0c lw r1,(r1+12)
8006588: 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);
800658c: b9 60 08 00 mv r1,r11
8006590: 34 02 00 18 mvi r2,24
8006594: f8 00 58 3b calli 801c680 <__lshrsi3>
8006598: 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 )
800659c: 34 64 ff ff addi r4,r3,-1
80065a0: 34 01 00 02 mvi r1,2
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
80065a4: 34 0c 00 03 mvi r12,3
80065a8: 54 81 00 12 bgu r4,r1,80065f0 <_Objects_Id_to_name+0x98>
if ( !_Objects_Information_table[ the_api ] )
80065ac: 78 04 08 02 mvhi r4,0x802
80065b0: b4 63 18 00 add r3,r3,r3
80065b4: 38 84 08 9c ori r4,r4,0x89c
80065b8: b4 63 18 00 add r3,r3,r3
80065bc: b4 83 18 00 add r3,r4,r3
80065c0: 28 6d 00 00 lw r13,(r3+0)
80065c4: 45 a0 00 0b be r13,r0,80065f0 <_Objects_Id_to_name+0x98>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
80065c8: b9 60 08 00 mv r1,r11
80065cc: 34 02 00 1b mvi r2,27
80065d0: f8 00 58 2c calli 801c680 <__lshrsi3>
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
80065d4: b4 21 18 00 add r3,r1,r1
80065d8: b4 63 18 00 add r3,r3,r3
80065dc: b5 a3 18 00 add r3,r13,r3
80065e0: 28 63 00 00 lw r3,(r3+0)
if ( !information )
80065e4: 44 60 00 03 be r3,r0,80065f0 <_Objects_Id_to_name+0x98> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
80065e8: 40 6d 00 38 lbu r13,(r3+56)
80065ec: 45 a0 00 09 be r13,r0,8006610 <_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;
}
80065f0: b9 80 08 00 mv r1,r12
80065f4: 2b 9d 00 04 lw ra,(sp+4)
80065f8: 2b 8b 00 14 lw r11,(sp+20)
80065fc: 2b 8c 00 10 lw r12,(sp+16)
8006600: 2b 8d 00 0c lw r13,(sp+12)
8006604: 2b 8e 00 08 lw r14,(sp+8)
8006608: 37 9c 00 18 addi sp,sp,24
800660c: 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 );
8006610: b8 60 08 00 mv r1,r3
8006614: b9 60 10 00 mv r2,r11
8006618: 37 83 00 18 addi r3,sp,24
800661c: fb ff ff a9 calli 80064c0 <_Objects_Get>
if ( !the_object )
8006620: 44 2d ff f4 be r1,r13,80065f0 <_Objects_Id_to_name+0x98>
return OBJECTS_INVALID_ID;
*name = the_object->name;
8006624: 28 21 00 0c lw r1,(r1+12)
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
8006628: 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;
800662c: 59 c1 00 00 sw (r14+0),r1
_Thread_Enable_dispatch();
8006630: f8 00 03 77 calli 800740c <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
8006634: b9 80 08 00 mv r1,r12
8006638: 2b 9d 00 04 lw ra,(sp+4)
800663c: 2b 8b 00 14 lw r11,(sp+20)
8006640: 2b 8c 00 10 lw r12,(sp+16)
8006644: 2b 8d 00 0c lw r13,(sp+12)
8006648: 2b 8e 00 08 lw r14,(sp+8)
800664c: 37 9c 00 18 addi sp,sp,24
8006650: c3 a0 00 00 ret
08004b58 <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
8004b58: 37 9c ff e8 addi sp,sp,-24
8004b5c: 5b 8b 00 18 sw (sp+24),r11
8004b60: 5b 8c 00 14 sw (sp+20),r12
8004b64: 5b 8d 00 10 sw (sp+16),r13
8004b68: 5b 8e 00 0c sw (sp+12),r14
8004b6c: 5b 8f 00 08 sw (sp+8),r15
8004b70: 5b 9d 00 04 sw (sp+4),ra
8004b74: b8 40 68 00 mv r13,r2
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
8004b78: b5 ad 40 00 add r8,r13,r13
8004b7c: 78 02 08 01 mvhi r2,0x801
8004b80: 38 42 48 44 ori r2,r2,0x4844
8004b84: b5 08 40 00 add r8,r8,r8
8004b88: b4 48 40 00 add r8,r2,r8
8004b8c: 29 02 00 00 lw r2,(r8+0)
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
8004b90: 20 6c ff ff andi r12,r3,0xffff
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
8004b94: b5 8c 40 00 add r8,r12,r12
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
8004b98: 20 a5 ff ff andi r5,r5,0xffff
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
8004b9c: b5 08 40 00 add r8,r8,r8
uint32_t maximum_per_allocation;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
8004ba0: 58 2d 00 00 sw (r1+0),r13
information->the_class = the_class;
8004ba4: 0c 2c 00 04 sh (r1+4),r12
information->size = size;
8004ba8: 58 25 00 18 sw (r1+24),r5
information->local_table = 0;
8004bac: 58 20 00 1c sw (r1+28),r0
information->inactive_per_block = 0;
8004bb0: 58 20 00 30 sw (r1+48),r0
information->object_blocks = 0;
8004bb4: 58 20 00 34 sw (r1+52),r0
information->inactive = 0;
8004bb8: 0c 20 00 2c sh (r1+44),r0
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
information->is_string = is_string;
8004bbc: 30 26 00 38 sb (r1+56),r6
/*
* Set the maximum value to 0. It will be updated when objects are
* added to the inactive set from _Objects_Extend_information()
*/
information->maximum = 0;
8004bc0: 0c 20 00 10 sh (r1+16),r0
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
8004bc4: b4 48 40 00 add r8,r2,r8
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
8004bc8: b8 20 58 00 mv r11,r1
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
8004bcc: 59 01 00 00 sw (r8+0),r1
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
8004bd0: 34 02 00 1f mvi r2,31
8004bd4: b8 80 08 00 mv r1,r4
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
8004bd8: b8 80 70 00 mv r14,r4
8004bdc: b8 e0 78 00 mv r15,r7
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
8004be0: f8 00 35 7e calli 80121d8 <__lshrsi3>
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
8004be4: 78 03 08 01 mvhi r3,0x801
8004be8: 38 63 36 24 ori r3,r3,0x3624
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
8004bec: 20 22 00 ff andi r2,r1,0xff
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
8004bf0: 28 61 00 00 lw r1,(r3+0)
_Objects_Information_table[ the_api ][ the_class ] = information;
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
8004bf4: 31 62 00 12 sb (r11+18),r2
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
8004bf8: a1 c1 70 00 and r14,r14,r1
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
8004bfc: 44 40 00 02 be r2,r0,8004c04 <_Objects_Initialize_information+0xac>
8004c00: 45 c0 00 29 be r14,r0,8004ca4 <_Objects_Initialize_information+0x14c><== NEVER TAKEN
information->allocation_size = maximum_per_allocation;
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
8004c04: 78 01 08 01 mvhi r1,0x801
8004c08: 38 21 46 b4 ori r1,r1,0x46b4
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
8004c0c: 34 02 00 18 mvi r2,24
8004c10: 59 61 00 1c sw (r11+28),r1
}
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum_per_allocation;
8004c14: 0d 6e 00 14 sh (r11+20),r14
8004c18: b9 a0 08 00 mv r1,r13
8004c1c: f8 00 35 21 calli 80120a0 <__ashlsi3>
8004c20: 78 0d 00 01 mvhi r13,0x1
8004c24: b8 2d 68 00 or r13,r1,r13
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
8004c28: 34 02 00 1b mvi r2,27
8004c2c: b9 80 08 00 mv r1,r12
8004c30: f8 00 35 1c calli 80120a0 <__ashlsi3>
information->local_table = &null_local_table;
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
8004c34: 7d c2 00 00 cmpnei r2,r14,0
8004c38: b9 a1 08 00 or r1,r13,r1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
8004c3c: b8 22 08 00 or r1,r1,r2
information->minimum_id =
8004c40: 59 61 00 08 sw (r11+8),r1
/*
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
8004c44: 21 e1 00 03 andi r1,r15,0x3
8004c48: b9 e0 38 00 mv r7,r15
8004c4c: 5c 20 00 12 bne r1,r0,8004c94 <_Objects_Initialize_information+0x13c>
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 );
8004c50: 35 62 00 24 addi r2,r11,36
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
8004c54: 35 61 00 20 addi r1,r11,32
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
~(OBJECTS_NAME_ALIGNMENT-1);
information->name_length = name_length;
8004c58: 0d 67 00 3a sh (r11+58),r7
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8004c5c: 59 62 00 20 sw (r11+32),r2
head->previous = NULL;
8004c60: 59 60 00 24 sw (r11+36),r0
tail->previous = head;
8004c64: 59 61 00 28 sw (r11+40),r1
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
8004c68: 45 c0 00 03 be r14,r0,8004c74 <_Objects_Initialize_information+0x11c>
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
8004c6c: b9 60 08 00 mv r1,r11
8004c70: fb ff fe 4f calli 80045ac <_Objects_Extend_information>
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
8004c74: 2b 9d 00 04 lw ra,(sp+4)
8004c78: 2b 8b 00 18 lw r11,(sp+24)
8004c7c: 2b 8c 00 14 lw r12,(sp+20)
8004c80: 2b 8d 00 10 lw r13,(sp+16)
8004c84: 2b 8e 00 0c lw r14,(sp+12)
8004c88: 2b 8f 00 08 lw r15,(sp+8)
8004c8c: 37 9c 00 18 addi sp,sp,24
8004c90: c3 a0 00 00 ret
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
8004c94: 35 e7 00 04 addi r7,r15,4
8004c98: 34 01 ff fc mvi r1,-4
8004c9c: a0 e1 38 00 and r7,r7,r1
8004ca0: e3 ff ff ec bi 8004c50 <_Objects_Initialize_information+0xf8>
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
_Internal_error_Occurred(
8004ca4: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
8004ca8: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
8004cac: 34 03 00 13 mvi r3,19 <== NOT EXECUTED
8004cb0: fb ff fd d4 calli 8004400 <_Internal_error_Occurred> <== NOT EXECUTED
08004d30 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
8004d30: 37 9c ff ec addi sp,sp,-20
8004d34: 5b 8b 00 14 sw (sp+20),r11
8004d38: 5b 8c 00 10 sw (sp+16),r12
8004d3c: 5b 8d 00 0c sw (sp+12),r13
8004d40: 5b 8e 00 08 sw (sp+8),r14
8004d44: 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 );
8004d48: 2c 2c 00 0a lhu r12,(r1+10)
block_count = (information->maximum - index_base) /
8004d4c: 2c 2d 00 14 lhu r13,(r1+20)
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
8004d50: 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) /
8004d54: 2c 21 00 10 lhu r1,(r1+16)
8004d58: b9 a0 10 00 mv r2,r13
8004d5c: c8 2c 08 00 sub r1,r1,r12
8004d60: f8 00 35 aa calli 8012408 <__udivsi3>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
8004d64: 44 20 00 09 be r1,r0,8004d88 <_Objects_Shrink_information+0x58><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
8004d68: 29 c5 00 30 lw r5,(r14+48)
8004d6c: 34 0b 00 04 mvi r11,4
8004d70: 34 03 00 00 mvi r3,0
8004d74: 28 a2 00 00 lw r2,(r5+0)
8004d78: 45 a2 00 11 be r13,r2,8004dbc <_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++ ) {
8004d7c: 34 63 00 01 addi r3,r3,1
* the_block - the block to remove
*
* Output parameters: NONE
*/
void _Objects_Shrink_information(
8004d80: 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++ ) {
8004d84: 54 23 00 08 bgu r1,r3,8004da4 <_Objects_Shrink_information+0x74>
return;
}
index_base += information->allocation_size;
}
}
8004d88: 2b 9d 00 04 lw ra,(sp+4)
8004d8c: 2b 8b 00 14 lw r11,(sp+20)
8004d90: 2b 8c 00 10 lw r12,(sp+16)
8004d94: 2b 8d 00 0c lw r13,(sp+12)
8004d98: 2b 8e 00 08 lw r14,(sp+8)
8004d9c: 37 9c 00 14 addi sp,sp,20
8004da0: 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 ] ==
8004da4: 28 42 00 00 lw r2,(r2+0)
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
8004da8: 35 64 00 04 addi r4,r11,4
8004dac: 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 ] ==
8004db0: 45 a2 00 04 be r13,r2,8004dc0 <_Objects_Shrink_information+0x90>
8004db4: b8 80 58 00 mv r11,r4
8004db8: e3 ff ff f1 bi 8004d7c <_Objects_Shrink_information+0x4c>
8004dbc: 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 );
8004dc0: 29 c1 00 20 lw r1,(r14+32)
do {
index = _Objects_Get_index( the_object->id );
8004dc4: 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;
8004dc8: 28 2d 00 00 lw r13,(r1+0)
if ((index >= index_base) &&
8004dcc: 55 82 00 05 bgu r12,r2,8004de0 <_Objects_Shrink_information+0xb0>
(index < (index_base + information->allocation_size))) {
8004dd0: 2d c3 00 14 lhu r3,(r14+20)
8004dd4: 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) &&
8004dd8: 50 43 00 02 bgeu r2,r3,8004de0 <_Objects_Shrink_information+0xb0>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
8004ddc: fb ff fa c1 calli 80038e0 <_Chain_Extract>
}
}
while ( the_object );
8004de0: 45 a0 00 03 be r13,r0,8004dec <_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;
8004de4: b9 a0 08 00 mv r1,r13
8004de8: e3 ff ff f7 bi 8004dc4 <_Objects_Shrink_information+0x94>
while ( the_object );
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
8004dec: 29 c1 00 34 lw r1,(r14+52)
8004df0: b4 2b 08 00 add r1,r1,r11
8004df4: 28 21 00 00 lw r1,(r1+0)
8004df8: f8 00 08 61 calli 8006f7c <_Workspace_Free>
information->object_blocks[ block ] = NULL;
8004dfc: 29 c2 00 34 lw r2,(r14+52)
information->inactive_per_block[ block ] = 0;
8004e00: 29 c4 00 30 lw r4,(r14+48)
information->inactive -= information->allocation_size;
8004e04: 2d c3 00 2c lhu r3,(r14+44)
8004e08: 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;
8004e0c: b4 4b 10 00 add r2,r2,r11
8004e10: 58 40 00 00 sw (r2+0),r0
information->inactive_per_block[ block ] = 0;
8004e14: b4 8b 58 00 add r11,r4,r11
8004e18: 59 60 00 00 sw (r11+0),r0
information->inactive -= information->allocation_size;
8004e1c: c8 61 08 00 sub r1,r3,r1
8004e20: 0d c1 00 2c sh (r14+44),r1
return;
}
index_base += information->allocation_size;
}
}
8004e24: 2b 9d 00 04 lw ra,(sp+4)
8004e28: 2b 8b 00 14 lw r11,(sp+20)
8004e2c: 2b 8c 00 10 lw r12,(sp+16)
8004e30: 2b 8d 00 0c lw r13,(sp+12)
8004e34: 2b 8e 00 08 lw r14,(sp+8)
8004e38: 37 9c 00 14 addi sp,sp,20
8004e3c: c3 a0 00 00 ret
08009018 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
8009018: 37 9c ff dc addi sp,sp,-36
800901c: 5b 8b 00 1c sw (sp+28),r11
8009020: 5b 8c 00 18 sw (sp+24),r12
8009024: 5b 8d 00 14 sw (sp+20),r13
8009028: 5b 8e 00 10 sw (sp+16),r14
800902c: 5b 8f 00 0c sw (sp+12),r15
8009030: 5b 90 00 08 sw (sp+8),r16
8009034: 5b 9d 00 04 sw (sp+4),ra
8009038: b8 20 60 00 mv r12,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(
800903c: 78 01 08 02 mvhi r1,0x802
8009040: b8 40 78 00 mv r15,r2
8009044: b8 60 58 00 mv r11,r3
8009048: b9 80 10 00 mv r2,r12
800904c: 38 21 a2 18 ori r1,r1,0xa218
8009050: 37 83 00 24 addi r3,sp,36
8009054: b8 80 68 00 mv r13,r4
8009058: b8 c0 70 00 mv r14,r6
800905c: 20 b0 00 ff andi r16,r5,0xff
8009060: f8 00 0d 2b calli 800c50c <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
8009064: 2b 82 00 24 lw r2,(sp+36)
8009068: 44 40 00 0e be r2,r0,80090a0 <_POSIX_Message_queue_Receive_support+0x88>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
800906c: f8 00 30 8f calli 80152a8 <__errno>
8009070: 34 02 00 09 mvi r2,9
8009074: 58 22 00 00 sw (r1+0),r2
8009078: 34 01 ff ff mvi r1,-1
}
800907c: 2b 9d 00 04 lw ra,(sp+4)
8009080: 2b 8b 00 1c lw r11,(sp+28)
8009084: 2b 8c 00 18 lw r12,(sp+24)
8009088: 2b 8d 00 14 lw r13,(sp+20)
800908c: 2b 8e 00 10 lw r14,(sp+16)
8009090: 2b 8f 00 0c lw r15,(sp+12)
8009094: 2b 90 00 08 lw r16,(sp+8)
8009098: 37 9c 00 24 addi sp,sp,36
800909c: 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 ) {
80090a0: 28 28 00 14 lw r8,(r1+20)
80090a4: 34 07 00 01 mvi r7,1
80090a8: 21 09 00 03 andi r9,r8,0x3
80090ac: 45 27 00 2e be r9,r7,8009164 <_POSIX_Message_queue_Receive_support+0x14c>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
80090b0: 28 27 00 10 lw r7,(r1+16)
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
80090b4: 28 e1 00 68 lw r1,(r7+104)
80090b8: 51 61 00 07 bgeu r11,r1,80090d4 <_POSIX_Message_queue_Receive_support+0xbc>
_Thread_Enable_dispatch();
80090bc: f8 00 10 b2 calli 800d384 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
80090c0: f8 00 30 7a calli 80152a8 <__errno>
80090c4: 34 02 00 7a mvi r2,122
80090c8: 58 22 00 00 sw (r1+0),r2
80090cc: 34 01 ff ff mvi r1,-1
80090d0: e3 ff ff eb bi 800907c <_POSIX_Message_queue_Receive_support+0x64>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
80090d4: 34 01 ff ff mvi r1,-1
80090d8: 5b 81 00 20 sw (sp+32),r1
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
80090dc: 34 05 00 00 mvi r5,0
80090e0: 5e 00 00 16 bne r16,r0,8009138 <_POSIX_Message_queue_Receive_support+0x120><== ALWAYS TAKEN
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
80090e4: 78 0b 08 02 mvhi r11,0x802
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
80090e8: 34 e1 00 1c addi r1,r7,28
80090ec: b9 80 10 00 mv r2,r12
80090f0: b9 e0 18 00 mv r3,r15
80090f4: 37 84 00 20 addi r4,sp,32
80090f8: b9 c0 30 00 mv r6,r14
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
80090fc: 39 6b a2 84 ori r11,r11,0xa284
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
8009100: f8 00 07 d1 calli 800b044 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
8009104: f8 00 10 a0 calli 800d384 <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
8009108: 29 6c 00 0c lw r12,(r11+12)
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
800910c: 34 02 00 1f mvi r2,31
8009110: 29 81 00 24 lw r1,(r12+36)
8009114: f8 00 6e 13 calli 8024960 <__ashrsi3>
8009118: 29 83 00 24 lw r3,(r12+36)
if ( !_Thread_Executing->Wait.return_code )
800911c: 29 82 00 34 lw r2,(r12+52)
8009120: 98 23 18 00 xor r3,r1,r3
8009124: c8 61 08 00 sub r1,r3,r1
do_wait,
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
8009128: 59 a1 00 00 sw (r13+0),r1
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
800912c: 5c 40 00 06 bne r2,r0,8009144 <_POSIX_Message_queue_Receive_support+0x12c>
return length_out;
8009130: 2b 81 00 20 lw r1,(sp+32)
8009134: e3 ff ff d2 bi 800907c <_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;
8009138: 21 05 40 00 andi r5,r8,0x4000
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
800913c: 64 a5 00 00 cmpei r5,r5,0
8009140: e3 ff ff e9 bi 80090e4 <_POSIX_Message_queue_Receive_support+0xcc>
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
return length_out;
rtems_set_errno_and_return_minus_one(
8009144: f8 00 30 59 calli 80152a8 <__errno>
8009148: b8 20 60 00 mv r12,r1
800914c: 29 61 00 0c lw r1,(r11+12)
8009150: 28 21 00 34 lw r1,(r1+52)
8009154: f8 00 00 c2 calli 800945c <_POSIX_Message_queue_Translate_core_message_queue_return_code>
8009158: 59 81 00 00 sw (r12+0),r1
800915c: 34 01 ff ff mvi r1,-1
8009160: e3 ff ff c7 bi 800907c <_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();
8009164: f8 00 10 88 calli 800d384 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
8009168: f8 00 30 50 calli 80152a8 <__errno>
800916c: 34 02 00 09 mvi r2,9
8009170: 58 22 00 00 sw (r1+0),r2
8009174: 34 01 ff ff mvi r1,-1
8009178: e3 ff ff c1 bi 800907c <_POSIX_Message_queue_Receive_support+0x64>
08008b90 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
8008b90: 37 9c ff fc addi sp,sp,-4
8008b94: 5b 9d 00 04 sw (sp+4),ra
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
8008b98: 28 22 01 20 lw r2,(r1+288)
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
8008b9c: 28 43 00 d8 lw r3,(r2+216)
8008ba0: 5c 60 00 04 bne r3,r0,8008bb0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x20><== NEVER TAKEN
8008ba4: 28 44 00 dc lw r4,(r2+220)
8008ba8: 34 03 00 01 mvi r3,1
8008bac: 44 83 00 05 be r4,r3,8008bc0 <_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();
8008bb0: fb ff f3 32 calli 8005878 <_Thread_Enable_dispatch>
}
8008bb4: 2b 9d 00 04 lw ra,(sp+4)
8008bb8: 37 9c 00 04 addi sp,sp,4
8008bbc: 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 &&
8008bc0: 28 42 00 e0 lw r2,(r2+224)
8008bc4: 44 40 ff fb be r2,r0,8008bb0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x20>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
8008bc8: 78 03 08 01 mvhi r3,0x801
8008bcc: 38 63 68 58 ori r3,r3,0x6858
8008bd0: 28 64 00 00 lw r4,(r3+0)
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
8008bd4: 34 02 ff ff mvi r2,-1
8008bd8: 34 84 ff ff addi r4,r4,-1
8008bdc: 58 64 00 00 sw (r3+0),r4
8008be0: f8 00 02 89 calli 8009604 <_POSIX_Thread_Exit>
8008be4: e3 ff ff f4 bi 8008bb4 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24>
0800a6cc <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
800a6cc: 37 9c ff e8 addi sp,sp,-24
800a6d0: 5b 8b 00 18 sw (sp+24),r11
800a6d4: 5b 8c 00 14 sw (sp+20),r12
800a6d8: 5b 8d 00 10 sw (sp+16),r13
800a6dc: 5b 8e 00 0c sw (sp+12),r14
800a6e0: 5b 8f 00 08 sw (sp+8),r15
800a6e4: 5b 9d 00 04 sw (sp+4),ra
800a6e8: b8 20 68 00 mv r13,r1
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
800a6ec: 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
)
{
800a6f0: b8 40 60 00 mv r12,r2
800a6f4: b8 60 70 00 mv r14,r3
800a6f8: b8 80 78 00 mv r15,r4
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
800a6fc: fb ff ff ec calli 800a6ac <_POSIX_Priority_Is_valid>
return EINVAL;
800a700: 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 ) )
800a704: 44 20 00 0c be r1,r0,800a734 <_POSIX_Thread_Translate_sched_param+0x68><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
800a708: 59 c0 00 00 sw (r14+0),r0
*budget_callout = NULL;
800a70c: 59 e0 00 00 sw (r15+0),r0
if ( policy == SCHED_OTHER ) {
800a710: 45 a0 00 12 be r13,r0,800a758 <_POSIX_Thread_Translate_sched_param+0x8c>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
800a714: 34 01 00 01 mvi r1,1
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
800a718: 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 ) {
800a71c: 45 a1 00 06 be r13,r1,800a734 <_POSIX_Thread_Translate_sched_param+0x68>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
800a720: 34 01 00 02 mvi r1,2
800a724: 45 a1 00 2b be r13,r1,800a7d0 <_POSIX_Thread_Translate_sched_param+0x104>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
800a728: 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;
800a72c: 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 ) {
800a730: 45 a1 00 0e be r13,r1,800a768 <_POSIX_Thread_Translate_sched_param+0x9c>
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
800a734: b9 60 08 00 mv r1,r11
800a738: 2b 9d 00 04 lw ra,(sp+4)
800a73c: 2b 8b 00 18 lw r11,(sp+24)
800a740: 2b 8c 00 14 lw r12,(sp+20)
800a744: 2b 8d 00 10 lw r13,(sp+16)
800a748: 2b 8e 00 0c lw r14,(sp+12)
800a74c: 2b 8f 00 08 lw r15,(sp+8)
800a750: 37 9c 00 18 addi sp,sp,24
800a754: 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;
800a758: 34 01 00 01 mvi r1,1
800a75c: 59 c1 00 00 sw (r14+0),r1
return 0;
800a760: 34 0b 00 00 mvi r11,0
800a764: e3 ff ff f4 bi 800a734 <_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) &&
800a768: 29 81 00 08 lw r1,(r12+8)
800a76c: 5c 20 00 03 bne r1,r0,800a778 <_POSIX_Thread_Translate_sched_param+0xac>
800a770: 29 82 00 0c lw r2,(r12+12)
800a774: 44 41 ff f0 be r2,r1,800a734 <_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) &&
800a778: 29 81 00 10 lw r1,(r12+16)
800a77c: 5c 20 00 04 bne r1,r0,800a78c <_POSIX_Thread_Translate_sched_param+0xc0>
800a780: 29 82 00 14 lw r2,(r12+20)
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
800a784: 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) &&
800a788: 44 41 ff eb be r2,r1,800a734 <_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 ) <
800a78c: 35 81 00 08 addi r1,r12,8
800a790: fb ff f4 36 calli 8007868 <_Timespec_To_ticks>
800a794: b8 20 68 00 mv r13,r1
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
800a798: 35 81 00 10 addi r1,r12,16
800a79c: fb ff f4 33 calli 8007868 <_Timespec_To_ticks>
return EINVAL;
800a7a0: 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 ) <
800a7a4: 54 2d ff e4 bgu r1,r13,800a734 <_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 ) )
800a7a8: 29 81 00 04 lw r1,(r12+4)
800a7ac: fb ff ff c0 calli 800a6ac <_POSIX_Priority_Is_valid>
800a7b0: 44 20 ff e1 be r1,r0,800a734 <_POSIX_Thread_Translate_sched_param+0x68>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
800a7b4: 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;
800a7b8: 34 02 00 03 mvi r2,3
800a7bc: 59 c2 00 00 sw (r14+0),r2
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
800a7c0: 38 21 3b b4 ori r1,r1,0x3bb4
800a7c4: 59 e1 00 00 sw (r15+0),r1
return 0;
800a7c8: 34 0b 00 00 mvi r11,0
800a7cc: e3 ff ff da bi 800a734 <_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;
800a7d0: 59 cd 00 00 sw (r14+0),r13
return 0;
800a7d4: e3 ff ff d8 bi 800a734 <_POSIX_Thread_Translate_sched_param+0x68>
08009340 <_POSIX_Threads_Exitted_extension>:
* This method is invoked each time a thread exits.
*/
void _POSIX_Threads_Exitted_extension(
Thread_Control *executing
)
{
8009340: 37 9c ff f8 addi sp,sp,-8
8009344: 5b 8b 00 08 sw (sp+8),r11
8009348: 5b 9d 00 04 sw (sp+4),ra
800934c: 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);
8009350: 28 21 00 08 lw r1,(r1+8)
8009354: 34 02 00 18 mvi r2,24
8009358: f8 00 23 a0 calli 80121d8 <__lshrsi3>
800935c: 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 )
8009360: 34 02 00 03 mvi r2,3
8009364: 44 22 00 05 be r1,r2,8009378 <_POSIX_Threads_Exitted_extension+0x38>
pthread_exit( executing->Wait.return_argument );
}
8009368: 2b 9d 00 04 lw ra,(sp+4)
800936c: 2b 8b 00 08 lw r11,(sp+8)
8009370: 37 9c 00 08 addi sp,sp,8
8009374: 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 );
8009378: 29 61 00 28 lw r1,(r11+40)
800937c: f8 00 0c ec calli 800c72c <pthread_exit>
}
8009380: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8009384: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
8009388: 37 9c 00 08 addi sp,sp,8 <== NOT EXECUTED
800938c: c3 a0 00 00 ret <== NOT EXECUTED
0800380c <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
800380c: 37 9c ff a8 addi sp,sp,-88
8003810: 5b 8b 00 14 sw (sp+20),r11
8003814: 5b 8c 00 10 sw (sp+16),r12
8003818: 5b 8d 00 0c sw (sp+12),r13
800381c: 5b 8e 00 08 sw (sp+8),r14
8003820: 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;
8003824: 78 01 08 01 mvhi r1,0x801
8003828: 38 21 f0 a8 ori r1,r1,0xf0a8
maximum = Configuration_POSIX_API.number_of_initialization_threads;
800382c: 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;
8003830: 28 2c 00 34 lw r12,(r1+52)
maximum = Configuration_POSIX_API.number_of_initialization_threads;
if ( !user_threads || maximum == 0 )
8003834: 65 c2 00 00 cmpei r2,r14,0
8003838: 65 81 00 00 cmpei r1,r12,0
800383c: b8 41 08 00 or r1,r2,r1
8003840: 5c 20 00 15 bne r1,r0,8003894 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
8003844: 34 0d 00 00 mvi r13,0
8003848: 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 );
800384c: b9 60 08 00 mv r1,r11
8003850: f8 00 1b e2 calli 800a7d8 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
8003854: 34 02 00 02 mvi r2,2
8003858: b9 60 08 00 mv r1,r11
800385c: f8 00 1c 16 calli 800a8b4 <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
8003860: 29 82 00 04 lw r2,(r12+4)
8003864: b9 60 08 00 mv r1,r11
8003868: f8 00 1c 1f calli 800a8e4 <pthread_attr_setstacksize>
status = pthread_create(
800386c: 29 83 00 00 lw r3,(r12+0)
8003870: 37 81 00 58 addi r1,sp,88
8003874: b9 60 10 00 mv r2,r11
8003878: 34 04 00 00 mvi r4,0
800387c: fb ff fe db calli 80033e8 <pthread_create>
8003880: b8 20 18 00 mv r3,r1
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
8003884: 5c 20 00 0b bne r1,r0,80038b0 <_POSIX_Threads_Initialize_user_threads_body+0xa4><== NEVER TAKEN
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
8003888: 35 ad 00 01 addi r13,r13,1
800388c: 35 8c 00 08 addi r12,r12,8
8003890: 55 cd ff ef bgu r14,r13,800384c <_POSIX_Threads_Initialize_user_threads_body+0x40><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
8003894: 2b 9d 00 04 lw ra,(sp+4)
8003898: 2b 8b 00 14 lw r11,(sp+20)
800389c: 2b 8c 00 10 lw r12,(sp+16)
80038a0: 2b 8d 00 0c lw r13,(sp+12)
80038a4: 2b 8e 00 08 lw r14,(sp+8)
80038a8: 37 9c 00 58 addi sp,sp,88
80038ac: c3 a0 00 00 ret
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
80038b0: 34 01 00 02 mvi r1,2 <== NOT EXECUTED
80038b4: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
80038b8: f8 00 07 5e calli 8005630 <_Internal_error_Occurred> <== NOT EXECUTED
08009588 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
8009588: 37 9c ff f4 addi sp,sp,-12
800958c: 5b 8b 00 0c sw (sp+12),r11
8009590: 5b 8c 00 08 sw (sp+8),r12
8009594: 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 ];
8009598: 28 4c 01 20 lw r12,(r2+288)
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
800959c: 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 );
80095a0: 35 81 00 98 addi r1,r12,152
80095a4: f8 00 05 5a calli 800ab0c <_Timespec_To_ticks>
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
80095a8: 78 03 08 01 mvhi r3,0x801
80095ac: 38 63 40 c0 ori r3,r3,0x40c0
80095b0: 29 84 00 88 lw r4,(r12+136)
80095b4: 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 ) {
80095b8: 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;
80095bc: 59 61 00 78 sw (r11+120),r1
80095c0: c8 44 10 00 sub r2,r2,r4
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
80095c4: 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 ) {
80095c8: 5c 60 00 06 bne r3,r0,80095e0 <_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 ) {
80095cc: 29 61 00 14 lw r1,(r11+20)
80095d0: 50 41 00 04 bgeu r2,r1,80095e0 <_POSIX_Threads_Sporadic_budget_TSR+0x58>
_Thread_Change_priority( the_thread, new_priority, true );
80095d4: b9 60 08 00 mv r1,r11
80095d8: 34 03 00 01 mvi r3,1
80095dc: fb ff ef 5c calli 800534c <_Thread_Change_priority>
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
80095e0: 35 81 00 90 addi r1,r12,144
80095e4: f8 00 05 4a calli 800ab0c <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
80095e8: 59 81 00 b4 sw (r12+180),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
80095ec: 78 01 08 01 mvhi r1,0x801
80095f0: 35 82 00 a8 addi r2,r12,168
80095f4: 38 21 49 88 ori r1,r1,0x4988
80095f8: fb ff f5 5c calli 8006b68 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
80095fc: 2b 9d 00 04 lw ra,(sp+4)
8009600: 2b 8b 00 0c lw r11,(sp+12)
8009604: 2b 8c 00 08 lw r12,(sp+8)
8009608: 37 9c 00 0c addi sp,sp,12
800960c: c3 a0 00 00 ret
08009610 <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
8009610: 37 9c ff fc addi sp,sp,-4
8009614: 5b 9d 00 04 sw (sp+4),ra
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8009618: 28 22 01 20 lw r2,(r1+288)
800961c: 78 04 08 01 mvhi r4,0x801
8009620: 38 84 40 c0 ori r4,r4,0x40c0
8009624: 28 42 00 8c lw r2,(r2+140)
8009628: 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 ) {
800962c: 28 25 00 1c lw r5,(r1+28)
8009630: 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 */
8009634: 34 04 ff ff mvi r4,-1
8009638: 58 24 00 78 sw (r1+120),r4
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
800963c: 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 ) {
8009640: 5c a0 00 05 bne r5,r0,8009654 <_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 ) {
8009644: 28 23 00 14 lw r3,(r1+20)
8009648: 50 62 00 03 bgeu r3,r2,8009654 <_POSIX_Threads_Sporadic_budget_callout+0x44><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
800964c: 34 03 00 01 mvi r3,1
8009650: fb ff ef 3f calli 800534c <_Thread_Change_priority>
#if 0
printk( "lower priority\n" );
#endif
}
}
}
8009654: 2b 9d 00 04 lw ra,(sp+4)
8009658: 37 9c 00 04 addi sp,sp,4
800965c: c3 a0 00 00 ret
0800c208 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
800c208: 37 9c ff ec addi sp,sp,-20
800c20c: 5b 8b 00 14 sw (sp+20),r11
800c210: 5b 8c 00 10 sw (sp+16),r12
800c214: 5b 8d 00 0c sw (sp+12),r13
800c218: 5b 8e 00 08 sw (sp+8),r14
800c21c: 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 ];
800c220: 28 2c 01 20 lw r12,(r1+288)
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
800c224: 34 01 00 01 mvi r1,1
while ( !_Chain_Is_empty( handler_stack ) ) {
800c228: 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;
800c22c: 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 );
800c230: 35 8d 00 e8 addi r13,r12,232
while ( !_Chain_Is_empty( handler_stack ) ) {
800c234: 44 4d 00 12 be r2,r13,800c27c <_POSIX_Threads_cancel_run+0x74>
_ISR_Disable( level );
800c238: 34 0e ff fe mvi r14,-2
800c23c: 90 00 08 00 rcsr r1,IE
800c240: a0 2e 10 00 and r2,r1,r14
800c244: d0 02 00 00 wcsr IE,r2
handler = (POSIX_Cancel_Handler_control *)
800c248: 29 8b 00 ec lw r11,(r12+236)
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
800c24c: 29 63 00 00 lw r3,(r11+0)
previous = the_node->previous;
800c250: 29 62 00 04 lw r2,(r11+4)
next->previous = previous;
800c254: 58 62 00 04 sw (r3+4),r2
previous->next = next;
800c258: 58 43 00 00 sw (r2+0),r3
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
800c25c: d0 01 00 00 wcsr IE,r1
(*handler->routine)( handler->arg );
800c260: 29 62 00 08 lw r2,(r11+8)
800c264: 29 61 00 0c lw r1,(r11+12)
800c268: d8 40 00 00 call r2
_Workspace_Free( handler );
800c26c: b9 60 08 00 mv r1,r11
800c270: fb ff eb 43 calli 8006f7c <_Workspace_Free>
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
800c274: 29 81 00 e4 lw r1,(r12+228)
800c278: 5c 2d ff f1 bne r1,r13,800c23c <_POSIX_Threads_cancel_run+0x34><== NEVER TAKEN
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
800c27c: 2b 9d 00 04 lw ra,(sp+4)
800c280: 2b 8b 00 14 lw r11,(sp+20)
800c284: 2b 8c 00 10 lw r12,(sp+16)
800c288: 2b 8d 00 0c lw r13,(sp+12)
800c28c: 2b 8e 00 08 lw r14,(sp+8)
800c290: 37 9c 00 14 addi sp,sp,20
800c294: c3 a0 00 00 ret
080034cc <_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)
{
80034cc: 37 9c ff f8 addi sp,sp,-8
80034d0: 5b 8b 00 08 sw (sp+8),r11
80034d4: 5b 9d 00 04 sw (sp+4),ra
80034d8: b8 40 58 00 mv r11,r2
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
80034dc: 28 42 00 68 lw r2,(r2+104)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
80034e0: 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;
80034e4: 34 42 00 01 addi r2,r2,1
80034e8: 59 62 00 68 sw (r11+104),r2
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
80034ec: 5c 20 00 0d bne r1,r0,8003520 <_POSIX_Timer_TSR+0x54>
80034f0: 29 62 00 58 lw r2,(r11+88)
80034f4: 5c 41 00 0b bne r2,r1,8003520 <_POSIX_Timer_TSR+0x54> <== 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;
80034f8: 34 01 00 04 mvi r1,4 <== NOT EXECUTED
80034fc: 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 ) ) {
8003500: 29 61 00 38 lw r1,(r11+56)
8003504: 29 62 00 44 lw r2,(r11+68)
8003508: f8 00 19 ed calli 8009cbc <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
800350c: 59 60 00 68 sw (r11+104),r0
}
8003510: 2b 9d 00 04 lw ra,(sp+4)
8003514: 2b 8b 00 08 lw r11,(sp+8)
8003518: 37 9c 00 08 addi sp,sp,8
800351c: 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(
8003520: 29 62 00 64 lw r2,(r11+100)
8003524: 29 63 00 08 lw r3,(r11+8)
8003528: 78 04 08 00 mvhi r4,0x800
800352c: 35 61 00 10 addi r1,r11,16
8003530: 38 84 34 cc ori r4,r4,0x34cc
8003534: b9 60 28 00 mv r5,r11
8003538: f8 00 1b 42 calli 800a240 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
800353c: 44 20 ff f5 be r1,r0,8003510 <_POSIX_Timer_TSR+0x44> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
8003540: 35 61 00 6c addi r1,r11,108
8003544: f8 00 04 af calli 8004800 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
8003548: 34 01 00 03 mvi r1,3
800354c: 31 61 00 3c sb (r11+60),r1
8003550: e3 ff ff ec bi 8003500 <_POSIX_Timer_TSR+0x34>
0800c370 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
800c370: 37 9c ff a0 addi sp,sp,-96
800c374: 5b 8b 00 2c sw (sp+44),r11
800c378: 5b 8c 00 28 sw (sp+40),r12
800c37c: 5b 8d 00 24 sw (sp+36),r13
800c380: 5b 8e 00 20 sw (sp+32),r14
800c384: 5b 8f 00 1c sw (sp+28),r15
800c388: 5b 90 00 18 sw (sp+24),r16
800c38c: 5b 91 00 14 sw (sp+20),r17
800c390: 5b 92 00 10 sw (sp+16),r18
800c394: 5b 93 00 0c sw (sp+12),r19
800c398: 5b 94 00 08 sw (sp+8),r20
800c39c: 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,
800c3a0: 37 8e 00 58 addi r14,sp,88
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
800c3a4: 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,
800c3a8: 34 05 00 01 mvi r5,1
800c3ac: b9 c0 18 00 mv r3,r14
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
800c3b0: b8 20 68 00 mv r13,r1
800c3b4: 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,
800c3b8: f8 00 00 57 calli 800c514 <_POSIX_signals_Clear_signals>
is_global, true ) )
return false;
800c3bc: 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,
800c3c0: 44 20 00 42 be r1,r0,800c4c8 <_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 )
800c3c4: b5 6b 20 00 add r4,r11,r11
800c3c8: b4 8b 20 00 add r4,r4,r11
800c3cc: 78 05 08 01 mvhi r5,0x801
800c3d0: b4 84 20 00 add r4,r4,r4
800c3d4: 38 a5 4d c0 ori r5,r5,0x4dc0
800c3d8: b4 84 20 00 add r4,r4,r4
800c3dc: b4 a4 28 00 add r5,r5,r4
800c3e0: 28 a7 00 08 lw r7,(r5+8)
800c3e4: 34 01 00 01 mvi r1,1
800c3e8: 44 e1 00 38 be r7,r1,800c4c8 <_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,
800c3ec: 78 0c 08 01 mvhi r12,0x801
800c3f0: 39 8c 4d 74 ori r12,r12,0x4d74
800c3f4: 29 84 00 0c lw r4,(r12+12)
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
800c3f8: 29 af 00 d0 lw r15,(r13+208)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
800c3fc: 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,
800c400: 28 94 00 20 lw r20,(r4+32)
800c404: 28 93 00 24 lw r19,(r4+36)
800c408: 28 92 00 28 lw r18,(r4+40)
800c40c: 28 91 00 2c lw r17,(r4+44)
800c410: 28 90 00 30 lw r16,(r4+48)
800c414: 28 8a 00 34 lw r10,(r4+52)
800c418: 28 89 00 38 lw r9,(r4+56)
800c41c: 28 88 00 3c lw r8,(r4+60)
800c420: 28 86 00 40 lw r6,(r4+64)
800c424: 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 ) {
800c428: 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;
800c42c: b8 2f 08 00 or r1,r1,r15
800c430: 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,
800c434: 5b 94 00 30 sw (sp+48),r20
800c438: 5b 93 00 34 sw (sp+52),r19
800c43c: 5b 92 00 38 sw (sp+56),r18
800c440: 5b 91 00 3c sw (sp+60),r17
800c444: 5b 90 00 40 sw (sp+64),r16
800c448: 5b 8a 00 44 sw (sp+68),r10
800c44c: 5b 89 00 48 sw (sp+72),r9
800c450: 5b 88 00 4c sw (sp+76),r8
800c454: 5b 86 00 50 sw (sp+80),r6
800c458: 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 ) {
800c45c: 34 01 00 02 mvi r1,2
800c460: 44 41 00 28 be r2,r1,800c500 <_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 );
800c464: b9 60 08 00 mv r1,r11
800c468: d8 e0 00 00 call r7
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
800c46c: 2b 81 00 30 lw r1,(sp+48)
800c470: 29 82 00 0c lw r2,(r12+12)
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
800c474: 34 06 00 01 mvi r6,1
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
800c478: 58 41 00 20 sw (r2+32),r1
800c47c: 2b 81 00 34 lw r1,(sp+52)
800c480: 58 41 00 24 sw (r2+36),r1
800c484: 2b 81 00 38 lw r1,(sp+56)
800c488: 58 41 00 28 sw (r2+40),r1
800c48c: 2b 81 00 3c lw r1,(sp+60)
800c490: 58 41 00 2c sw (r2+44),r1
800c494: 2b 81 00 40 lw r1,(sp+64)
800c498: 58 41 00 30 sw (r2+48),r1
800c49c: 2b 81 00 44 lw r1,(sp+68)
800c4a0: 58 41 00 34 sw (r2+52),r1
800c4a4: 2b 81 00 48 lw r1,(sp+72)
800c4a8: 58 41 00 38 sw (r2+56),r1
800c4ac: 2b 81 00 4c lw r1,(sp+76)
800c4b0: 58 41 00 3c sw (r2+60),r1
800c4b4: 2b 81 00 50 lw r1,(sp+80)
800c4b8: 58 41 00 40 sw (r2+64),r1
800c4bc: 2b 81 00 54 lw r1,(sp+84)
800c4c0: 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;
800c4c4: 59 af 00 d0 sw (r13+208),r15
return true;
}
800c4c8: b8 c0 08 00 mv r1,r6
800c4cc: 2b 9d 00 04 lw ra,(sp+4)
800c4d0: 2b 8b 00 2c lw r11,(sp+44)
800c4d4: 2b 8c 00 28 lw r12,(sp+40)
800c4d8: 2b 8d 00 24 lw r13,(sp+36)
800c4dc: 2b 8e 00 20 lw r14,(sp+32)
800c4e0: 2b 8f 00 1c lw r15,(sp+28)
800c4e4: 2b 90 00 18 lw r16,(sp+24)
800c4e8: 2b 91 00 14 lw r17,(sp+20)
800c4ec: 2b 92 00 10 lw r18,(sp+16)
800c4f0: 2b 93 00 0c lw r19,(sp+12)
800c4f4: 2b 94 00 08 lw r20,(sp+8)
800c4f8: 37 9c 00 60 addi sp,sp,96
800c4fc: 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)(
800c500: b9 60 08 00 mv r1,r11
800c504: b9 c0 10 00 mv r2,r14
800c508: 34 03 00 00 mvi r3,0
800c50c: d8 e0 00 00 call r7
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
800c510: e3 ff ff d7 bi 800c46c <_POSIX_signals_Check_signal+0xfc>
0800ccec <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
800ccec: 37 9c ff f4 addi sp,sp,-12
800ccf0: 5b 8b 00 0c sw (sp+12),r11
800ccf4: 5b 8c 00 08 sw (sp+8),r12
800ccf8: 5b 9d 00 04 sw (sp+4),ra
800ccfc: b8 20 10 00 mv r2,r1
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
800cd00: 90 00 60 00 rcsr r12,IE
800cd04: 34 01 ff fe mvi r1,-2
800cd08: a1 81 08 00 and r1,r12,r1
800cd0c: d0 01 00 00 wcsr IE,r1
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
800cd10: b4 42 20 00 add r4,r2,r2
800cd14: b4 82 20 00 add r4,r4,r2
800cd18: 78 01 08 01 mvhi r1,0x801
800cd1c: b4 84 18 00 add r3,r4,r4
800cd20: 38 21 4d c0 ori r1,r1,0x4dc0
800cd24: b4 63 18 00 add r3,r3,r3
800cd28: b4 23 18 00 add r3,r1,r3
800cd2c: 28 63 00 00 lw r3,(r3+0)
800cd30: 34 01 00 02 mvi r1,2
800cd34: 44 61 00 10 be r3,r1,800cd74 <_POSIX_signals_Clear_process_signals+0x88>
800cd38: 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;
800cd3c: 78 0b 08 01 mvhi r11,0x801
800cd40: 34 01 00 01 mvi r1,1
800cd44: f8 00 14 d7 calli 80120a0 <__ashlsi3>
800cd48: 39 6b 4f b4 ori r11,r11,0x4fb4
800cd4c: 29 62 00 00 lw r2,(r11+0)
800cd50: a4 20 08 00 not r1,r1
800cd54: a0 22 08 00 and r1,r1,r2
800cd58: 59 61 00 00 sw (r11+0),r1
}
_ISR_Enable( level );
800cd5c: d0 0c 00 00 wcsr IE,r12
}
800cd60: 2b 9d 00 04 lw ra,(sp+4)
800cd64: 2b 8b 00 0c lw r11,(sp+12)
800cd68: 2b 8c 00 08 lw r12,(sp+8)
800cd6c: 37 9c 00 0c addi sp,sp,12
800cd70: c3 a0 00 00 ret
800cd74: 78 01 08 01 mvhi r1,0x801
800cd78: b4 84 20 00 add r4,r4,r4
800cd7c: 38 21 4f b8 ori r1,r1,0x4fb8
800cd80: b4 84 20 00 add r4,r4,r4
800cd84: 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 ] ) )
800cd88: 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 );
800cd8c: 34 84 00 04 addi r4,r4,4
800cd90: 44 24 ff ea be r1,r4,800cd38 <_POSIX_signals_Clear_process_signals+0x4c><== ALWAYS TAKEN
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
800cd94: d0 0c 00 00 wcsr IE,r12 <== NOT EXECUTED
}
800cd98: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
800cd9c: 2b 8b 00 0c lw r11,(sp+12) <== NOT EXECUTED
800cda0: 2b 8c 00 08 lw r12,(sp+8) <== NOT EXECUTED
800cda4: 37 9c 00 0c addi sp,sp,12 <== NOT EXECUTED
800cda8: c3 a0 00 00 ret <== NOT EXECUTED
0800419c <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
800419c: 37 9c ff f0 addi sp,sp,-16
80041a0: 5b 8b 00 10 sw (sp+16),r11
80041a4: 5b 8c 00 0c sw (sp+12),r12
80041a8: 5b 8d 00 08 sw (sp+8),r13
80041ac: 5b 9d 00 04 sw (sp+4),ra
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
80041b0: 34 0b 00 1b mvi r11,27
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
80041b4: b8 20 60 00 mv r12,r1
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
80041b8: 34 0d 00 20 mvi r13,32
80041bc: 35 62 ff ff addi r2,r11,-1
80041c0: 34 01 00 01 mvi r1,1
80041c4: f8 00 67 05 calli 801ddd8 <__ashlsi3>
if ( set & signo_to_mask( signo ) ) {
80041c8: a0 2c 08 00 and r1,r1,r12
80041cc: 5c 20 00 0d bne r1,r0,8004200 <_POSIX_signals_Get_lowest+0x64><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
80041d0: 35 6b 00 01 addi r11,r11,1
80041d4: 5d 6d ff fa bne r11,r13,80041bc <_POSIX_signals_Get_lowest+0x20>
80041d8: 34 0b 00 01 mvi r11,1
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
80041dc: 34 0d 00 1b mvi r13,27
80041e0: e0 00 00 03 bi 80041ec <_POSIX_signals_Get_lowest+0x50>
80041e4: 35 6b 00 01 addi r11,r11,1
80041e8: 45 6d 00 06 be r11,r13,8004200 <_POSIX_signals_Get_lowest+0x64><== NEVER TAKEN
80041ec: 35 62 ff ff addi r2,r11,-1
80041f0: 34 01 00 01 mvi r1,1
80041f4: f8 00 66 f9 calli 801ddd8 <__ashlsi3>
if ( set & signo_to_mask( signo ) ) {
80041f8: a0 2c 10 00 and r2,r1,r12
80041fc: 44 40 ff fa be r2,r0,80041e4 <_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;
}
8004200: b9 60 08 00 mv r1,r11
8004204: 2b 9d 00 04 lw ra,(sp+4)
8004208: 2b 8b 00 10 lw r11,(sp+16)
800420c: 2b 8c 00 0c lw r12,(sp+12)
8004210: 2b 8d 00 08 lw r13,(sp+8)
8004214: 37 9c 00 10 addi sp,sp,16
8004218: c3 a0 00 00 ret
08026350 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
8026350: 37 9c ff ec addi sp,sp,-20
8026354: 5b 8b 00 14 sw (sp+20),r11
8026358: 5b 8c 00 10 sw (sp+16),r12
802635c: 5b 8d 00 0c sw (sp+12),r13
8026360: 5b 8e 00 08 sw (sp+8),r14
8026364: 5b 9d 00 04 sw (sp+4),ra
8026368: b8 20 58 00 mv r11,r1
802636c: b8 40 70 00 mv r14,r2
8026370: 34 01 00 01 mvi r1,1
8026374: 34 42 ff ff addi r2,r2,-1
8026378: b8 60 68 00 mv r13,r3
802637c: fb ff 6f 7b calli 8002168 <__ashlsi3>
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
8026380: 78 02 08 02 mvhi r2,0x802
8026384: 38 42 7b e0 ori r2,r2,0x7be0
8026388: 29 64 00 10 lw r4,(r11+16)
802638c: 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 ];
8026390: 29 65 01 20 lw r5,(r11+288)
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
8026394: a0 83 10 00 and r2,r4,r3
8026398: 44 43 00 21 be r2,r3,802641c <_POSIX_signals_Unblock_thread+0xcc>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
802639c: 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;
80263a0: 34 0c 00 00 mvi r12,0
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
80263a4: a4 40 10 00 not r2,r2
80263a8: a0 22 08 00 and r1,r1,r2
80263ac: 44 20 00 14 be r1,r0,80263fc <_POSIX_signals_Unblock_thread+0xac>
80263b0: 78 01 10 00 mvhi r1,0x1000
80263b4: 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 ) ) {
80263b8: 44 20 00 31 be r1,r0,802647c <_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);
80263bc: 78 03 08 02 mvhi r3,0x802
the_thread->Wait.return_code = EINTR;
80263c0: 34 01 00 04 mvi r1,4
80263c4: 38 63 79 88 ori r3,r3,0x7988
80263c8: 59 61 00 34 sw (r11+52),r1
80263cc: 28 61 00 00 lw r1,(r3+0)
80263d0: 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) )
80263d4: 5c 20 00 3a bne r1,r0,80264bc <_POSIX_signals_Unblock_thread+0x16c>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_delaying (
States_Control the_states
)
{
return (the_states & STATES_DELAYING);
80263d8: 20 84 00 08 andi r4,r4,0x8
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
80263dc: 44 8c 00 08 be r4,r12,80263fc <_POSIX_signals_Unblock_thread+0xac><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
80263e0: 35 61 00 48 addi r1,r11,72
80263e4: fb ff 9e b5 calli 800deb8 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
80263e8: 78 03 08 02 mvhi r3,0x802
80263ec: 38 63 77 ec ori r3,r3,0x77ec
80263f0: 28 62 00 00 lw r2,(r3+0)
80263f4: b9 60 08 00 mv r1,r11
80263f8: fb ff 98 7a calli 800c5e0 <_Thread_Clear_state>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
80263fc: b9 80 08 00 mv r1,r12
8026400: 2b 9d 00 04 lw ra,(sp+4)
8026404: 2b 8b 00 14 lw r11,(sp+20)
8026408: 2b 8c 00 10 lw r12,(sp+16)
802640c: 2b 8d 00 0c lw r13,(sp+12)
8026410: 2b 8e 00 08 lw r14,(sp+8)
8026414: 37 9c 00 14 addi sp,sp,20
8026418: 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) ) {
802641c: 29 62 00 30 lw r2,(r11+48)
8026420: a0 22 10 00 and r2,r1,r2
8026424: 44 40 00 20 be r2,r0,80264a4 <_POSIX_signals_Unblock_thread+0x154>
the_thread->Wait.return_code = EINTR;
8026428: 34 01 00 04 mvi r1,4
802642c: 59 61 00 34 sw (r11+52),r1
the_info = (siginfo_t *) the_thread->Wait.return_argument;
8026430: 29 61 00 28 lw r1,(r11+40)
if ( !info ) {
8026434: 45 a0 00 25 be r13,r0,80264c8 <_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;
8026438: 29 a2 00 00 lw r2,(r13+0)
802643c: 58 22 00 00 sw (r1+0),r2
8026440: 29 a2 00 04 lw r2,(r13+4)
8026444: 58 22 00 04 sw (r1+4),r2
8026448: 29 a2 00 08 lw r2,(r13+8)
802644c: 58 22 00 08 sw (r1+8),r2
}
_Thread_queue_Extract_with_proxy( the_thread );
8026450: b9 60 08 00 mv r1,r11
8026454: fb ff 9b ab calli 800d300 <_Thread_queue_Extract_with_proxy>
return true;
8026458: 34 0c 00 01 mvi r12,1
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
802645c: b9 80 08 00 mv r1,r12
8026460: 2b 9d 00 04 lw ra,(sp+4)
8026464: 2b 8b 00 14 lw r11,(sp+20)
8026468: 2b 8c 00 10 lw r12,(sp+16)
802646c: 2b 8d 00 0c lw r13,(sp+12)
8026470: 2b 8e 00 08 lw r14,(sp+8)
8026474: 37 9c 00 14 addi sp,sp,20
8026478: 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 ) {
802647c: 5c 8c ff e0 bne r4,r12,80263fc <_POSIX_signals_Unblock_thread+0xac><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
8026480: 78 01 08 02 mvhi r1,0x802
8026484: 38 21 ae ec ori r1,r1,0xaeec
8026488: 28 22 00 08 lw r2,(r1+8)
802648c: 44 4c ff dc be r2,r12,80263fc <_POSIX_signals_Unblock_thread+0xac>
8026490: 28 22 00 0c lw r2,(r1+12)
8026494: 5d 62 ff da bne r11,r2,80263fc <_POSIX_signals_Unblock_thread+0xac><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
8026498: 34 02 00 01 mvi r2,1
802649c: 30 22 00 18 sb (r1+24),r2
80264a0: e3 ff ff d7 bi 80263fc <_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) ) {
80264a4: 28 a2 00 d0 lw r2,(r5+208)
/*
* This should only be reached via pthread_kill().
*/
return false;
80264a8: 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) ) {
80264ac: a4 40 10 00 not r2,r2
80264b0: a0 22 08 00 and r1,r1,r2
80264b4: 5c 2c ff dd bne r1,r12,8026428 <_POSIX_signals_Unblock_thread+0xd8>
80264b8: e3 ff ff d1 bi 80263fc <_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 );
80264bc: b9 60 08 00 mv r1,r11
80264c0: fb ff 9b 90 calli 800d300 <_Thread_queue_Extract_with_proxy>
80264c4: e3 ff ff ce bi 80263fc <_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;
80264c8: 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;
80264cc: 58 2e 00 00 sw (r1+0),r14
the_info->si_code = SI_USER;
80264d0: 58 22 00 04 sw (r1+4),r2
the_info->si_value.sival_int = 0;
80264d4: 58 20 00 08 sw (r1+8),r0
80264d8: e3 ff ff de bi 8026450 <_POSIX_signals_Unblock_thread+0x100>
08003194 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
8003194: 37 9c ff e8 addi sp,sp,-24
8003198: 5b 8b 00 14 sw (sp+20),r11
800319c: 5b 8c 00 10 sw (sp+16),r12
80031a0: 5b 8d 00 0c sw (sp+12),r13
80031a4: 5b 8e 00 08 sw (sp+8),r14
80031a8: 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;
80031ac: 78 01 08 01 mvhi r1,0x801
80031b0: 38 21 40 8c ori r1,r1,0x408c
80031b4: 28 2b 00 2c lw r11,(r1+44)
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
80031b8: 28 2e 00 28 lw r14,(r1+40)
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
80031bc: 45 60 00 15 be r11,r0,8003210 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
80031c0: 45 c0 00 14 be r14,r0,8003210 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c><== NEVER TAKEN
80031c4: 34 0c 00 00 mvi r12,0
return_value = rtems_task_create(
80031c8: 29 61 00 00 lw r1,(r11+0)
80031cc: 29 62 00 08 lw r2,(r11+8)
80031d0: 29 63 00 04 lw r3,(r11+4)
80031d4: 29 64 00 14 lw r4,(r11+20)
80031d8: 29 65 00 0c lw r5,(r11+12)
80031dc: 37 86 00 18 addi r6,sp,24
80031e0: fb ff ff 52 calli 8002f28 <rtems_task_create>
80031e4: 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 ) )
80031e8: 5c 20 00 11 bne r1,r0,800322c <_RTEMS_tasks_Initialize_user_tasks_body+0x98><== NEVER TAKEN
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
80031ec: 29 63 00 18 lw r3,(r11+24)
80031f0: 2b 81 00 18 lw r1,(sp+24)
80031f4: 29 62 00 10 lw r2,(r11+16)
80031f8: f8 00 00 14 calli 8003248 <rtems_task_start>
80031fc: b8 20 18 00 mv r3,r1
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
8003200: 5c 2d 00 0f bne r1,r13,800323c <_RTEMS_tasks_Initialize_user_tasks_body+0xa8><== NEVER TAKEN
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
8003204: 35 8c 00 01 addi r12,r12,1
8003208: 35 6b 00 1c addi r11,r11,28
800320c: 55 cc ff ef bgu r14,r12,80031c8 <_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 );
}
}
8003210: 2b 9d 00 04 lw ra,(sp+4)
8003214: 2b 8b 00 14 lw r11,(sp+20)
8003218: 2b 8c 00 10 lw r12,(sp+16)
800321c: 2b 8d 00 0c lw r13,(sp+12)
8003220: 2b 8e 00 08 lw r14,(sp+8)
8003224: 37 9c 00 18 addi sp,sp,24
8003228: 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 );
800322c: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
8003230: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
8003234: b9 a0 18 00 mv r3,r13 <== NOT EXECUTED
8003238: f8 00 04 72 calli 8004400 <_Internal_error_Occurred> <== NOT EXECUTED
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 );
800323c: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
8003240: 34 02 00 01 mvi r2,1 <== NOT EXECUTED
8003244: f8 00 04 6f calli 8004400 <_Internal_error_Occurred> <== NOT EXECUTED
08009a74 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
8009a74: 28 21 01 28 lw r1,(r1+296)
while (tvp) {
8009a78: 44 20 00 08 be r1,r0,8009a98 <_RTEMS_tasks_Switch_extension+0x24>
tvp->tval = *tvp->ptr;
8009a7c: 28 23 00 04 lw r3,(r1+4)
*tvp->ptr = tvp->gval;
8009a80: 28 24 00 08 lw r4,(r1+8)
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
8009a84: 28 65 00 00 lw r5,(r3+0)
8009a88: 58 25 00 0c sw (r1+12),r5
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
8009a8c: 28 21 00 00 lw r1,(r1+0)
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
8009a90: 58 64 00 00 sw (r3+0),r4
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
8009a94: 5c 20 ff fa bne r1,r0,8009a7c <_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;
8009a98: 28 41 01 28 lw r1,(r2+296)
while (tvp) {
8009a9c: 44 20 00 08 be r1,r0,8009abc <_RTEMS_tasks_Switch_extension+0x48>
tvp->gval = *tvp->ptr;
8009aa0: 28 22 00 04 lw r2,(r1+4)
*tvp->ptr = tvp->tval;
8009aa4: 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;
8009aa8: 28 44 00 00 lw r4,(r2+0)
8009aac: 58 24 00 08 sw (r1+8),r4
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
8009ab0: 28 21 00 00 lw r1,(r1+0)
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
8009ab4: 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) {
8009ab8: 5c 20 ff fa bne r1,r0,8009aa0 <_RTEMS_tasks_Switch_extension+0x2c><== NEVER TAKEN
8009abc: c3 a0 00 00 ret
0800487c <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
800487c: 37 9c ff f4 addi sp,sp,-12
8004880: 5b 8b 00 08 sw (sp+8),r11
8004884: 5b 9d 00 04 sw (sp+4),ra
8004888: b8 20 10 00 mv r2,r1
800488c: 78 01 08 02 mvhi r1,0x802
8004890: 38 21 18 90 ori r1,r1,0x1890
8004894: 37 83 00 0c addi r3,sp,12
8004898: f8 00 09 2d calli 8006d4c <_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 ) {
800489c: 2b 82 00 0c lw r2,(sp+12)
80048a0: b8 20 58 00 mv r11,r1
80048a4: 44 40 00 05 be r2,r0,80048b8 <_Rate_monotonic_Timeout+0x3c><== ALWAYS TAKEN
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
80048a8: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80048ac: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
80048b0: 37 9c 00 0c addi sp,sp,12 <== NOT EXECUTED
80048b4: c3 a0 00 00 ret <== NOT EXECUTED
*/
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_thread = the_period->owner;
80048b8: 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);
80048bc: 28 23 00 10 lw r3,(r1+16)
80048c0: 20 63 40 00 andi r3,r3,0x4000
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
80048c4: 44 62 00 04 be r3,r2,80048d4 <_Rate_monotonic_Timeout+0x58>
80048c8: 28 23 00 20 lw r3,(r1+32)
80048cc: 29 62 00 08 lw r2,(r11+8)
80048d0: 44 62 00 1a be r3,r2,8004938 <_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 ) {
80048d4: 29 62 00 38 lw r2,(r11+56)
80048d8: 34 01 00 01 mvi r1,1
80048dc: 44 41 00 0c be r2,r1,800490c <_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;
80048e0: 34 01 00 04 mvi r1,4
80048e4: 59 61 00 38 sw (r11+56),r1
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
80048e8: 78 01 08 02 mvhi r1,0x802
80048ec: 38 21 19 b8 ori r1,r1,0x19b8
80048f0: 28 22 00 00 lw r2,(r1+0)
80048f4: 34 42 ff ff addi r2,r2,-1
80048f8: 58 22 00 00 sw (r1+0),r2
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
80048fc: 2b 9d 00 04 lw ra,(sp+4)
8004900: 2b 8b 00 08 lw r11,(sp+8)
8004904: 37 9c 00 0c addi sp,sp,12
8004908: 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;
800490c: 34 02 00 03 mvi r2,3 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
8004910: 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;
8004914: 59 62 00 38 sw (r11+56),r2 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
8004918: fb ff fe 00 calli 8004118 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
800491c: 29 62 00 3c lw r2,(r11+60)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8004920: 78 01 08 02 mvhi r1,0x802
8004924: 38 21 1a 98 ori r1,r1,0x1a98
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
8004928: 59 62 00 1c sw (r11+28),r2
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
800492c: 35 62 00 10 addi r2,r11,16
8004930: f8 00 11 fa calli 8009118 <_Watchdog_Insert>
8004934: e3 ff ff ed bi 80048e8 <_Rate_monotonic_Timeout+0x6c>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
8004938: 78 03 08 01 mvhi r3,0x801
800493c: 38 63 f0 fc ori r3,r3,0xf0fc
8004940: 28 62 00 00 lw r2,(r3+0)
8004944: f8 00 0b a1 calli 80077c8 <_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 );
8004948: b9 60 08 00 mv r1,r11
800494c: e3 ff ff f3 bi 8004918 <_Rate_monotonic_Timeout+0x9c>
080041c4 <_Rate_monotonic_Update_statistics>:
void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
80041c4: 37 9c ff e0 addi sp,sp,-32
80041c8: 5b 8b 00 10 sw (sp+16),r11
80041cc: 5b 8c 00 0c sw (sp+12),r12
80041d0: 5b 8d 00 08 sw (sp+8),r13
80041d4: 5b 9d 00 04 sw (sp+4),ra
80041d8: b8 20 58 00 mv r11,r1
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
80041dc: 28 21 00 54 lw r1,(r1+84)
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
80041e0: 29 62 00 38 lw r2,(r11+56)
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
80041e4: 34 21 00 01 addi r1,r1,1
80041e8: 59 61 00 54 sw (r11+84),r1
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
80041ec: 34 01 00 04 mvi r1,4
80041f0: 44 41 00 36 be r2,r1,80042c8 <_Rate_monotonic_Update_statistics+0x104>
/*
* Grab status for time statistics.
*/
valid_status =
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
80041f4: 37 8c 00 14 addi r12,sp,20
80041f8: 37 8d 00 1c addi r13,sp,28
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
80041fc: b9 60 08 00 mv r1,r11
8004200: b9 80 10 00 mv r2,r12
8004204: b9 a0 18 00 mv r3,r13
8004208: fb ff ff 8a calli 8004030 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
800420c: 5c 20 00 07 bne r1,r0,8004228 <_Rate_monotonic_Update_statistics+0x64><== ALWAYS TAKEN
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
8004210: 2b 9d 00 04 lw ra,(sp+4)
8004214: 2b 8b 00 10 lw r11,(sp+16)
8004218: 2b 8c 00 0c lw r12,(sp+12)
800421c: 2b 8d 00 08 lw r13,(sp+8)
8004220: 37 9c 00 20 addi sp,sp,32
8004224: c3 a0 00 00 ret
/*
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
8004228: b9 a0 10 00 mv r2,r13
800422c: 35 61 00 6c addi r1,r11,108
8004230: f8 00 11 bc calli 8008920 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
8004234: b9 a0 08 00 mv r1,r13
8004238: 35 62 00 5c addi r2,r11,92
800423c: f8 00 12 a5 calli 8008cd0 <_Timespec_Less_than>
8004240: 44 20 00 05 be r1,r0,8004254 <_Rate_monotonic_Update_statistics+0x90>
stats->min_cpu_time = executed;
8004244: 2b 81 00 1c lw r1,(sp+28)
8004248: 59 61 00 5c sw (r11+92),r1
800424c: 2b 81 00 20 lw r1,(sp+32)
8004250: 59 61 00 60 sw (r11+96),r1
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
8004254: b9 a0 08 00 mv r1,r13
8004258: 35 62 00 64 addi r2,r11,100
800425c: f8 00 12 92 calli 8008ca4 <_Timespec_Greater_than>
8004260: 44 20 00 05 be r1,r0,8004274 <_Rate_monotonic_Update_statistics+0xb0>
stats->max_cpu_time = executed;
8004264: 2b 81 00 1c lw r1,(sp+28)
8004268: 59 61 00 64 sw (r11+100),r1
800426c: 2b 81 00 20 lw r1,(sp+32)
8004270: 59 61 00 68 sw (r11+104),r1
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
8004274: b9 80 10 00 mv r2,r12
8004278: 35 61 00 84 addi r1,r11,132
800427c: f8 00 11 a9 calli 8008920 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
8004280: b9 80 08 00 mv r1,r12
8004284: 35 62 00 74 addi r2,r11,116
8004288: f8 00 12 92 calli 8008cd0 <_Timespec_Less_than>
800428c: 5c 20 00 13 bne r1,r0,80042d8 <_Rate_monotonic_Update_statistics+0x114>
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
8004290: b9 80 08 00 mv r1,r12
8004294: 35 62 00 7c addi r2,r11,124
8004298: f8 00 12 83 calli 8008ca4 <_Timespec_Greater_than>
800429c: 44 20 ff dd be r1,r0,8004210 <_Rate_monotonic_Update_statistics+0x4c>
stats->max_wall_time = since_last_period;
80042a0: 2b 81 00 14 lw r1,(sp+20)
80042a4: 59 61 00 7c sw (r11+124),r1
80042a8: 2b 81 00 18 lw r1,(sp+24)
80042ac: 59 61 00 80 sw (r11+128),r1
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
80042b0: 2b 9d 00 04 lw ra,(sp+4)
80042b4: 2b 8b 00 10 lw r11,(sp+16)
80042b8: 2b 8c 00 0c lw r12,(sp+12)
80042bc: 2b 8d 00 08 lw r13,(sp+8)
80042c0: 37 9c 00 20 addi sp,sp,32
80042c4: c3 a0 00 00 ret
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
80042c8: 29 61 00 58 lw r1,(r11+88)
80042cc: 34 21 00 01 addi r1,r1,1
80042d0: 59 61 00 58 sw (r11+88),r1
80042d4: e3 ff ff c8 bi 80041f4 <_Rate_monotonic_Update_statistics+0x30>
*/
#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;
80042d8: 2b 81 00 14 lw r1,(sp+20)
80042dc: 59 61 00 74 sw (r11+116),r1
80042e0: 2b 81 00 18 lw r1,(sp+24)
80042e4: 59 61 00 78 sw (r11+120),r1
80042e8: e3 ff ff ea bi 8004290 <_Rate_monotonic_Update_statistics+0xcc>
0800a504 <_Scheduler_priority_Block>:
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract(
Thread_Control *the_thread
)
{
Chain_Control *ready = the_thread->scheduler.priority->ready_chain;
800a504: 28 43 00 8c lw r3,(r2+140)
800a508: 28 63 00 00 lw r3,(r3+0)
if ( _Chain_Has_only_one_node( ready ) ) {
800a50c: 28 65 00 00 lw r5,(r3+0)
800a510: 28 64 00 08 lw r4,(r3+8)
800a514: 44 a4 00 35 be r5,r4,800a5e8 <_Scheduler_priority_Block+0xe4>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
800a518: 28 44 00 00 lw r4,(r2+0)
previous = the_node->previous;
800a51c: 28 43 00 04 lw r3,(r2+4)
next->previous = previous;
800a520: 58 83 00 04 sw (r4+4),r3
previous->next = next;
800a524: 58 64 00 00 sw (r3+0),r4
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
800a528: 78 03 08 01 mvhi r3,0x801
800a52c: 38 63 4d 74 ori r3,r3,0x4d74
{
_Scheduler_priority_Ready_queue_extract(the_thread);
/* TODO: flash critical section */
if ( _Thread_Is_heir( the_thread ) )
800a530: 28 64 00 10 lw r4,(r3+16)
800a534: 44 44 00 07 be r2,r4,800a550 <_Scheduler_priority_Block+0x4c>
_Scheduler_priority_Schedule_body(the_scheduler);
if ( _Thread_Is_executing( the_thread ) )
800a538: 28 61 00 0c lw r1,(r3+12)
800a53c: 44 41 00 02 be r2,r1,800a544 <_Scheduler_priority_Block+0x40>
800a540: c3 a0 00 00 ret
_Thread_Dispatch_necessary = true;
800a544: 34 01 00 01 mvi r1,1
800a548: 30 61 00 18 sb (r3+24),r1
800a54c: 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 );
800a550: 78 04 08 01 mvhi r4,0x801
800a554: 38 84 4d 90 ori r4,r4,0x4d90
800a558: 2c 84 00 00 lhu r4,(r4+0)
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
_Scheduler_priority_Block_body(the_scheduler, the_thread);
}
800a55c: 28 27 00 00 lw r7,(r1+0)
800a560: 34 01 00 ff mvi r1,255
800a564: 20 84 ff ff andi r4,r4,0xffff
800a568: 54 81 00 3d bgu r4,r1,800a65c <_Scheduler_priority_Block+0x158>
800a56c: 78 05 08 01 mvhi r5,0x801
800a570: 38 a5 34 c0 ori r5,r5,0x34c0
800a574: b4 a4 20 00 add r4,r5,r4
800a578: 40 84 00 00 lbu r4,(r4+0)
800a57c: 34 84 00 08 addi r4,r4,8
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
800a580: 78 06 08 01 mvhi r6,0x801
800a584: 38 c6 4d 98 ori r6,r6,0x4d98
800a588: b4 84 20 00 add r4,r4,r4
800a58c: b4 c4 30 00 add r6,r6,r4
800a590: 2c c1 00 00 lhu r1,(r6+0)
800a594: 34 06 00 ff mvi r6,255
800a598: 54 26 00 26 bgu r1,r6,800a630 <_Scheduler_priority_Block+0x12c>
800a59c: b4 a1 08 00 add r1,r5,r1
800a5a0: 40 25 00 00 lbu r5,(r1+0)
800a5a4: 34 a5 00 08 addi r5,r5,8
return (_Priority_Bits_index( major ) << 4) +
800a5a8: b4 84 08 00 add r1,r4,r4
800a5ac: b4 21 08 00 add r1,r1,r1
800a5b0: b4 21 08 00 add r1,r1,r1
800a5b4: b4 a1 08 00 add r1,r5,r1
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
800a5b8: b4 21 20 00 add r4,r1,r1
800a5bc: b4 81 08 00 add r1,r4,r1
800a5c0: b4 21 08 00 add r1,r1,r1
800a5c4: b4 21 08 00 add r1,r1,r1
800a5c8: b4 e1 08 00 add r1,r7,r1
800a5cc: 28 25 00 00 lw r5,(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 );
800a5d0: 34 21 00 04 addi r1,r1,4
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
800a5d4: 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 ] ) )
800a5d8: 44 a1 00 02 be r5,r1,800a5e0 <_Scheduler_priority_Block+0xdc><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
800a5dc: b8 a0 20 00 mv r4,r5
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
800a5e0: 58 64 00 10 sw (r3+16),r4
800a5e4: e3 ff ff d5 bi 800a538 <_Scheduler_priority_Block+0x34>
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 );
800a5e8: 34 64 00 04 addi r4,r3,4
head->next = tail;
head->previous = NULL;
800a5ec: 58 60 00 04 sw (r3+4),r0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
800a5f0: 58 64 00 00 sw (r3+0),r4
head->previous = NULL;
tail->previous = head;
800a5f4: 58 63 00 08 sw (r3+8),r3
{
Chain_Control *ready = the_thread->scheduler.priority->ready_chain;
if ( _Chain_Has_only_one_node( ready ) ) {
_Chain_Initialize_empty( ready );
_Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map );
800a5f8: 28 43 00 8c lw r3,(r2+140)
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
800a5fc: 28 65 00 04 lw r5,(r3+4)
800a600: 2c 66 00 0e lhu r6,(r3+14)
800a604: 2c a4 00 00 lhu r4,(r5+0)
800a608: a0 86 20 00 and r4,r4,r6
800a60c: 0c a4 00 00 sh (r5+0),r4
if ( *the_priority_map->minor == 0 )
800a610: 5c 80 ff c6 bne r4,r0,800a528 <_Scheduler_priority_Block+0x24>
_Priority_Major_bit_map &= the_priority_map->block_major;
800a614: 78 04 08 01 mvhi r4,0x801
800a618: 38 84 4d 90 ori r4,r4,0x4d90
800a61c: 2c 85 00 00 lhu r5,(r4+0)
800a620: 2c 63 00 0c lhu r3,(r3+12)
800a624: a0 65 18 00 and r3,r3,r5
800a628: 0c 83 00 00 sh (r4+0),r3
800a62c: e3 ff ff bf bi 800a528 <_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 );
800a630: 00 21 00 01 srui r1,r1,1
800a634: 00 21 00 01 srui r1,r1,1
800a638: 00 21 00 01 srui r1,r1,1
800a63c: 00 21 00 01 srui r1,r1,1
800a640: 00 21 00 01 srui r1,r1,1
800a644: 00 21 00 01 srui r1,r1,1
800a648: 00 21 00 01 srui r1,r1,1
800a64c: 00 21 00 01 srui r1,r1,1
800a650: b4 a1 08 00 add r1,r5,r1
800a654: 40 25 00 00 lbu r5,(r1+0)
800a658: e3 ff ff d4 bi 800a5a8 <_Scheduler_priority_Block+0xa4>
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
800a65c: 00 84 00 01 srui r4,r4,1
800a660: 78 05 08 01 mvhi r5,0x801
800a664: 00 84 00 01 srui r4,r4,1
800a668: 38 a5 34 c0 ori r5,r5,0x34c0
800a66c: 00 84 00 01 srui r4,r4,1
800a670: 00 84 00 01 srui r4,r4,1
800a674: 00 84 00 01 srui r4,r4,1
800a678: 00 84 00 01 srui r4,r4,1
800a67c: 00 84 00 01 srui r4,r4,1
800a680: 00 84 00 01 srui r4,r4,1
800a684: b4 a4 20 00 add r4,r5,r4
800a688: 40 84 00 00 lbu r4,(r4+0)
800a68c: e3 ff ff bd bi 800a580 <_Scheduler_priority_Block+0x7c>
0800503c <_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 );
800503c: 78 02 08 01 mvhi r2,0x801
8005040: 38 42 4d 90 ori r2,r2,0x4d90
8005044: 2c 42 00 00 lhu r2,(r2+0)
void _Scheduler_priority_Schedule(
Scheduler_Control *the_scheduler
)
{
_Scheduler_priority_Schedule_body( the_scheduler );
}
8005048: 28 25 00 00 lw r5,(r1+0)
800504c: 34 01 00 ff mvi r1,255
8005050: 20 42 ff ff andi r2,r2,0xffff
8005054: 54 41 00 2d bgu r2,r1,8005108 <_Scheduler_priority_Schedule+0xcc>
8005058: 78 03 08 01 mvhi r3,0x801
800505c: 38 63 34 c0 ori r3,r3,0x34c0
8005060: b4 62 10 00 add r2,r3,r2
8005064: 40 42 00 00 lbu r2,(r2+0)
8005068: 34 42 00 08 addi r2,r2,8
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
800506c: 78 04 08 01 mvhi r4,0x801
8005070: 38 84 4d 98 ori r4,r4,0x4d98
8005074: b4 42 10 00 add r2,r2,r2
8005078: b4 82 20 00 add r4,r4,r2
800507c: 2c 81 00 00 lhu r1,(r4+0)
8005080: 34 04 00 ff mvi r4,255
8005084: 54 24 00 16 bgu r1,r4,80050dc <_Scheduler_priority_Schedule+0xa0>
8005088: b4 61 08 00 add r1,r3,r1
800508c: 40 23 00 00 lbu r3,(r1+0)
8005090: 34 63 00 08 addi r3,r3,8
return (_Priority_Bits_index( major ) << 4) +
8005094: b4 42 08 00 add r1,r2,r2
8005098: b4 21 08 00 add r1,r1,r1
800509c: b4 21 08 00 add r1,r1,r1
80050a0: 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 ] ) )
80050a4: b4 21 10 00 add r2,r1,r1
80050a8: b4 41 08 00 add r1,r2,r1
80050ac: b4 21 08 00 add r1,r1,r1
80050b0: b4 21 08 00 add r1,r1,r1
80050b4: b4 a1 08 00 add r1,r5,r1
80050b8: 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 );
80050bc: 34 21 00 04 addi r1,r1,4
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
80050c0: 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 ] ) )
80050c4: 44 61 00 02 be r3,r1,80050cc <_Scheduler_priority_Schedule+0x90><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
80050c8: b8 60 10 00 mv r2,r3
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
80050cc: 78 01 08 01 mvhi r1,0x801
80050d0: 38 21 4d 74 ori r1,r1,0x4d74
80050d4: 58 22 00 10 sw (r1+16),r2
80050d8: 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 );
80050dc: 00 21 00 01 srui r1,r1,1
80050e0: 00 21 00 01 srui r1,r1,1
80050e4: 00 21 00 01 srui r1,r1,1
80050e8: 00 21 00 01 srui r1,r1,1
80050ec: 00 21 00 01 srui r1,r1,1
80050f0: 00 21 00 01 srui r1,r1,1
80050f4: 00 21 00 01 srui r1,r1,1
80050f8: 00 21 00 01 srui r1,r1,1
80050fc: b4 61 08 00 add r1,r3,r1
8005100: 40 23 00 00 lbu r3,(r1+0)
8005104: e3 ff ff e4 bi 8005094 <_Scheduler_priority_Schedule+0x58>
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 );
8005108: 00 42 00 01 srui r2,r2,1
800510c: 78 03 08 01 mvhi r3,0x801
8005110: 00 42 00 01 srui r2,r2,1
8005114: 38 63 34 c0 ori r3,r3,0x34c0
8005118: 00 42 00 01 srui r2,r2,1
800511c: 00 42 00 01 srui r2,r2,1
8005120: 00 42 00 01 srui r2,r2,1
8005124: 00 42 00 01 srui r2,r2,1
8005128: 00 42 00 01 srui r2,r2,1
800512c: 00 42 00 01 srui r2,r2,1
8005130: b4 62 10 00 add r2,r3,r2
8005134: 40 42 00 00 lbu r2,(r2+0)
8005138: e3 ff ff cd bi 800506c <_Scheduler_priority_Schedule+0x30>
08003e44 <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
8003e44: 37 9c ff ec addi sp,sp,-20
8003e48: 5b 8b 00 0c sw (sp+12),r11
8003e4c: 5b 8c 00 08 sw (sp+8),r12
8003e50: 5b 9d 00 04 sw (sp+4),ra
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
8003e54: 78 01 08 01 mvhi r1,0x801
8003e58: 38 21 40 c4 ori r1,r1,0x40c4
8003e5c: 28 21 00 0c lw r1,(r1+12)
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
8003e60: 78 03 08 01 mvhi r3,0x801
8003e64: 38 63 49 d8 ori r3,r3,0x49d8
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
8003e68: b4 21 08 00 add r1,r1,r1
8003e6c: b4 21 08 00 add r1,r1,r1
8003e70: b4 21 08 00 add r1,r1,r1
8003e74: b4 21 10 00 add r2,r1,r1
8003e78: b4 42 10 00 add r2,r2,r2
8003e7c: b4 22 08 00 add r1,r1,r2
8003e80: b4 21 10 00 add r2,r1,r1
8003e84: b4 42 10 00 add r2,r2,r2
8003e88: b4 22 08 00 add r1,r1,r2
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
8003e8c: 28 65 00 00 lw r5,(r3+0)
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
8003e90: b4 21 20 00 add r4,r1,r1
8003e94: b4 84 20 00 add r4,r4,r4
8003e98: b4 24 20 00 add r4,r1,r4
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
8003e9c: 37 8b 00 10 addi r11,sp,16
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
8003ea0: 34 a5 00 01 addi r5,r5,1
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
8003ea4: 78 01 08 01 mvhi r1,0x801
8003ea8: b9 60 10 00 mv r2,r11
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
8003eac: 58 65 00 00 sw (r3+0),r5
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
8003eb0: 38 21 49 24 ori r1,r1,0x4924
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
8003eb4: 5b 84 00 14 sw (sp+20),r4
8003eb8: 5b 80 00 10 sw (sp+16),r0
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
8003ebc: f8 00 09 f2 calli 8006684 <_Timespec_Add_to>
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );
8003ec0: 78 01 08 01 mvhi r1,0x801
8003ec4: b9 60 10 00 mv r2,r11
8003ec8: 38 21 49 50 ori r1,r1,0x4950
8003ecc: f8 00 09 ee calli 8006684 <_Timespec_Add_to>
8003ed0: b8 20 58 00 mv r11,r1
while ( seconds ) {
8003ed4: 44 20 00 07 be r1,r0,8003ef0 <_TOD_Tickle_ticks+0xac>
8003ed8: 78 0c 08 01 mvhi r12,0x801
8003edc: 39 8c 49 7c ori r12,r12,0x497c
_Watchdog_Tickle_seconds();
seconds--;
8003ee0: 35 6b ff ff addi r11,r11,-1
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
8003ee4: b9 80 08 00 mv r1,r12
8003ee8: f8 00 0b c0 calli 8006de8 <_Watchdog_Tickle>
_Timestamp_Add_to( &_TOD_Uptime, &tick );
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );
while ( seconds ) {
8003eec: 5d 60 ff fd bne r11,r0,8003ee0 <_TOD_Tickle_ticks+0x9c> <== NEVER TAKEN
_Watchdog_Tickle_seconds();
seconds--;
}
}
8003ef0: 2b 9d 00 04 lw ra,(sp+4)
8003ef4: 2b 8b 00 0c lw r11,(sp+12)
8003ef8: 2b 8c 00 08 lw r12,(sp+8)
8003efc: 37 9c 00 14 addi sp,sp,20
8003f00: c3 a0 00 00 ret
08004458 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
8004458: 37 9c ff f4 addi sp,sp,-12
800445c: 5b 8b 00 0c sw (sp+12),r11
8004460: 5b 8c 00 08 sw (sp+8),r12
8004464: 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();
8004468: 78 02 08 02 mvhi r2,0x802
800446c: 38 42 20 c4 ori r2,r2,0x20c4
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
8004470: 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();
8004474: 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;
8004478: 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) ||
800447c: 44 20 00 22 be r1,r0,8004504 <_TOD_Validate+0xac> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
8004480: 78 03 08 01 mvhi r3,0x801
8004484: 38 63 f1 f0 ori r3,r3,0xf1f0
8004488: 28 61 00 00 lw r1,(r3+0)
800448c: f8 00 65 9b calli 801daf8 <__udivsi3>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
8004490: 29 62 00 18 lw r2,(r11+24)
8004494: 50 41 00 1c bgeu r2,r1,8004504 <_TOD_Validate+0xac>
(the_tod->ticks >= ticks_per_second) ||
8004498: 29 62 00 14 lw r2,(r11+20)
800449c: 34 01 00 3b mvi r1,59
80044a0: 54 41 00 19 bgu r2,r1,8004504 <_TOD_Validate+0xac>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
80044a4: 29 62 00 10 lw r2,(r11+16)
80044a8: 54 41 00 17 bgu r2,r1,8004504 <_TOD_Validate+0xac>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
80044ac: 29 62 00 0c lw r2,(r11+12)
80044b0: 34 01 00 17 mvi r1,23
80044b4: 54 41 00 14 bgu r2,r1,8004504 <_TOD_Validate+0xac>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
80044b8: 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) ||
80044bc: 44 20 00 12 be r1,r0,8004504 <_TOD_Validate+0xac> <== NEVER TAKEN
(the_tod->month == 0) ||
80044c0: 34 02 00 0c mvi r2,12
80044c4: 54 22 00 10 bgu r1,r2,8004504 <_TOD_Validate+0xac>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
80044c8: 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) ||
80044cc: 34 03 07 c3 mvi r3,1987
80044d0: 50 62 00 0d bgeu r3,r2,8004504 <_TOD_Validate+0xac>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
80044d4: 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) ||
80044d8: 44 60 00 0b be r3,r0,8004504 <_TOD_Validate+0xac> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
80044dc: 20 42 00 03 andi r2,r2,0x3
80044e0: 5c 40 00 02 bne r2,r0,80044e8 <_TOD_Validate+0x90>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
80044e4: 34 21 00 0d addi r1,r1,13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
80044e8: 78 02 08 01 mvhi r2,0x801
80044ec: b4 21 08 00 add r1,r1,r1
80044f0: 38 42 fa a0 ori r2,r2,0xfaa0
80044f4: b4 21 08 00 add r1,r1,r1
80044f8: b4 41 08 00 add r1,r2,r1
80044fc: 28 2c 00 00 lw r12,(r1+0)
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
8004500: f1 83 60 00 cmpgeu r12,r12,r3
if ( the_tod->day > days_in_month )
return false;
return true;
}
8004504: b9 80 08 00 mv r1,r12
8004508: 2b 9d 00 04 lw ra,(sp+4)
800450c: 2b 8b 00 0c lw r11,(sp+12)
8004510: 2b 8c 00 08 lw r12,(sp+8)
8004514: 37 9c 00 0c addi sp,sp,12
8004518: c3 a0 00 00 ret
0800534c <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
800534c: 37 9c ff ec addi sp,sp,-20
8005350: 5b 8b 00 14 sw (sp+20),r11
8005354: 5b 8c 00 10 sw (sp+16),r12
8005358: 5b 8d 00 0c sw (sp+12),r13
800535c: 5b 8e 00 08 sw (sp+8),r14
8005360: 5b 9d 00 04 sw (sp+4),ra
8005364: b8 20 58 00 mv r11,r1
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
8005368: 28 2d 00 10 lw r13,(r1+16)
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
800536c: b8 40 60 00 mv r12,r2
8005370: 20 6e 00 ff andi r14,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 );
8005374: f8 00 04 1b calli 80063e0 <_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 )
8005378: 29 61 00 14 lw r1,(r11+20)
800537c: 44 2c 00 04 be r1,r12,800538c <_Thread_Change_priority+0x40>
_Thread_Set_priority( the_thread, new_priority );
8005380: b9 60 08 00 mv r1,r11
8005384: b9 80 10 00 mv r2,r12
8005388: f8 00 03 ed calli 800633c <_Thread_Set_priority>
_ISR_Disable( level );
800538c: 90 00 60 00 rcsr r12,IE
8005390: 34 02 ff fe mvi r2,-2
8005394: a1 82 10 00 and r2,r12,r2
8005398: d0 02 00 00 wcsr IE,r2
/*
* 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;
800539c: 29 61 00 10 lw r1,(r11+16)
if ( state != STATES_TRANSIENT ) {
80053a0: 34 04 00 04 mvi r4,4
80053a4: 44 24 00 23 be r1,r4,8005430 <_Thread_Change_priority+0xe4>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_transient (
States_Control the_states
)
{
return (the_states & STATES_TRANSIENT);
80053a8: 21 ad 00 04 andi r13,r13,0x4
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
80053ac: 45 a0 00 0e be r13,r0,80053e4 <_Thread_Change_priority+0x98><== ALWAYS TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
80053b0: 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);
80053b4: 78 03 08 01 mvhi r3,0x801 <== NOT EXECUTED
80053b8: 38 63 36 28 ori r3,r3,0x3628 <== NOT EXECUTED
80053bc: 28 62 00 00 lw r2,(r3+0) <== NOT EXECUTED
80053c0: a0 22 08 00 and r1,r1,r2 <== NOT EXECUTED
if ( _States_Is_waiting_on_thread_queue( state ) ) {
80053c4: 5c 20 00 11 bne r1,r0,8005408 <_Thread_Change_priority+0xbc><== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
80053c8: 2b 9d 00 04 lw ra,(sp+4)
80053cc: 2b 8b 00 14 lw r11,(sp+20)
80053d0: 2b 8c 00 10 lw r12,(sp+16)
80053d4: 2b 8d 00 0c lw r13,(sp+12)
80053d8: 2b 8e 00 08 lw r14,(sp+8)
80053dc: 37 9c 00 14 addi sp,sp,20
80053e0: 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);
80053e4: 34 02 ff fb mvi r2,-5
80053e8: 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 );
80053ec: 59 62 00 10 sw (r11+16),r2
_ISR_Enable( level );
80053f0: 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);
80053f4: 78 03 08 01 mvhi r3,0x801
80053f8: 38 63 36 28 ori r3,r3,0x3628
80053fc: 28 62 00 00 lw r2,(r3+0)
8005400: a0 22 08 00 and r1,r1,r2
if ( _States_Is_waiting_on_thread_queue( state ) ) {
8005404: 44 20 ff f1 be r1,r0,80053c8 <_Thread_Change_priority+0x7c>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
8005408: 29 61 00 44 lw r1,(r11+68)
800540c: b9 60 10 00 mv r2,r11
8005410: f8 00 03 8e calli 8006248 <_Thread_queue_Requeue>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
8005414: 2b 9d 00 04 lw ra,(sp+4)
8005418: 2b 8b 00 14 lw r11,(sp+20)
800541c: 2b 8c 00 10 lw r12,(sp+16)
8005420: 2b 8d 00 0c lw r13,(sp+12)
8005424: 2b 8e 00 08 lw r14,(sp+8)
8005428: 37 9c 00 14 addi sp,sp,20
800542c: c3 a0 00 00 ret
*/
RTEMS_INLINE_ROUTINE bool _States_Is_transient (
States_Control the_states
)
{
return (the_states & STATES_TRANSIENT);
8005430: 21 ad 00 04 andi r13,r13,0x4
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
8005434: 5d a0 00 16 bne r13,r0,800548c <_Thread_Change_priority+0x140><== NEVER TAKEN
* Ready Queue with interrupts off.
*
* FIXME: hard-coded for priority scheduling. Might be ok since this
* function is specific to priority scheduling?
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
8005438: 59 60 00 10 sw (r11+16),r0
if ( prepend_it )
800543c: 45 cd 00 2b be r14,r13,80054e8 <_Thread_Change_priority+0x19c>
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue_first(
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
8005440: 29 61 00 8c lw r1,(r11+140)
8005444: 78 03 08 01 mvhi r3,0x801
8005448: 38 63 4d 90 ori r3,r3,0x4d90
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
800544c: 28 25 00 04 lw r5,(r1+4)
8005450: 2c 26 00 0a lhu r6,(r1+10)
_Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain,
8005454: 28 24 00 00 lw r4,(r1+0)
8005458: 2c a7 00 00 lhu r7,(r5+0)
800545c: b8 e6 30 00 or r6,r7,r6
8005460: 0c a6 00 00 sh (r5+0),r6
_Priority_Major_bit_map |= the_priority_map->ready_major;
8005464: 2c 26 00 08 lhu r6,(r1+8)
8005468: 2c 65 00 00 lhu r5,(r3+0)
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
800546c: 28 81 00 00 lw r1,(r4+0)
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
8005470: 59 64 00 04 sw (r11+4),r4
8005474: b8 c5 28 00 or r5,r6,r5
8005478: 20 a5 ff ff andi r5,r5,0xffff
800547c: 0c 65 00 00 sh (r3+0),r5
before_node = after_node->next;
after_node->next = the_node;
8005480: 58 8b 00 00 sw (r4+0),r11
the_node->next = before_node;
8005484: 59 61 00 00 sw (r11+0),r1
before_node->previous = the_node;
8005488: 58 2b 00 04 sw (r1+4),r11
_Scheduler_priority_Ready_queue_enqueue_first( the_thread );
else
_Scheduler_priority_Ready_queue_enqueue( the_thread );
}
_ISR_Flash( level );
800548c: d0 0c 00 00 wcsr IE,r12
8005490: d0 02 00 00 wcsr IE,r2
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule(
Scheduler_Control *the_scheduler
)
{
the_scheduler->Operations.schedule( the_scheduler );
8005494: 78 01 08 01 mvhi r1,0x801
8005498: 38 21 49 2c ori r1,r1,0x492c
800549c: 28 22 00 04 lw r2,(r1+4)
80054a0: d8 40 00 00 call r2
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
80054a4: 78 01 08 01 mvhi r1,0x801
80054a8: 38 21 4d 74 ori r1,r1,0x4d74
80054ac: 28 22 00 0c lw r2,(r1+12)
* 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(&_Scheduler);
if ( !_Thread_Is_executing_also_the_heir() &&
80054b0: 28 23 00 10 lw r3,(r1+16)
80054b4: 44 43 00 05 be r2,r3,80054c8 <_Thread_Change_priority+0x17c>
80054b8: 40 42 00 74 lbu r2,(r2+116)
80054bc: 44 40 00 03 be r2,r0,80054c8 <_Thread_Change_priority+0x17c>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
80054c0: 34 02 00 01 mvi r2,1
80054c4: 30 22 00 18 sb (r1+24),r2
_ISR_Enable( level );
80054c8: d0 0c 00 00 wcsr IE,r12
}
80054cc: 2b 9d 00 04 lw ra,(sp+4)
80054d0: 2b 8b 00 14 lw r11,(sp+20)
80054d4: 2b 8c 00 10 lw r12,(sp+16)
80054d8: 2b 8d 00 0c lw r13,(sp+12)
80054dc: 2b 8e 00 08 lw r14,(sp+8)
80054e0: 37 9c 00 14 addi sp,sp,20
80054e4: c3 a0 00 00 ret
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue(
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
80054e8: 29 61 00 8c lw r1,(r11+140)
80054ec: 78 03 08 01 mvhi r3,0x801
80054f0: 38 63 4d 90 ori r3,r3,0x4d90
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
80054f4: 28 25 00 04 lw r5,(r1+4)
80054f8: 2c 27 00 0a lhu r7,(r1+10)
_Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain,
80054fc: 28 24 00 00 lw r4,(r1+0)
8005500: 2c a8 00 00 lhu r8,(r5+0)
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
8005504: 34 86 00 04 addi r6,r4,4
8005508: b9 07 38 00 or r7,r8,r7
800550c: 0c a7 00 00 sh (r5+0),r7
_Priority_Major_bit_map |= the_priority_map->ready_major;
8005510: 2c 27 00 08 lhu r7,(r1+8)
8005514: 2c 65 00 00 lhu r5,(r3+0)
Chain_Node *old_last = tail->previous;
8005518: 28 81 00 08 lw r1,(r4+8)
the_node->next = tail;
tail->previous = the_node;
800551c: 58 8b 00 08 sw (r4+8),r11
8005520: b8 e5 20 00 or r4,r7,r5
8005524: 20 84 ff ff andi r4,r4,0xffff
8005528: 0c 64 00 00 sh (r3+0),r4
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
800552c: 59 66 00 00 sw (r11+0),r6
tail->previous = the_node;
old_last->next = the_node;
8005530: 58 2b 00 00 sw (r1+0),r11
the_node->previous = old_last;
8005534: 59 61 00 04 sw (r11+4),r1
8005538: e3 ff ff d5 bi 800548c <_Thread_Change_priority+0x140>
0800c82c <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
800c82c: 37 9c ff f8 addi sp,sp,-8
800c830: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
800c834: 37 82 00 08 addi r2,sp,8
800c838: f8 00 00 8a calli 800ca60 <_Thread_Get>
switch ( location ) {
800c83c: 2b 82 00 08 lw r2,(sp+8)
800c840: 5c 40 00 0a bne r2,r0,800c868 <_Thread_Delay_ended+0x3c> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
800c844: 78 03 08 02 mvhi r3,0x802
800c848: 38 63 79 90 ori r3,r3,0x7990
800c84c: 28 62 00 00 lw r2,(r3+0)
800c850: fb ff ff 64 calli 800c5e0 <_Thread_Clear_state>
800c854: 78 01 08 02 mvhi r1,0x802
800c858: 38 21 aa 20 ori r1,r1,0xaa20
800c85c: 28 22 00 00 lw r2,(r1+0)
800c860: 34 42 ff ff addi r2,r2,-1
800c864: 58 22 00 00 sw (r1+0),r2
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
800c868: 2b 9d 00 04 lw ra,(sp+4)
800c86c: 37 9c 00 08 addi sp,sp,8
800c870: c3 a0 00 00 ret
08005710 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
8005710: 37 9c ff bc addi sp,sp,-68
8005714: 5b 8b 00 34 sw (sp+52),r11
8005718: 5b 8c 00 30 sw (sp+48),r12
800571c: 5b 8d 00 2c sw (sp+44),r13
8005720: 5b 8e 00 28 sw (sp+40),r14
8005724: 5b 8f 00 24 sw (sp+36),r15
8005728: 5b 90 00 20 sw (sp+32),r16
800572c: 5b 91 00 1c sw (sp+28),r17
8005730: 5b 92 00 18 sw (sp+24),r18
8005734: 5b 93 00 14 sw (sp+20),r19
8005738: 5b 94 00 10 sw (sp+16),r20
800573c: 5b 95 00 0c sw (sp+12),r21
8005740: 5b 96 00 08 sw (sp+8),r22
8005744: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
8005748: 78 01 08 01 mvhi r1,0x801
800574c: 38 21 4d 74 ori r1,r1,0x4d74
8005750: 28 2c 00 0c lw r12,(r1+12)
_ISR_Disable( level );
8005754: 90 00 08 00 rcsr r1,IE
8005758: 34 02 ff fe mvi r2,-2
800575c: a0 22 10 00 and r2,r1,r2
8005760: d0 02 00 00 wcsr IE,r2
while ( _Thread_Dispatch_necessary == true ) {
8005764: 78 0e 08 01 mvhi r14,0x801
8005768: 39 ce 4d 74 ori r14,r14,0x4d74
800576c: 41 c2 00 18 lbu r2,(r14+24)
8005770: 78 10 08 01 mvhi r16,0x801
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
8005774: b8 20 20 00 mv r4,r1
while ( _Thread_Dispatch_necessary == true ) {
8005778: 20 42 00 ff andi r2,r2,0xff
800577c: 3a 10 48 a8 ori r16,r16,0x48a8
8005780: 44 40 00 40 be r2,r0,8005880 <_Thread_Dispatch+0x170>
heir = _Thread_Heir;
8005784: 29 cb 00 10 lw r11,(r14+16)
_Thread_Dispatch_disable_level = 1;
8005788: 34 02 00 01 mvi r2,1
800578c: 5a 02 00 00 sw (r16+0),r2
_Thread_Dispatch_necessary = false;
8005790: 31 c0 00 18 sb (r14+24),r0
_Thread_Executing = heir;
8005794: 59 cb 00 0c sw (r14+12),r11
/*
* 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 )
8005798: 45 8b 00 3a be r12,r11,8005880 <_Thread_Dispatch+0x170>
800579c: 78 0f 08 01 mvhi r15,0x801
80057a0: 78 14 08 01 mvhi r20,0x801
#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;
80057a4: 78 15 08 01 mvhi r21,0x801
80057a8: 37 92 00 40 addi r18,sp,64
80057ac: 39 ef 49 74 ori r15,r15,0x4974
80057b0: 37 91 00 38 addi r17,sp,56
80057b4: 3a 94 49 4c ori r20,r20,0x494c
*/
#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 )
80057b8: 34 13 00 01 mvi r19,1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
80057bc: 3a b5 48 40 ori r21,r21,0x4840
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
80057c0: 34 16 ff fe mvi r22,-2
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
80057c4: b9 c0 68 00 mv r13,r14
80057c8: e0 00 00 29 bi 800586c <_Thread_Dispatch+0x15c>
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;
_ISR_Enable( level );
80057cc: d0 01 00 00 wcsr IE,r1
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
80057d0: ba 40 08 00 mv r1,r18
80057d4: f8 00 12 07 calli 8009ff0 <_TOD_Get_uptime>
_Timestamp_Subtract(
80057d8: ba 20 18 00 mv r3,r17
80057dc: b9 e0 08 00 mv r1,r15
80057e0: ba 40 10 00 mv r2,r18
80057e4: f8 00 03 bf calli 80066e0 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
80057e8: ba 20 10 00 mv r2,r17
80057ec: 35 81 00 84 addi r1,r12,132
80057f0: f8 00 03 a5 calli 8006684 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
80057f4: 2b 83 00 40 lw r3,(sp+64)
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
80057f8: 2a 84 00 00 lw r4,(r20+0)
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
80057fc: b9 80 08 00 mv r1,r12
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
8005800: 59 e3 00 00 sw (r15+0),r3
8005804: 2b 83 00 44 lw r3,(sp+68)
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
8005808: b9 60 10 00 mv r2,r11
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
800580c: 59 e3 00 04 sw (r15+4),r3
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
8005810: 44 80 00 05 be r4,r0,8005824 <_Thread_Dispatch+0x114> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
8005814: 28 83 00 00 lw r3,(r4+0)
8005818: 59 83 01 18 sw (r12+280),r3
*_Thread_libc_reent = heir->libc_reent;
800581c: 29 63 01 18 lw r3,(r11+280)
8005820: 58 83 00 00 sw (r4+0),r3
}
_User_extensions_Thread_switch( executing, heir );
8005824: f8 00 04 b6 calli 8006afc <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
8005828: 35 81 00 c4 addi r1,r12,196
800582c: 35 62 00 c4 addi r2,r11,196
8005830: f8 00 05 eb calli 8006fdc <_CPU_Context_switch>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
8005834: 29 cc 00 0c lw r12,(r14+12)
_ISR_Disable( level );
8005838: 90 00 20 00 rcsr r4,IE
800583c: a0 96 08 00 and r1,r4,r22
8005840: d0 01 00 00 wcsr IE,r1
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
8005844: 41 a2 00 18 lbu r2,(r13+24)
8005848: b9 a0 70 00 mv r14,r13
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
800584c: b8 80 08 00 mv r1,r4
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
8005850: 20 42 00 ff andi r2,r2,0xff
8005854: 44 40 00 0b be r2,r0,8005880 <_Thread_Dispatch+0x170> <== ALWAYS TAKEN
heir = _Thread_Heir;
8005858: 29 ab 00 10 lw r11,(r13+16) <== NOT EXECUTED
_Thread_Dispatch_disable_level = 1;
800585c: 5a 13 00 00 sw (r16+0),r19 <== NOT EXECUTED
_Thread_Dispatch_necessary = false;
8005860: 31 a0 00 18 sb (r13+24),r0 <== NOT EXECUTED
_Thread_Executing = heir;
8005864: 59 ab 00 0c sw (r13+12),r11 <== NOT EXECUTED
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
8005868: 45 6c 00 06 be r11,r12,8005880 <_Thread_Dispatch+0x170> <== NOT EXECUTED
*/
#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 )
800586c: 29 62 00 7c lw r2,(r11+124)
8005870: 5c 53 ff d7 bne r2,r19,80057cc <_Thread_Dispatch+0xbc>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
8005874: 2a a2 00 00 lw r2,(r21+0)
8005878: 59 62 00 78 sw (r11+120),r2
800587c: e3 ff ff d4 bi 80057cc <_Thread_Dispatch+0xbc>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
8005880: 5a 00 00 00 sw (r16+0),r0
_ISR_Enable( level );
8005884: d0 04 00 00 wcsr IE,r4
_API_extensions_Run_postswitch();
8005888: fb ff f7 a2 calli 8003710 <_API_extensions_Run_postswitch>
}
800588c: 2b 9d 00 04 lw ra,(sp+4)
8005890: 2b 8b 00 34 lw r11,(sp+52)
8005894: 2b 8c 00 30 lw r12,(sp+48)
8005898: 2b 8d 00 2c lw r13,(sp+44)
800589c: 2b 8e 00 28 lw r14,(sp+40)
80058a0: 2b 8f 00 24 lw r15,(sp+36)
80058a4: 2b 90 00 20 lw r16,(sp+32)
80058a8: 2b 91 00 1c lw r17,(sp+28)
80058ac: 2b 92 00 18 lw r18,(sp+24)
80058b0: 2b 93 00 14 lw r19,(sp+20)
80058b4: 2b 94 00 10 lw r20,(sp+16)
80058b8: 2b 95 00 0c lw r21,(sp+12)
80058bc: 2b 96 00 08 lw r22,(sp+8)
80058c0: 37 9c 00 44 addi sp,sp,68
80058c4: c3 a0 00 00 ret
0800cb3c <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
800cb3c: 37 9c ff f4 addi sp,sp,-12
800cb40: 5b 8b 00 0c sw (sp+12),r11
800cb44: 5b 8c 00 08 sw (sp+8),r12
800cb48: 5b 9d 00 04 sw (sp+4),ra
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
800cb4c: 78 01 08 01 mvhi r1,0x801
800cb50: 38 21 4d 74 ori r1,r1,0x4d74
800cb54: 28 2b 00 0c lw r11,(r1+12)
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
800cb58: 29 61 00 ac lw r1,(r11+172)
_ISR_Set_level(level);
800cb5c: 64 21 00 00 cmpei r1,r1,0
800cb60: d0 01 00 00 wcsr IE,r1
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
800cb64: 78 02 08 01 mvhi r2,0x801
800cb68: 38 42 46 bc ori r2,r2,0x46bc
800cb6c: 40 4c 00 00 lbu r12,(r2+0)
doneConstructors = 1;
800cb70: 34 03 00 01 mvi r3,1
/*
* Take care that 'begin' extensions get to complete before
* 'switch' extensions can run. This means must keep dispatch
* disabled until all 'begin' extensions complete.
*/
_User_extensions_Thread_begin( executing );
800cb74: b9 60 08 00 mv r1,r11
level = executing->Start.isr_level;
_ISR_Set_level(level);
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
doneConstructors = 1;
800cb78: 30 43 00 00 sb (r2+0),r3
/*
* Take care that 'begin' extensions get to complete before
* 'switch' extensions can run. This means must keep dispatch
* disabled until all 'begin' extensions complete.
*/
_User_extensions_Thread_begin( executing );
800cb7c: fb ff e7 34 calli 800684c <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
800cb80: fb ff e3 52 calli 80058c8 <_Thread_Enable_dispatch>
/*
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (!doneCons) /* && (volatile void *)_init) */ {
800cb84: 45 80 00 0b be r12,r0,800cbb0 <_Thread_Handler+0x74>
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
800cb88: 29 61 00 94 lw r1,(r11+148)
800cb8c: 44 20 00 0c be r1,r0,800cbbc <_Thread_Handler+0x80>
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
800cb90: 34 02 00 01 mvi r2,1
800cb94: 44 22 00 0f be r1,r2,800cbd0 <_Thread_Handler+0x94> <== ALWAYS TAKEN
* was placed in return_argument. This assumed that if it returned
* anything (which is not supporting in all APIs), then it would be
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
800cb98: b9 60 08 00 mv r1,r11
800cb9c: fb ff e7 44 calli 80068ac <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
800cba0: 34 01 00 00 mvi r1,0
800cba4: 34 02 00 01 mvi r2,1
800cba8: 34 03 00 05 mvi r3,5
800cbac: fb ff de 15 calli 8004400 <_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 (!doneCons) /* && (volatile void *)_init) */ {
INIT_NAME ();
800cbb0: fb ff cd 14 calli 8000000 <RamBase>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
800cbb4: 29 61 00 94 lw r1,(r11+148)
800cbb8: 5c 20 ff f6 bne r1,r0,800cb90 <_Thread_Handler+0x54>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
800cbbc: 29 62 00 90 lw r2,(r11+144)
800cbc0: 29 61 00 9c lw r1,(r11+156)
800cbc4: d8 40 00 00 call r2
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
800cbc8: 59 61 00 28 sw (r11+40),r1
800cbcc: e3 ff ff f3 bi 800cb98 <_Thread_Handler+0x5c>
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
800cbd0: 29 62 00 90 lw r2,(r11+144)
800cbd4: 29 61 00 98 lw r1,(r11+152)
800cbd8: 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 =
800cbdc: 59 61 00 28 sw (r11+40),r1
800cbe0: e3 ff ff ee bi 800cb98 <_Thread_Handler+0x5c>
0800a9c8 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
800a9c8: 37 9c ff f8 addi sp,sp,-8
800a9cc: 5b 8b 00 08 sw (sp+8),r11
800a9d0: 5b 9d 00 04 sw (sp+4),ra
800a9d4: b8 20 10 00 mv r2,r1
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
800a9d8: 90 00 58 00 rcsr r11,IE
800a9dc: 34 01 ff fe mvi r1,-2
800a9e0: a1 61 08 00 and r1,r11,r1
800a9e4: d0 01 00 00 wcsr IE,r1
current_state = the_thread->current_state;
800a9e8: 28 41 00 10 lw r1,(r2+16)
if ( current_state & STATES_SUSPENDED ) {
800a9ec: 20 23 00 02 andi r3,r1,0x2
800a9f0: 44 60 00 05 be r3,r0,800aa04 <_Thread_Resume+0x3c> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
800a9f4: 34 03 ff fd mvi r3,-3
800a9f8: a0 23 08 00 and r1,r1,r3
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
800a9fc: 58 41 00 10 sw (r2+16),r1
if ( _States_Is_ready( current_state ) ) {
800aa00: 44 20 00 06 be r1,r0,800aa18 <_Thread_Resume+0x50>
_Scheduler_Unblock( &_Scheduler, the_thread );
}
}
_ISR_Enable( level );
800aa04: d0 0b 00 00 wcsr IE,r11
}
800aa08: 2b 9d 00 04 lw ra,(sp+4)
800aa0c: 2b 8b 00 08 lw r11,(sp+8)
800aa10: 37 9c 00 08 addi sp,sp,8
800aa14: c3 a0 00 00 ret
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
the_scheduler->Operations.unblock( the_scheduler, the_thread );
800aa18: 78 01 08 01 mvhi r1,0x801
800aa1c: 38 21 a9 f4 ori r1,r1,0xa9f4
800aa20: 28 23 00 10 lw r3,(r1+16)
800aa24: d8 60 00 00 call r3
if ( _States_Is_ready( current_state ) ) {
_Scheduler_Unblock( &_Scheduler, the_thread );
}
}
_ISR_Enable( level );
800aa28: d0 0b 00 00 wcsr IE,r11
}
800aa2c: 2b 9d 00 04 lw ra,(sp+4)
800aa30: 2b 8b 00 08 lw r11,(sp+8)
800aa34: 37 9c 00 08 addi sp,sp,8
800aa38: c3 a0 00 00 ret
080065e0 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
80065e0: 37 9c ff f8 addi sp,sp,-8
80065e4: 5b 8b 00 08 sw (sp+8),r11
80065e8: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *executing;
executing = _Thread_Executing;
80065ec: 78 01 08 01 mvhi r1,0x801
80065f0: 38 21 4d 74 ori r1,r1,0x4d74
80065f4: 28 2b 00 0c lw r11,(r1+12)
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
80065f8: 41 61 00 74 lbu r1,(r11+116)
80065fc: 44 20 00 09 be r1,r0,8006620 <_Thread_Tickle_timeslice+0x40>
return;
if ( !_States_Is_ready( executing->current_state ) )
8006600: 29 61 00 10 lw r1,(r11+16)
8006604: 5c 20 00 07 bne r1,r0,8006620 <_Thread_Tickle_timeslice+0x40>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
8006608: 29 61 00 7c lw r1,(r11+124)
800660c: 44 20 00 05 be r1,r0,8006620 <_Thread_Tickle_timeslice+0x40>
8006610: 34 02 00 02 mvi r2,2
8006614: 50 41 00 0f bgeu r2,r1,8006650 <_Thread_Tickle_timeslice+0x70>
8006618: 34 02 00 03 mvi r2,3
800661c: 44 22 00 05 be r1,r2,8006630 <_Thread_Tickle_timeslice+0x50><== ALWAYS TAKEN
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
#endif
}
}
8006620: 2b 9d 00 04 lw ra,(sp+4)
8006624: 2b 8b 00 08 lw r11,(sp+8)
8006628: 37 9c 00 08 addi sp,sp,8
800662c: 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 )
8006630: 29 61 00 78 lw r1,(r11+120)
8006634: 34 21 ff ff addi r1,r1,-1
8006638: 59 61 00 78 sw (r11+120),r1
800663c: 5c 20 ff f9 bne r1,r0,8006620 <_Thread_Tickle_timeslice+0x40>
(*executing->budget_callout)( executing );
8006640: 29 62 00 80 lw r2,(r11+128)
8006644: b9 60 08 00 mv r1,r11
8006648: d8 40 00 00 call r2
800664c: e3 ff ff f5 bi 8006620 <_Thread_Tickle_timeslice+0x40>
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 ) {
8006650: 29 61 00 78 lw r1,(r11+120)
8006654: 34 21 ff ff addi r1,r1,-1
8006658: 59 61 00 78 sw (r11+120),r1
800665c: 48 20 ff f1 bg r1,r0,8006620 <_Thread_Tickle_timeslice+0x40>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield( &_Scheduler );
8006660: 78 01 08 01 mvhi r1,0x801
8006664: 38 21 49 2c ori r1,r1,0x492c
8006668: 28 22 00 08 lw r2,(r1+8)
800666c: 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;
8006670: 78 01 08 01 mvhi r1,0x801
8006674: 38 21 48 40 ori r1,r1,0x4840
8006678: 28 21 00 00 lw r1,(r1+0)
800667c: 59 61 00 78 sw (r11+120),r1
8006680: e3 ff ff e8 bi 8006620 <_Thread_Tickle_timeslice+0x40>
08005fa8 <_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
)
{
8005fa8: 37 9c ff f4 addi sp,sp,-12
8005fac: 5b 8b 00 0c sw (sp+12),r11
8005fb0: 5b 8c 00 08 sw (sp+8),r12
8005fb4: 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;
8005fb8: 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 );
8005fbc: 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 );
8005fc0: 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);
8005fc4: 00 a4 00 01 srui r4,r5,1
8005fc8: 78 0c 08 01 mvhi r12,0x801
8005fcc: 00 84 00 01 srui r4,r4,1
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8005fd0: 58 47 00 38 sw (r2+56),r7
8005fd4: 00 84 00 01 srui r4,r4,1
head->previous = NULL;
tail->previous = head;
8005fd8: 58 46 00 40 sw (r2+64),r6
8005fdc: 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;
8005fe0: 58 40 00 3c sw (r2+60),r0
8005fe4: 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 );
8005fe8: 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);
8005fec: 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;
8005ff0: 28 27 00 38 lw r7,(r1+56)
8005ff4: b4 84 30 00 add r6,r4,r4
8005ff8: 39 8c 40 c0 ori r12,r12,0x40c0
if ( _Thread_queue_Is_reverse_search( priority ) )
8005ffc: 5d 00 00 18 bne r8,r0,800605c <_Thread_queue_Enqueue_priority+0xb4>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
8006000: b4 c4 20 00 add r4,r6,r4
8006004: b4 84 20 00 add r4,r4,r4
8006008: b4 84 20 00 add r4,r4,r4
800600c: 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 );
8006010: 34 0d ff fe mvi r13,-2
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
8006014: 35 8b 00 04 addi r11,r12,4
8006018: 90 00 40 00 rcsr r8,IE
800601c: a1 0d 50 00 and r10,r8,r13
8006020: d0 0a 00 00 wcsr IE,r10
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
8006024: 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 ) ) {
8006028: 5c 8b 00 04 bne r4,r11,8006038 <_Thread_queue_Enqueue_priority+0x90>
800602c: e0 00 00 24 bi 80060bc <_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;
8006030: 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 ) ) {
8006034: 44 8b 00 23 be r4,r11,80060c0 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
8006038: 28 86 00 14 lw r6,(r4+20)
if ( priority <= search_priority )
800603c: 50 c5 00 21 bgeu r6,r5,80060c0 <_Thread_queue_Enqueue_priority+0x118>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
8006040: d0 08 00 00 wcsr IE,r8
8006044: 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);
8006048: 28 89 00 10 lw r9,(r4+16)
800604c: a0 e9 48 00 and r9,r7,r9
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
8006050: 5d 20 ff f8 bne r9,r0,8006030 <_Thread_queue_Enqueue_priority+0x88><== ALWAYS TAKEN
_ISR_Enable( level );
8006054: d0 08 00 00 wcsr IE,r8 <== NOT EXECUTED
goto restart_forward_search;
8006058: e3 ff ff f0 bi 8006018 <_Thread_queue_Enqueue_priority+0x70><== NOT EXECUTED
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
800605c: b4 c4 20 00 add r4,r6,r4
8006060: b4 84 20 00 add r4,r4,r4
8006064: 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 );
8006068: 34 0d ff fe mvi r13,-2
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
800606c: 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;
8006070: 41 86 00 00 lbu r6,(r12+0)
8006074: 34 c6 00 01 addi r6,r6,1
_ISR_Disable( level );
8006078: 90 00 40 00 rcsr r8,IE
800607c: a1 0d 58 00 and r11,r8,r13
8006080: d0 0b 00 00 wcsr IE,r11
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
8006084: 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 ) ) {
8006088: 5c 8a 00 04 bne r4,r10,8006098 <_Thread_queue_Enqueue_priority+0xf0>
800608c: e0 00 00 18 bi 80060ec <_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;
8006090: 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 ) ) {
8006094: 44 8a 00 16 be r4,r10,80060ec <_Thread_queue_Enqueue_priority+0x144>
search_priority = search_thread->current_priority;
8006098: 28 86 00 14 lw r6,(r4+20)
if ( priority >= search_priority )
800609c: 50 a6 00 14 bgeu r5,r6,80060ec <_Thread_queue_Enqueue_priority+0x144>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
80060a0: d0 08 00 00 wcsr IE,r8
80060a4: d0 0b 00 00 wcsr IE,r11
80060a8: 28 89 00 10 lw r9,(r4+16)
80060ac: a0 e9 48 00 and r9,r7,r9
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
80060b0: 5d 20 ff f8 bne r9,r0,8006090 <_Thread_queue_Enqueue_priority+0xe8><== ALWAYS TAKEN
_ISR_Enable( level );
80060b4: d0 08 00 00 wcsr IE,r8 <== NOT EXECUTED
goto restart_reverse_search;
80060b8: e3 ff ff ee bi 8006070 <_Thread_queue_Enqueue_priority+0xc8><== NOT EXECUTED
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
80060bc: 34 06 ff ff mvi r6,-1
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
80060c0: 28 27 00 30 lw r7,(r1+48)
80060c4: 34 0a 00 01 mvi r10,1
80060c8: b9 00 48 00 mv r9,r8
80060cc: 44 ea 00 1b be r7,r10,8006138 <_Thread_queue_Enqueue_priority+0x190>
* 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;
80060d0: 58 69 00 00 sw (r3+0),r9
return the_thread_queue->sync_state;
}
80060d4: b8 e0 08 00 mv r1,r7
80060d8: 2b 8b 00 0c lw r11,(sp+12)
80060dc: 2b 8c 00 08 lw r12,(sp+8)
80060e0: 2b 8d 00 04 lw r13,(sp+4)
80060e4: 37 9c 00 0c addi sp,sp,12
80060e8: c3 a0 00 00 ret
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
80060ec: 28 27 00 30 lw r7,(r1+48)
80060f0: 34 0a 00 01 mvi r10,1
80060f4: b9 00 48 00 mv r9,r8
80060f8: 5c ea ff f6 bne r7,r10,80060d0 <_Thread_queue_Enqueue_priority+0x128><== NEVER TAKEN
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
80060fc: 58 20 00 30 sw (r1+48),r0
if ( priority == search_priority )
8006100: 44 a6 00 1d be r5,r6,8006174 <_Thread_queue_Enqueue_priority+0x1cc>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
8006104: 28 83 00 00 lw r3,(r4+0)
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
8006108: 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;
800610c: 58 43 00 00 sw (r2+0),r3
the_node->previous = search_node;
search_node->next = the_node;
8006110: 58 82 00 00 sw (r4+0),r2
next_node->previous = the_node;
8006114: 58 62 00 04 sw (r3+4),r2
the_thread->Wait.queue = the_thread_queue;
8006118: 58 41 00 44 sw (r2+68),r1
_ISR_Enable( level );
800611c: d0 08 00 00 wcsr IE,r8
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
8006120: b8 e0 08 00 mv r1,r7
8006124: 2b 8b 00 0c lw r11,(sp+12)
8006128: 2b 8c 00 08 lw r12,(sp+8)
800612c: 2b 8d 00 04 lw r13,(sp+4)
8006130: 37 9c 00 0c addi sp,sp,12
8006134: 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;
8006138: 58 20 00 30 sw (r1+48),r0
if ( priority == search_priority )
800613c: 44 a6 00 0e be r5,r6,8006174 <_Thread_queue_Enqueue_priority+0x1cc>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
8006140: 28 83 00 04 lw r3,(r4+4)
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
8006144: 58 44 00 00 sw (r2+0),r4
the_node->previous = previous_node;
8006148: 58 43 00 04 sw (r2+4),r3
previous_node->next = the_node;
800614c: 58 62 00 00 sw (r3+0),r2
search_node->previous = the_node;
8006150: 58 82 00 04 sw (r4+4),r2
the_thread->Wait.queue = the_thread_queue;
8006154: 58 41 00 44 sw (r2+68),r1
_ISR_Enable( level );
8006158: d0 08 00 00 wcsr IE,r8
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
800615c: b8 e0 08 00 mv r1,r7
8006160: 2b 8b 00 0c lw r11,(sp+12)
8006164: 2b 8c 00 08 lw r12,(sp+8)
8006168: 2b 8d 00 04 lw r13,(sp+4)
800616c: 37 9c 00 0c addi sp,sp,12
8006170: 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;
8006174: 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 );
8006178: 34 85 00 3c addi r5,r4,60
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
800617c: 58 45 00 00 sw (r2+0),r5
the_node->previous = previous_node;
8006180: 58 43 00 04 sw (r2+4),r3
previous_node->next = the_node;
8006184: 58 62 00 00 sw (r3+0),r2
search_node->previous = the_node;
8006188: 58 82 00 40 sw (r4+64),r2
the_thread->Wait.queue = the_thread_queue;
800618c: 58 41 00 44 sw (r2+68),r1
_ISR_Enable( level );
8006190: d0 08 00 00 wcsr IE,r8
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8006194: 34 07 00 01 mvi r7,1
8006198: e3 ff ff cf bi 80060d4 <_Thread_queue_Enqueue_priority+0x12c>
0800aa60 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
800aa60: 37 9c ff fc addi sp,sp,-4
800aa64: 5b 9d 00 04 sw (sp+4),ra
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
800aa68: 28 23 00 44 lw r3,(r1+68)
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
800aa6c: 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 &&
800aa70: 28 62 00 30 lw r2,(r3+48)
800aa74: 44 40 00 05 be r2,r0,800aa88 <_Thread_queue_Process_timeout+0x28>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
800aa78: 78 01 08 01 mvhi r1,0x801
800aa7c: 38 21 4d 74 ori r1,r1,0x4d74
800aa80: 28 21 00 0c lw r1,(r1+12)
800aa84: 44 81 00 09 be r4,r1,800aaa8 <_Thread_queue_Process_timeout+0x48><== NEVER TAKEN
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;
800aa88: 28 65 00 3c lw r5,(r3+60)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
800aa8c: b8 60 08 00 mv r1,r3
800aa90: 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;
800aa94: 58 85 00 34 sw (r4+52),r5
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
800aa98: fb ff ff 8f calli 800a8d4 <_Thread_queue_Extract>
}
}
800aa9c: 2b 9d 00 04 lw ra,(sp+4)
800aaa0: 37 9c 00 04 addi sp,sp,4
800aaa4: 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 ) {
800aaa8: 34 01 00 03 mvi r1,3 <== NOT EXECUTED
800aaac: 44 41 ff fc be r2,r1,800aa9c <_Thread_queue_Process_timeout+0x3c><== NOT EXECUTED
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
800aab0: 28 61 00 3c lw r1,(r3+60) <== NOT EXECUTED
800aab4: 58 81 00 34 sw (r4+52),r1 <== NOT EXECUTED
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
800aab8: 34 01 00 02 mvi r1,2 <== NOT EXECUTED
800aabc: 58 61 00 30 sw (r3+48),r1 <== NOT EXECUTED
800aac0: e3 ff ff f7 bi 800aa9c <_Thread_queue_Process_timeout+0x3c><== NOT EXECUTED
08006248 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
8006248: 37 9c ff ec addi sp,sp,-20
800624c: 5b 8b 00 10 sw (sp+16),r11
8006250: 5b 8c 00 0c sw (sp+12),r12
8006254: 5b 8d 00 08 sw (sp+8),r13
8006258: 5b 9d 00 04 sw (sp+4),ra
800625c: b8 20 58 00 mv r11,r1
8006260: 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 )
8006264: 44 20 00 04 be r1,r0,8006274 <_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 ) {
8006268: 28 22 00 34 lw r2,(r1+52)
800626c: 34 01 00 01 mvi r1,1
8006270: 44 41 00 07 be r2,r1,800628c <_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 );
}
}
8006274: 2b 9d 00 04 lw ra,(sp+4)
8006278: 2b 8b 00 10 lw r11,(sp+16) <== NOT EXECUTED
800627c: 2b 8c 00 0c lw r12,(sp+12) <== NOT EXECUTED
8006280: 2b 8d 00 08 lw r13,(sp+8) <== NOT EXECUTED
8006284: 37 9c 00 14 addi sp,sp,20 <== NOT EXECUTED
8006288: 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 );
800628c: 90 00 68 00 rcsr r13,IE
8006290: 34 01 ff fe mvi r1,-2
8006294: a1 a1 08 00 and r1,r13,r1
8006298: d0 01 00 00 wcsr IE,r1
800629c: 78 03 08 01 mvhi r3,0x801
80062a0: 38 63 36 28 ori r3,r3,0x3628
80062a4: 29 82 00 10 lw r2,(r12+16)
80062a8: 28 61 00 00 lw r1,(r3+0)
80062ac: a0 41 08 00 and r1,r2,r1
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
80062b0: 5c 20 00 08 bne r1,r0,80062d0 <_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 );
80062b4: d0 0d 00 00 wcsr IE,r13
}
}
80062b8: 2b 9d 00 04 lw ra,(sp+4)
80062bc: 2b 8b 00 10 lw r11,(sp+16)
80062c0: 2b 8c 00 0c lw r12,(sp+12)
80062c4: 2b 8d 00 08 lw r13,(sp+8)
80062c8: 37 9c 00 14 addi sp,sp,20
80062cc: 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;
80062d0: 34 01 00 01 mvi r1,1
80062d4: 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 );
80062d8: b9 80 10 00 mv r2,r12
80062dc: b9 60 08 00 mv r1,r11
80062e0: 34 03 00 01 mvi r3,1
80062e4: f8 00 11 8a calli 800a90c <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
80062e8: b9 60 08 00 mv r1,r11
80062ec: b9 80 10 00 mv r2,r12
80062f0: 37 83 00 14 addi r3,sp,20
80062f4: fb ff ff 2d calli 8005fa8 <_Thread_queue_Enqueue_priority>
}
_ISR_Enable( level );
80062f8: d0 0d 00 00 wcsr IE,r13
80062fc: e3 ff ff ef bi 80062b8 <_Thread_queue_Requeue+0x70>
08006300 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
8006300: 37 9c ff f8 addi sp,sp,-8
8006304: 5b 9d 00 04 sw (sp+4),ra
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
8006308: 37 82 00 08 addi r2,sp,8
800630c: fb ff fd 7c calli 80058fc <_Thread_Get>
switch ( location ) {
8006310: 2b 82 00 08 lw r2,(sp+8)
8006314: 5c 40 00 07 bne r2,r0,8006330 <_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 );
8006318: f8 00 11 d2 calli 800aa60 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
800631c: 78 01 08 01 mvhi r1,0x801
8006320: 38 21 48 a8 ori r1,r1,0x48a8
8006324: 28 22 00 00 lw r2,(r1+0)
8006328: 34 42 ff ff addi r2,r2,-1
800632c: 58 22 00 00 sw (r1+0),r2
_Thread_Unnest_dispatch();
break;
}
}
8006330: 2b 9d 00 04 lw ra,(sp+4)
8006334: 37 9c 00 08 addi sp,sp,8
8006338: c3 a0 00 00 ret
080144a8 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
80144a8: 37 9c ff a4 addi sp,sp,-92
80144ac: 5b 8b 00 44 sw (sp+68),r11
80144b0: 5b 8c 00 40 sw (sp+64),r12
80144b4: 5b 8d 00 3c sw (sp+60),r13
80144b8: 5b 8e 00 38 sw (sp+56),r14
80144bc: 5b 8f 00 34 sw (sp+52),r15
80144c0: 5b 90 00 30 sw (sp+48),r16
80144c4: 5b 91 00 2c sw (sp+44),r17
80144c8: 5b 92 00 28 sw (sp+40),r18
80144cc: 5b 93 00 24 sw (sp+36),r19
80144d0: 5b 94 00 20 sw (sp+32),r20
80144d4: 5b 95 00 1c sw (sp+28),r21
80144d8: 5b 96 00 18 sw (sp+24),r22
80144dc: 5b 97 00 14 sw (sp+20),r23
80144e0: 5b 98 00 10 sw (sp+16),r24
80144e4: 5b 99 00 0c sw (sp+12),r25
80144e8: 5b 9b 00 08 sw (sp+8),fp
80144ec: 5b 9d 00 04 sw (sp+4),ra
80144f0: 78 14 08 04 mvhi r20,0x804
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
80144f4: 37 96 00 54 addi r22,sp,84
80144f8: 37 95 00 58 addi r21,sp,88
80144fc: 37 8e 00 48 addi r14,sp,72
8014500: 37 92 00 4c addi r18,sp,76
8014504: 78 13 08 04 mvhi r19,0x804
8014508: 78 17 08 04 mvhi r23,0x804
801450c: b8 20 58 00 mv r11,r1
8014510: 5b 95 00 54 sw (sp+84),r21
head->previous = NULL;
8014514: 5b 80 00 58 sw (sp+88),r0
tail->previous = head;
8014518: 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;
801451c: 5b 92 00 48 sw (sp+72),r18
head->previous = NULL;
8014520: 5b 80 00 4c sw (sp+76),r0
tail->previous = head;
8014524: 5b 8e 00 50 sw (sp+80),r14
8014528: 3a 94 0d e0 ori r20,r20,0xde0
801452c: 34 30 00 30 addi r16,r1,48
8014530: 3a 73 0d 58 ori r19,r19,0xd58
8014534: 34 2f 00 68 addi r15,r1,104
8014538: 3a f7 0c b0 ori r23,r23,0xcb0
801453c: 34 3b 00 08 addi fp,r1,8
8014540: 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 ) {
8014544: 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 );
8014548: 34 11 ff fe mvi r17,-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;
801454c: 34 18 00 01 mvi r24,1
Chain_Control *tmp;
/*
* 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;
8014550: 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;
8014554: 2a 82 00 00 lw r2,(r20+0)
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
8014558: 29 63 00 3c lw r3,(r11+60)
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
801455c: ba 00 08 00 mv r1,r16
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
8014560: 59 62 00 3c sw (r11+60),r2
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
8014564: c8 43 10 00 sub r2,r2,r3
8014568: b9 c0 18 00 mv r3,r14
801456c: f8 00 15 9f calli 8019be8 <_Watchdog_Adjust_to_chain>
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
8014570: 29 64 00 74 lw r4,(r11+116)
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
8014574: 2a 6c 00 00 lw r12,(r19+0)
/*
* 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 ) {
8014578: 50 8c 00 31 bgeu r4,r12,801463c <_Timer_server_Body+0x194>
/*
* 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 );
801457c: b9 e0 08 00 mv r1,r15
8014580: c9 84 10 00 sub r2,r12,r4
8014584: b9 c0 18 00 mv r3,r14
8014588: f8 00 15 98 calli 8019be8 <_Watchdog_Adjust_to_chain>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
801458c: 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 ) {
8014590: 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 );
8014594: 29 61 00 78 lw r1,(r11+120)
8014598: f8 00 03 50 calli 80152d8 <_Chain_Get>
801459c: b8 20 10 00 mv r2,r1
if ( timer == NULL ) {
80145a0: 44 20 00 0b be r1,r0,80145cc <_Timer_server_Body+0x124>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
80145a4: 28 24 00 38 lw r4,(r1+56)
80145a8: 44 8c 00 2b be r4,r12,8014654 <_Timer_server_Body+0x1ac>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
80145ac: 5c 8d ff fa bne r4,r13,8014594 <_Timer_server_Body+0xec> <== NEVER TAKEN
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
80145b0: 34 42 00 10 addi r2,r2,16
80145b4: b9 e0 08 00 mv r1,r15
80145b8: f8 00 15 b2 calli 8019c80 <_Watchdog_Insert>
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
80145bc: 29 61 00 78 lw r1,(r11+120)
80145c0: f8 00 03 46 calli 80152d8 <_Chain_Get>
80145c4: b8 20 10 00 mv r2,r1
if ( timer == NULL ) {
80145c8: 5c 20 ff f7 bne r1,r0,80145a4 <_Timer_server_Body+0xfc> <== 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 );
80145cc: 90 00 10 00 rcsr r2,IE
80145d0: a0 51 18 00 and r3,r2,r17
80145d4: d0 03 00 00 wcsr IE,r3
tmp = ts->insert_chain;
if ( _Chain_Is_empty( insert_chain ) ) {
80145d8: 2b 84 00 54 lw r4,(sp+84)
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
tmp = ts->insert_chain;
80145dc: 29 63 00 78 lw r3,(r11+120)
if ( _Chain_Is_empty( insert_chain ) ) {
80145e0: 34 03 00 01 mvi r3,1
80145e4: 44 95 00 20 be r4,r21,8014664 <_Timer_server_Body+0x1bc>
ts->insert_chain = NULL;
do_loop = false;
}
_ISR_Enable( level );
80145e8: d0 02 00 00 wcsr IE,r2
* 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;
while ( do_loop ) {
80145ec: 5c 60 ff da bne r3,r0,8014554 <_Timer_server_Body+0xac>
_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 ) ) {
80145f0: 2b 82 00 48 lw r2,(sp+72)
80145f4: 5c 52 00 0b bne r2,r18,8014620 <_Timer_server_Body+0x178>
80145f8: e0 00 00 1e bi 8014670 <_Timer_server_Body+0x1c8>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
80145fc: 28 43 00 00 lw r3,(r2+0)
head->next = new_first;
new_first->previous = head;
8014600: 58 6e 00 04 sw (r3+4),r14
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
8014604: 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;
8014608: 58 40 00 08 sw (r2+8),r0
_ISR_Enable( level );
801460c: 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 );
8014610: 28 43 00 1c lw r3,(r2+28)
8014614: 28 41 00 20 lw r1,(r2+32)
8014618: 28 42 00 24 lw r2,(r2+36)
801461c: 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 );
8014620: 90 00 20 00 rcsr r4,IE
8014624: a0 91 10 00 and r2,r4,r17
8014628: d0 02 00 00 wcsr IE,r2
initialized = false;
}
#endif
return status;
}
801462c: 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))
8014630: 5c 52 ff f3 bne r2,r18,80145fc <_Timer_server_Body+0x154>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
8014634: d0 04 00 00 wcsr IE,r4
8014638: e3 ff ff c6 bi 8014550 <_Timer_server_Body+0xa8>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
801463c: 51 84 ff d4 bgeu r12,r4,801458c <_Timer_server_Body+0xe4>
/*
* 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 );
8014640: b9 e0 08 00 mv r1,r15
8014644: 34 02 00 01 mvi r2,1
8014648: c8 8c 18 00 sub r3,r4,r12
801464c: f8 00 15 29 calli 8019af0 <_Watchdog_Adjust>
8014650: e3 ff ff cf bi 801458c <_Timer_server_Body+0xe4>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
8014654: ba 00 08 00 mv r1,r16
8014658: 34 42 00 10 addi r2,r2,16
801465c: f8 00 15 89 calli 8019c80 <_Watchdog_Insert>
8014660: e3 ff ff cd bi 8014594 <_Timer_server_Body+0xec>
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
tmp = ts->insert_chain;
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
8014664: 59 60 00 78 sw (r11+120),r0
do_loop = false;
8014668: 34 03 00 00 mvi r3,0
801466c: e3 ff ff df bi 80145e8 <_Timer_server_Body+0x140>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
8014670: 31 60 00 7c sb (r11+124),r0
8014674: 2a e1 00 00 lw r1,(r23+0)
8014678: 34 21 00 01 addi r1,r1,1
801467c: 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 );
8014680: 29 61 00 00 lw r1,(r11+0)
8014684: 34 02 00 08 mvi r2,8
8014688: f8 00 12 cd calli 80191bc <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
801468c: b9 60 08 00 mv r1,r11
8014690: fb ff ff 44 calli 80143a0 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
8014694: b9 60 08 00 mv r1,r11
8014698: fb ff ff 63 calli 8014424 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
801469c: f8 00 0f d0 calli 80185dc <_Thread_Enable_dispatch>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
80146a0: 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;
80146a4: 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 );
80146a8: f8 00 15 e1 calli 8019e2c <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
80146ac: bb 20 08 00 mv r1,r25
80146b0: f8 00 15 df calli 8019e2c <_Watchdog_Remove>
80146b4: e3 ff ff a7 bi 8014550 <_Timer_server_Body+0xa8>
080146b8 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
80146b8: 37 9c ff f8 addi sp,sp,-8
80146bc: 5b 8b 00 08 sw (sp+8),r11
80146c0: 5b 9d 00 04 sw (sp+4),ra
80146c4: b8 20 58 00 mv r11,r1
if ( ts->insert_chain == NULL ) {
80146c8: 28 21 00 78 lw r1,(r1+120)
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
80146cc: b8 40 18 00 mv r3,r2
if ( ts->insert_chain == NULL ) {
80146d0: 44 20 00 07 be r1,r0,80146ec <_Timer_server_Schedule_operation_method+0x34>
* 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 );
80146d4: 29 61 00 78 lw r1,(r11+120)
80146d8: f8 00 02 ea calli 8015280 <_Chain_Append>
}
}
80146dc: 2b 9d 00 04 lw ra,(sp+4)
80146e0: 2b 8b 00 08 lw r11,(sp+8)
80146e4: 37 9c 00 08 addi sp,sp,8
80146e8: c3 a0 00 00 ret
80146ec: 78 01 08 04 mvhi r1,0x804
80146f0: 38 21 0c b0 ori r1,r1,0xcb0
80146f4: 28 22 00 00 lw r2,(r1+0)
80146f8: 34 42 00 01 addi r2,r2,1
80146fc: 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 ) {
8014700: 28 61 00 38 lw r1,(r3+56)
8014704: 34 02 00 01 mvi r2,1
8014708: 44 22 00 28 be r1,r2,80147a8 <_Timer_server_Schedule_operation_method+0xf0>
_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 ) {
801470c: 34 02 00 03 mvi r2,3
8014710: 44 22 00 06 be r1,r2,8014728 <_Timer_server_Schedule_operation_method+0x70>
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
8014714: f8 00 0f b2 calli 80185dc <_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 );
}
}
8014718: 2b 9d 00 04 lw ra,(sp+4)
801471c: 2b 8b 00 08 lw r11,(sp+8)
8014720: 37 9c 00 08 addi sp,sp,8
8014724: 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 );
8014728: 90 00 38 00 rcsr r7,IE
801472c: 34 01 ff fe mvi r1,-2
8014730: a0 e1 08 00 and r1,r7,r1
8014734: d0 01 00 00 wcsr IE,r1
initialized = false;
}
#endif
return status;
}
8014738: 29 62 00 68 lw r2,(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();
801473c: 78 01 08 04 mvhi r1,0x804
last_snapshot = ts->TOD_watchdogs.last_snapshot;
8014740: 29 64 00 74 lw r4,(r11+116)
/*
* 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();
8014744: 38 21 0d 58 ori r1,r1,0xd58
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8014748: 35 65 00 6c addi r5,r11,108
801474c: 28 21 00 00 lw r1,(r1+0)
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
8014750: 44 45 00 0a be r2,r5,8014778 <_Timer_server_Schedule_operation_method+0xc0>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
8014754: 28 46 00 10 lw r6,(r2+16)
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
8014758: b4 c4 28 00 add r5,r6,r4
delta_interval += delta;
801475c: c8 a1 28 00 sub r5,r5,r1
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 ) {
8014760: 50 81 00 05 bgeu r4,r1,8014774 <_Timer_server_Schedule_operation_method+0xbc>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
8014764: c8 24 20 00 sub r4,r1,r4
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
8014768: 34 05 00 00 mvi r5,0
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
801476c: 50 86 00 02 bgeu r4,r6,8014774 <_Timer_server_Schedule_operation_method+0xbc><== NEVER TAKEN
delta_interval -= delta;
8014770: c8 c4 28 00 sub r5,r6,r4
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
8014774: 58 45 00 10 sw (r2+16),r5
}
ts->TOD_watchdogs.last_snapshot = snapshot;
8014778: 59 61 00 74 sw (r11+116),r1
_ISR_Enable( level );
801477c: d0 07 00 00 wcsr IE,r7
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
8014780: 35 61 00 68 addi r1,r11,104
8014784: 34 62 00 10 addi r2,r3,16
8014788: f8 00 15 3e calli 8019c80 <_Watchdog_Insert>
if ( !ts->active ) {
801478c: 41 61 00 7c lbu r1,(r11+124)
8014790: 20 21 00 ff andi r1,r1,0xff
8014794: 5c 20 ff e0 bne r1,r0,8014714 <_Timer_server_Schedule_operation_method+0x5c>
_Timer_server_Reset_tod_system_watchdog( ts );
8014798: b9 60 08 00 mv r1,r11
801479c: fb ff ff 22 calli 8014424 <_Timer_server_Reset_tod_system_watchdog>
}
}
_Thread_Enable_dispatch();
80147a0: f8 00 0f 8f calli 80185dc <_Thread_Enable_dispatch>
80147a4: e3 ff ff dd bi 8014718 <_Timer_server_Schedule_operation_method+0x60>
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 );
80147a8: 90 00 20 00 rcsr r4,IE
80147ac: 34 01 ff fe mvi r1,-2
80147b0: a0 81 08 00 and r1,r4,r1
80147b4: d0 01 00 00 wcsr IE,r1
snapshot = _Watchdog_Ticks_since_boot;
80147b8: 78 01 08 04 mvhi r1,0x804
80147bc: 38 21 0d e0 ori r1,r1,0xde0
initialized = false;
}
#endif
return status;
}
80147c0: 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;
80147c4: 28 21 00 00 lw r1,(r1+0)
last_snapshot = ts->Interval_watchdogs.last_snapshot;
80147c8: 29 66 00 3c lw r6,(r11+60)
80147cc: 35 65 00 34 addi r5,r11,52
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
80147d0: 44 45 00 07 be r2,r5,80147ec <_Timer_server_Schedule_operation_method+0x134>
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
80147d4: 28 47 00 10 lw r7,(r2+16)
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
80147d8: c8 26 30 00 sub r6,r1,r6
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
80147dc: 34 05 00 00 mvi r5,0
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
80147e0: 50 c7 00 02 bgeu r6,r7,80147e8 <_Timer_server_Schedule_operation_method+0x130>
delta_interval -= delta;
80147e4: c8 e6 28 00 sub r5,r7,r6
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
80147e8: 58 45 00 10 sw (r2+16),r5
}
ts->Interval_watchdogs.last_snapshot = snapshot;
80147ec: 59 61 00 3c sw (r11+60),r1
_ISR_Enable( level );
80147f0: d0 04 00 00 wcsr IE,r4
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
80147f4: 35 61 00 30 addi r1,r11,48
80147f8: 34 62 00 10 addi r2,r3,16
80147fc: f8 00 15 21 calli 8019c80 <_Watchdog_Insert>
if ( !ts->active ) {
8014800: 41 61 00 7c lbu r1,(r11+124)
8014804: 20 21 00 ff andi r1,r1,0xff
8014808: 5c 20 ff c3 bne r1,r0,8014714 <_Timer_server_Schedule_operation_method+0x5c>
_Timer_server_Reset_interval_system_watchdog( ts );
801480c: b9 60 08 00 mv r1,r11
8014810: fb ff fe e4 calli 80143a0 <_Timer_server_Reset_interval_system_watchdog>
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
8014814: f8 00 0f 72 calli 80185dc <_Thread_Enable_dispatch>
8014818: e3 ff ff c0 bi 8014718 <_Timer_server_Schedule_operation_method+0x60>
08006904 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
8006904: 37 9c ff e8 addi sp,sp,-24
8006908: 5b 8b 00 18 sw (sp+24),r11
800690c: 5b 8c 00 14 sw (sp+20),r12
8006910: 5b 8d 00 10 sw (sp+16),r13
8006914: 5b 8e 00 0c sw (sp+12),r14
8006918: 5b 8f 00 08 sw (sp+8),r15
800691c: 5b 9d 00 04 sw (sp+4),ra
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
8006920: 78 0c 08 01 mvhi r12,0x801
8006924: 39 8c 4a 24 ori r12,r12,0x4a24
8006928: 29 8b 00 08 lw r11,(r12+8)
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
800692c: b8 20 78 00 mv r15,r1
8006930: b8 60 70 00 mv r14,r3
8006934: 20 4d 00 ff andi r13,r2,0xff
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
8006938: 45 6c 00 09 be r11,r12,800695c <_User_extensions_Fatal+0x58><== NEVER TAKEN
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
800693c: 29 64 00 30 lw r4,(r11+48)
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
8006940: b9 e0 08 00 mv r1,r15
8006944: b9 a0 10 00 mv r2,r13
8006948: b9 c0 18 00 mv r3,r14
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
800694c: 44 80 00 02 be r4,r0,8006954 <_User_extensions_Fatal+0x50>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
8006950: d8 80 00 00 call r4
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
8006954: 29 6b 00 04 lw r11,(r11+4)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
8006958: 5d 6c ff f9 bne r11,r12,800693c <_User_extensions_Fatal+0x38>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
800695c: 2b 9d 00 04 lw ra,(sp+4)
8006960: 2b 8b 00 18 lw r11,(sp+24)
8006964: 2b 8c 00 14 lw r12,(sp+20)
8006968: 2b 8d 00 10 lw r13,(sp+16)
800696c: 2b 8e 00 0c lw r14,(sp+12)
8006970: 2b 8f 00 08 lw r15,(sp+8)
8006974: 37 9c 00 18 addi sp,sp,24
8006978: c3 a0 00 00 ret
08006738 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
8006738: 37 9c ff ec addi sp,sp,-20
800673c: 5b 8b 00 14 sw (sp+20),r11
8006740: 5b 8c 00 10 sw (sp+16),r12
8006744: 5b 8d 00 0c sw (sp+12),r13
8006748: 5b 8e 00 08 sw (sp+8),r14
800674c: 5b 9d 00 04 sw (sp+4),ra
User_extensions_Control *extension;
uint32_t i;
uint32_t number_of_extensions;
User_extensions_Table *initial_extensions;
number_of_extensions = Configuration.number_of_initial_extensions;
8006750: 78 03 08 01 mvhi r3,0x801
8006754: 38 63 40 c4 ori r3,r3,0x40c4
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8006758: 78 02 08 01 mvhi r2,0x801
800675c: 78 05 08 01 mvhi r5,0x801
8006760: 78 01 08 01 mvhi r1,0x801
8006764: 78 04 08 01 mvhi r4,0x801
initial_extensions = Configuration.User_extension_table;
8006768: 28 6b 00 40 lw r11,(r3+64)
800676c: 38 42 4a 24 ori r2,r2,0x4a24
8006770: 38 21 48 ac ori r1,r1,0x48ac
8006774: 38 a5 4a 28 ori r5,r5,0x4a28
8006778: 38 84 48 b0 ori r4,r4,0x48b0
800677c: 58 45 00 00 sw (r2+0),r5
head->previous = NULL;
8006780: 58 40 00 04 sw (r2+4),r0
tail->previous = head;
8006784: 58 42 00 08 sw (r2+8),r2
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8006788: 58 24 00 00 sw (r1+0),r4
head->previous = NULL;
800678c: 58 20 00 04 sw (r1+4),r0
tail->previous = head;
8006790: 58 21 00 08 sw (r1+8),r1
User_extensions_Control *extension;
uint32_t i;
uint32_t number_of_extensions;
User_extensions_Table *initial_extensions;
number_of_extensions = Configuration.number_of_initial_extensions;
8006794: 28 6e 00 3c lw r14,(r3+60)
initial_extensions = Configuration.User_extension_table;
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
8006798: 45 60 00 26 be r11,r0,8006830 <_User_extensions_Handler_initialization+0xf8><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
800679c: b5 ce 68 00 add r13,r14,r14
80067a0: b5 ae 68 00 add r13,r13,r14
80067a4: b5 ad 68 00 add r13,r13,r13
80067a8: b5 ad 68 00 add r13,r13,r13
80067ac: b5 ae 68 00 add r13,r13,r14
80067b0: b5 ad 68 00 add r13,r13,r13
80067b4: b5 ad 68 00 add r13,r13,r13
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
80067b8: b9 a0 08 00 mv r1,r13
80067bc: f8 00 01 f9 calli 8006fa0 <_Workspace_Allocate_or_fatal_error>
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
80067c0: 34 02 00 00 mvi r2,0
80067c4: b9 a0 18 00 mv r3,r13
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
80067c8: b8 20 60 00 mv r12,r1
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
80067cc: f8 00 1c 79 calli 800d9b0 <memset>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
80067d0: 45 c0 00 18 be r14,r0,8006830 <_User_extensions_Handler_initialization+0xf8><== NEVER TAKEN
80067d4: 34 0d 00 00 mvi r13,0
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
80067d8: 29 62 00 00 lw r2,(r11+0)
_User_extensions_Add_set( extension );
80067dc: b9 80 08 00 mv r1,r12
80067e0: 35 ad 00 01 addi r13,r13,1
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
80067e4: 59 82 00 14 sw (r12+20),r2
80067e8: 29 62 00 04 lw r2,(r11+4)
80067ec: 59 82 00 18 sw (r12+24),r2
80067f0: 29 62 00 08 lw r2,(r11+8)
80067f4: 59 82 00 1c sw (r12+28),r2
80067f8: 29 62 00 0c lw r2,(r11+12)
80067fc: 59 82 00 20 sw (r12+32),r2
8006800: 29 62 00 10 lw r2,(r11+16)
8006804: 59 82 00 24 sw (r12+36),r2
8006808: 29 62 00 14 lw r2,(r11+20)
800680c: 59 82 00 28 sw (r12+40),r2
8006810: 29 62 00 18 lw r2,(r11+24)
8006814: 59 82 00 2c sw (r12+44),r2
8006818: 29 62 00 1c lw r2,(r11+28)
800681c: 35 6b 00 20 addi r11,r11,32
8006820: 59 82 00 30 sw (r12+48),r2
_User_extensions_Add_set( extension );
8006824: f8 00 10 e6 calli 800abbc <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
8006828: 35 8c 00 34 addi r12,r12,52
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
800682c: 55 cd ff eb bgu r14,r13,80067d8 <_User_extensions_Handler_initialization+0xa0>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
8006830: 2b 9d 00 04 lw ra,(sp+4)
8006834: 2b 8b 00 14 lw r11,(sp+20)
8006838: 2b 8c 00 10 lw r12,(sp+16)
800683c: 2b 8d 00 0c lw r13,(sp+12)
8006840: 2b 8e 00 08 lw r14,(sp+8)
8006844: 37 9c 00 14 addi sp,sp,20
8006848: c3 a0 00 00 ret
0800684c <_User_extensions_Thread_begin>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
800684c: 37 9c ff f0 addi sp,sp,-16
8006850: 5b 8b 00 10 sw (sp+16),r11
8006854: 5b 8c 00 0c sw (sp+12),r12
8006858: 5b 8d 00 08 sw (sp+8),r13
800685c: 5b 9d 00 04 sw (sp+4),ra
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
8006860: 78 02 08 01 mvhi r2,0x801
8006864: 38 42 4a 24 ori r2,r2,0x4a24
8006868: 28 4b 00 00 lw r11,(r2+0)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
800686c: 78 0c 08 01 mvhi r12,0x801
8006870: 39 8c 4a 28 ori r12,r12,0x4a28
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
8006874: b8 20 68 00 mv r13,r1
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
8006878: 45 6c 00 07 be r11,r12,8006894 <_User_extensions_Thread_begin+0x48><== NEVER TAKEN
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
800687c: 29 62 00 28 lw r2,(r11+40)
(*the_extension->Callouts.thread_begin)( executing );
8006880: b9 a0 08 00 mv r1,r13
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
8006884: 44 40 00 02 be r2,r0,800688c <_User_extensions_Thread_begin+0x40>
(*the_extension->Callouts.thread_begin)( executing );
8006888: d8 40 00 00 call r2
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
800688c: 29 6b 00 00 lw r11,(r11+0)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
8006890: 5d 6c ff fb bne r11,r12,800687c <_User_extensions_Thread_begin+0x30>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
(*the_extension->Callouts.thread_begin)( executing );
}
}
8006894: 2b 9d 00 04 lw ra,(sp+4)
8006898: 2b 8b 00 10 lw r11,(sp+16)
800689c: 2b 8c 00 0c lw r12,(sp+12)
80068a0: 2b 8d 00 08 lw r13,(sp+8)
80068a4: 37 9c 00 10 addi sp,sp,16
80068a8: c3 a0 00 00 ret
0800697c <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
800697c: 37 9c ff ec addi sp,sp,-20
8006980: 5b 8b 00 14 sw (sp+20),r11
8006984: 5b 8c 00 10 sw (sp+16),r12
8006988: 5b 8d 00 0c sw (sp+12),r13
800698c: 5b 8e 00 08 sw (sp+8),r14
8006990: 5b 9d 00 04 sw (sp+4),ra
return false;
}
}
return true;
}
8006994: 78 02 08 01 mvhi r2,0x801
8006998: 38 42 4a 24 ori r2,r2,0x4a24
800699c: 28 4b 00 00 lw r11,(r2+0)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
80069a0: 78 0c 08 01 mvhi r12,0x801
80069a4: 39 8c 4a 28 ori r12,r12,0x4a28
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
80069a8: b8 20 70 00 mv r14,r1
if ( !status )
return false;
}
}
return true;
80069ac: 34 01 00 01 mvi r1,1
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
80069b0: 45 6c 00 0c be r11,r12,80069e0 <_User_extensions_Thread_create+0x64><== NEVER TAKEN
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
status = (*the_extension->Callouts.thread_create)(
80069b4: 78 0d 08 01 mvhi r13,0x801
80069b8: 39 ad 4d 74 ori r13,r13,0x4d74
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
80069bc: 29 63 00 14 lw r3,(r11+20)
status = (*the_extension->Callouts.thread_create)(
80069c0: b9 c0 10 00 mv r2,r14
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
80069c4: 44 60 00 04 be r3,r0,80069d4 <_User_extensions_Thread_create+0x58>
status = (*the_extension->Callouts.thread_create)(
80069c8: 29 a1 00 0c lw r1,(r13+12)
80069cc: d8 60 00 00 call r3
_Thread_Executing,
the_thread
);
if ( !status )
80069d0: 44 20 00 0b be r1,r0,80069fc <_User_extensions_Thread_create+0x80>
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
80069d4: 29 6b 00 00 lw r11,(r11+0)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
80069d8: 5d 6c ff f9 bne r11,r12,80069bc <_User_extensions_Thread_create+0x40>
if ( !status )
return false;
}
}
return true;
80069dc: 34 01 00 01 mvi r1,1
}
80069e0: 2b 9d 00 04 lw ra,(sp+4)
80069e4: 2b 8b 00 14 lw r11,(sp+20)
80069e8: 2b 8c 00 10 lw r12,(sp+16)
80069ec: 2b 8d 00 0c lw r13,(sp+12)
80069f0: 2b 8e 00 08 lw r14,(sp+8)
80069f4: 37 9c 00 14 addi sp,sp,20
80069f8: c3 a0 00 00 ret
status = (*the_extension->Callouts.thread_create)(
_Thread_Executing,
the_thread
);
if ( !status )
return false;
80069fc: 34 01 00 00 mvi r1,0
}
}
return true;
}
8006a00: 2b 9d 00 04 lw ra,(sp+4)
8006a04: 2b 8b 00 14 lw r11,(sp+20)
8006a08: 2b 8c 00 10 lw r12,(sp+16)
8006a0c: 2b 8d 00 0c lw r13,(sp+12)
8006a10: 2b 8e 00 08 lw r14,(sp+8)
8006a14: 37 9c 00 14 addi sp,sp,20
8006a18: c3 a0 00 00 ret
08006a1c <_User_extensions_Thread_delete>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
8006a1c: 37 9c ff ec addi sp,sp,-20
8006a20: 5b 8b 00 14 sw (sp+20),r11
8006a24: 5b 8c 00 10 sw (sp+16),r12
8006a28: 5b 8d 00 0c sw (sp+12),r13
8006a2c: 5b 8e 00 08 sw (sp+8),r14
8006a30: 5b 9d 00 04 sw (sp+4),ra
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
8006a34: 78 0c 08 01 mvhi r12,0x801
8006a38: 39 8c 4a 24 ori r12,r12,0x4a24
8006a3c: 29 8b 00 08 lw r11,(r12+8)
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
8006a40: b8 20 70 00 mv r14,r1
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
8006a44: 45 6c 00 0a be r11,r12,8006a6c <_User_extensions_Thread_delete+0x50><== NEVER TAKEN
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
(*the_extension->Callouts.thread_delete)(
8006a48: 78 0d 08 01 mvhi r13,0x801
8006a4c: 39 ad 4d 74 ori r13,r13,0x4d74
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
8006a50: 29 63 00 20 lw r3,(r11+32)
(*the_extension->Callouts.thread_delete)(
8006a54: b9 c0 10 00 mv r2,r14
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
8006a58: 44 60 00 03 be r3,r0,8006a64 <_User_extensions_Thread_delete+0x48>
(*the_extension->Callouts.thread_delete)(
8006a5c: 29 a1 00 0c lw r1,(r13+12)
8006a60: d8 60 00 00 call r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
8006a64: 29 6b 00 04 lw r11,(r11+4)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
8006a68: 5d 6c ff fa bne r11,r12,8006a50 <_User_extensions_Thread_delete+0x34>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
8006a6c: 2b 9d 00 04 lw ra,(sp+4)
8006a70: 2b 8b 00 14 lw r11,(sp+20)
8006a74: 2b 8c 00 10 lw r12,(sp+16)
8006a78: 2b 8d 00 0c lw r13,(sp+12)
8006a7c: 2b 8e 00 08 lw r14,(sp+8)
8006a80: 37 9c 00 14 addi sp,sp,20
8006a84: c3 a0 00 00 ret
080068ac <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
80068ac: 37 9c ff f0 addi sp,sp,-16
80068b0: 5b 8b 00 10 sw (sp+16),r11
80068b4: 5b 8c 00 0c sw (sp+12),r12
80068b8: 5b 8d 00 08 sw (sp+8),r13
80068bc: 5b 9d 00 04 sw (sp+4),ra
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
80068c0: 78 0c 08 01 mvhi r12,0x801
80068c4: 39 8c 4a 24 ori r12,r12,0x4a24
80068c8: 29 8b 00 08 lw r11,(r12+8)
}
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
80068cc: b8 20 68 00 mv r13,r1
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
80068d0: 45 6c 00 07 be r11,r12,80068ec <_User_extensions_Thread_exitted+0x40><== NEVER TAKEN
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
80068d4: 29 62 00 2c lw r2,(r11+44)
(*the_extension->Callouts.thread_exitted)( executing );
80068d8: b9 a0 08 00 mv r1,r13
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
80068dc: 44 40 00 02 be r2,r0,80068e4 <_User_extensions_Thread_exitted+0x38>
(*the_extension->Callouts.thread_exitted)( executing );
80068e0: d8 40 00 00 call r2
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
80068e4: 29 6b 00 04 lw r11,(r11+4)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
80068e8: 5d 6c ff fb bne r11,r12,80068d4 <_User_extensions_Thread_exitted+0x28>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
(*the_extension->Callouts.thread_exitted)( executing );
}
}
80068ec: 2b 9d 00 04 lw ra,(sp+4)
80068f0: 2b 8b 00 10 lw r11,(sp+16)
80068f4: 2b 8c 00 0c lw r12,(sp+12)
80068f8: 2b 8d 00 08 lw r13,(sp+8)
80068fc: 37 9c 00 10 addi sp,sp,16
8006900: c3 a0 00 00 ret
08007a74 <_User_extensions_Thread_restart>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
8007a74: 37 9c ff ec addi sp,sp,-20
8007a78: 5b 8b 00 14 sw (sp+20),r11
8007a7c: 5b 8c 00 10 sw (sp+16),r12
8007a80: 5b 8d 00 0c sw (sp+12),r13
8007a84: 5b 8e 00 08 sw (sp+8),r14
8007a88: 5b 9d 00 04 sw (sp+4),ra
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
8007a8c: 78 02 08 01 mvhi r2,0x801
8007a90: 38 42 fa 7c ori r2,r2,0xfa7c
8007a94: 28 4b 00 00 lw r11,(r2+0)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
8007a98: 78 0c 08 01 mvhi r12,0x801
8007a9c: 39 8c fa 80 ori r12,r12,0xfa80
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
8007aa0: b8 20 70 00 mv r14,r1
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
8007aa4: 45 6c 00 0a be r11,r12,8007acc <_User_extensions_Thread_restart+0x58><== NEVER TAKEN
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
(*the_extension->Callouts.thread_restart)(
8007aa8: 78 0d 08 01 mvhi r13,0x801
8007aac: 39 ad fd cc ori r13,r13,0xfdcc
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
8007ab0: 29 63 00 1c lw r3,(r11+28)
(*the_extension->Callouts.thread_restart)(
8007ab4: b9 c0 10 00 mv r2,r14
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
8007ab8: 44 60 00 03 be r3,r0,8007ac4 <_User_extensions_Thread_restart+0x50>
(*the_extension->Callouts.thread_restart)(
8007abc: 29 a1 00 0c lw r1,(r13+12)
8007ac0: d8 60 00 00 call r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
8007ac4: 29 6b 00 00 lw r11,(r11+0)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
8007ac8: 5d 6c ff fa bne r11,r12,8007ab0 <_User_extensions_Thread_restart+0x3c>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
8007acc: 2b 9d 00 04 lw ra,(sp+4)
8007ad0: 2b 8b 00 14 lw r11,(sp+20)
8007ad4: 2b 8c 00 10 lw r12,(sp+16)
8007ad8: 2b 8d 00 0c lw r13,(sp+12)
8007adc: 2b 8e 00 08 lw r14,(sp+8)
8007ae0: 37 9c 00 14 addi sp,sp,20
8007ae4: c3 a0 00 00 ret
08006a88 <_User_extensions_Thread_start>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
8006a88: 37 9c ff ec addi sp,sp,-20
8006a8c: 5b 8b 00 14 sw (sp+20),r11
8006a90: 5b 8c 00 10 sw (sp+16),r12
8006a94: 5b 8d 00 0c sw (sp+12),r13
8006a98: 5b 8e 00 08 sw (sp+8),r14
8006a9c: 5b 9d 00 04 sw (sp+4),ra
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
8006aa0: 78 02 08 01 mvhi r2,0x801
8006aa4: 38 42 4a 24 ori r2,r2,0x4a24
8006aa8: 28 4b 00 00 lw r11,(r2+0)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
8006aac: 78 0c 08 01 mvhi r12,0x801
8006ab0: 39 8c 4a 28 ori r12,r12,0x4a28
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
8006ab4: b8 20 70 00 mv r14,r1
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
8006ab8: 45 6c 00 0a be r11,r12,8006ae0 <_User_extensions_Thread_start+0x58><== NEVER TAKEN
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
(*the_extension->Callouts.thread_start)(
8006abc: 78 0d 08 01 mvhi r13,0x801
8006ac0: 39 ad 4d 74 ori r13,r13,0x4d74
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
8006ac4: 29 63 00 18 lw r3,(r11+24)
(*the_extension->Callouts.thread_start)(
8006ac8: b9 c0 10 00 mv r2,r14
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
8006acc: 44 60 00 03 be r3,r0,8006ad8 <_User_extensions_Thread_start+0x50>
(*the_extension->Callouts.thread_start)(
8006ad0: 29 a1 00 0c lw r1,(r13+12)
8006ad4: d8 60 00 00 call r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
8006ad8: 29 6b 00 00 lw r11,(r11+0)
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
8006adc: 5d 6c ff fa bne r11,r12,8006ac4 <_User_extensions_Thread_start+0x3c>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
8006ae0: 2b 9d 00 04 lw ra,(sp+4)
8006ae4: 2b 8b 00 14 lw r11,(sp+20)
8006ae8: 2b 8c 00 10 lw r12,(sp+16)
8006aec: 2b 8d 00 0c lw r13,(sp+12)
8006af0: 2b 8e 00 08 lw r14,(sp+8)
8006af4: 37 9c 00 14 addi sp,sp,20
8006af8: c3 a0 00 00 ret
08006afc <_User_extensions_Thread_switch>:
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
8006afc: 37 9c ff ec addi sp,sp,-20
8006b00: 5b 8b 00 14 sw (sp+20),r11
8006b04: 5b 8c 00 10 sw (sp+16),r12
8006b08: 5b 8d 00 0c sw (sp+12),r13
8006b0c: 5b 8e 00 08 sw (sp+8),r14
8006b10: 5b 9d 00 04 sw (sp+4),ra
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
8006b14: 78 03 08 01 mvhi r3,0x801
8006b18: 38 63 48 ac ori r3,r3,0x48ac
8006b1c: 28 6b 00 00 lw r11,(r3+0)
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
8006b20: 78 0c 08 01 mvhi r12,0x801
8006b24: 39 8c 48 b0 ori r12,r12,0x48b0
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
8006b28: b8 20 70 00 mv r14,r1
8006b2c: b8 40 68 00 mv r13,r2
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
8006b30: 45 6c 00 07 be r11,r12,8006b4c <_User_extensions_Thread_switch+0x50><== NEVER TAKEN
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
8006b34: 29 63 00 08 lw r3,(r11+8)
8006b38: b9 c0 08 00 mv r1,r14
8006b3c: b9 a0 10 00 mv r2,r13
8006b40: d8 60 00 00 call r3
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
8006b44: 29 6b 00 00 lw r11,(r11+0)
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
8006b48: 5d 6c ff fb bne r11,r12,8006b34 <_User_extensions_Thread_switch+0x38>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
8006b4c: 2b 9d 00 04 lw ra,(sp+4)
8006b50: 2b 8b 00 14 lw r11,(sp+20)
8006b54: 2b 8c 00 10 lw r12,(sp+16)
8006b58: 2b 8d 00 0c lw r13,(sp+12)
8006b5c: 2b 8e 00 08 lw r14,(sp+8)
8006b60: 37 9c 00 14 addi sp,sp,20
8006b64: c3 a0 00 00 ret
08009258 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
8009258: 37 9c ff e4 addi sp,sp,-28
800925c: 5b 8b 00 1c sw (sp+28),r11
8009260: 5b 8c 00 18 sw (sp+24),r12
8009264: 5b 8d 00 14 sw (sp+20),r13
8009268: 5b 8e 00 10 sw (sp+16),r14
800926c: 5b 8f 00 0c sw (sp+12),r15
8009270: 5b 90 00 08 sw (sp+8),r16
8009274: 5b 9d 00 04 sw (sp+4),ra
8009278: b8 20 60 00 mv r12,r1
800927c: b8 60 58 00 mv r11,r3
ISR_Level level;
_ISR_Disable( level );
8009280: 90 00 18 00 rcsr r3,IE
8009284: 34 01 ff fe mvi r1,-2
8009288: a0 61 08 00 and r1,r3,r1
800928c: d0 01 00 00 wcsr IE,r1
}
}
_ISR_Enable( level );
}
8009290: 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 );
8009294: 35 8e 00 04 addi r14,r12,4
Watchdog_Interval units
)
{
ISR_Level level;
_ISR_Disable( level );
8009298: 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 ) ) {
800929c: 44 2e 00 04 be r1,r14,80092ac <_Watchdog_Adjust+0x54>
switch ( direction ) {
80092a0: 44 40 00 11 be r2,r0,80092e4 <_Watchdog_Adjust+0x8c>
80092a4: 34 03 00 01 mvi r3,1
80092a8: 44 43 00 0b be r2,r3,80092d4 <_Watchdog_Adjust+0x7c> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
80092ac: d0 04 00 00 wcsr IE,r4
}
80092b0: 2b 9d 00 04 lw ra,(sp+4)
80092b4: 2b 8b 00 1c lw r11,(sp+28)
80092b8: 2b 8c 00 18 lw r12,(sp+24)
80092bc: 2b 8d 00 14 lw r13,(sp+20)
80092c0: 2b 8e 00 10 lw r14,(sp+16)
80092c4: 2b 8f 00 0c lw r15,(sp+12)
80092c8: 2b 90 00 08 lw r16,(sp+8)
80092cc: 37 9c 00 1c addi sp,sp,28
80092d0: 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;
80092d4: 28 22 00 10 lw r2,(r1+16)
80092d8: b4 4b 58 00 add r11,r2,r11
80092dc: 58 2b 00 10 sw (r1+16),r11
break;
80092e0: e3 ff ff f3 bi 80092ac <_Watchdog_Adjust+0x54>
case WATCHDOG_FORWARD:
while ( units ) {
80092e4: b8 60 20 00 mv r4,r3
80092e8: 45 62 ff f1 be r11,r2,80092ac <_Watchdog_Adjust+0x54> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
80092ec: 28 2d 00 10 lw r13,(r1+16)
80092f0: 55 ab 00 13 bgu r13,r11,800933c <_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;
80092f4: 34 10 00 01 mvi r16,1
_ISR_Enable( level );
_Watchdog_Tickle( header );
_ISR_Disable( level );
80092f8: 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;
80092fc: 58 30 00 10 sw (r1+16),r16
_ISR_Enable( level );
8009300: d0 03 00 00 wcsr IE,r3
_Watchdog_Tickle( header );
8009304: b9 80 08 00 mv r1,r12
8009308: f8 00 00 b2 calli 80095d0 <_Watchdog_Tickle>
_ISR_Disable( level );
800930c: 90 00 10 00 rcsr r2,IE
8009310: a0 4f 08 00 and r1,r2,r15
8009314: d0 01 00 00 wcsr IE,r1
}
}
_ISR_Enable( level );
}
8009318: 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;
800931c: c9 6d 58 00 sub r11,r11,r13
_ISR_Enable( level );
_Watchdog_Tickle( header );
_ISR_Disable( level );
8009320: b8 40 18 00 mv r3,r2
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
8009324: b8 80 08 00 mv r1,r4
if ( _Chain_Is_empty( header ) )
8009328: 45 c4 00 08 be r14,r4,8009348 <_Watchdog_Adjust+0xf0>
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
800932c: 45 60 00 07 be r11,r0,8009348 <_Watchdog_Adjust+0xf0> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
8009330: 28 2d 00 10 lw r13,(r1+16)
8009334: 51 6d ff f2 bgeu r11,r13,80092fc <_Watchdog_Adjust+0xa4>
_ISR_Enable( level );
_Watchdog_Tickle( header );
_ISR_Disable( level );
8009338: 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;
800933c: c9 ab 58 00 sub r11,r13,r11
8009340: 58 2b 00 10 sw (r1+16),r11
break;
8009344: e3 ff ff da bi 80092ac <_Watchdog_Adjust+0x54>
_ISR_Enable( level );
_Watchdog_Tickle( header );
_ISR_Disable( level );
8009348: b8 40 20 00 mv r4,r2
800934c: e3 ff ff d8 bi 80092ac <_Watchdog_Adjust+0x54>
08006b68 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
8006b68: 37 9c ff f8 addi sp,sp,-8
8006b6c: 5b 8b 00 08 sw (sp+8),r11
8006b70: 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;
8006b74: 78 03 08 01 mvhi r3,0x801
8006b78: 38 63 4d 74 ori r3,r3,0x4d74
8006b7c: 28 69 00 08 lw r9,(r3+8)
_ISR_Disable( level );
8006b80: 90 00 30 00 rcsr r6,IE
8006b84: 34 08 ff fe mvi r8,-2
8006b88: a0 c8 40 00 and r8,r6,r8
8006b8c: 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 ) {
8006b90: 28 43 00 08 lw r3,(r2+8)
8006b94: 5c 60 00 3f bne r3,r0,8006c90 <_Watchdog_Insert+0x128>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
8006b98: 78 0c 08 01 mvhi r12,0x801
8006b9c: 39 8c 49 d4 ori r12,r12,0x49d4
8006ba0: 29 83 00 00 lw r3,(r12+0)
8006ba4: 78 07 08 01 mvhi r7,0x801
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
8006ba8: 34 04 00 01 mvi r4,1
_Watchdog_Sync_count++;
8006bac: 34 63 00 01 addi r3,r3,1
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
8006bb0: 58 44 00 08 sw (r2+8),r4
_Watchdog_Sync_count++;
8006bb4: 59 83 00 00 sw (r12+0),r3
8006bb8: 38 e7 49 6c ori r7,r7,0x496c
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
8006bbc: 34 0a 00 01 mvi r10,1
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
restart:
delta_interval = the_watchdog->initial;
8006bc0: 28 44 00 0c lw r4,(r2+12)
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
8006bc4: 28 23 00 00 lw r3,(r1+0)
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
8006bc8: 44 80 00 14 be r4,r0,8006c18 <_Watchdog_Insert+0xb0>
8006bcc: 28 65 00 00 lw r5,(r3+0)
8006bd0: 44 a0 00 12 be r5,r0,8006c18 <_Watchdog_Insert+0xb0>
break;
if ( delta_interval < after->delta_interval ) {
8006bd4: 28 65 00 10 lw r5,(r3+16)
8006bd8: 54 a4 00 0e bgu r5,r4,8006c10 <_Watchdog_Insert+0xa8>
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
8006bdc: d0 06 00 00 wcsr IE,r6
8006be0: d0 08 00 00 wcsr IE,r8
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
8006be4: 28 4b 00 08 lw r11,(r2+8)
8006be8: 5d 6a 00 19 bne r11,r10,8006c4c <_Watchdog_Insert+0xe4>
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
8006bec: 28 eb 00 00 lw r11,(r7+0)
8006bf0: 55 69 00 2d bgu r11,r9,8006ca4 <_Watchdog_Insert+0x13c>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
8006bf4: c8 85 20 00 sub r4,r4,r5
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
8006bf8: 28 63 00 00 lw r3,(r3+0)
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
8006bfc: 44 80 00 07 be r4,r0,8006c18 <_Watchdog_Insert+0xb0>
8006c00: 28 65 00 00 lw r5,(r3+0)
8006c04: 44 a0 00 05 be r5,r0,8006c18 <_Watchdog_Insert+0xb0>
break;
if ( delta_interval < after->delta_interval ) {
8006c08: 28 65 00 10 lw r5,(r3+16)
8006c0c: 50 85 00 19 bgeu r4,r5,8006c70 <_Watchdog_Insert+0x108>
after->delta_interval -= delta_interval;
8006c10: c8 a4 28 00 sub r5,r5,r4
8006c14: 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 );
8006c18: 28 63 00 04 lw r3,(r3+4)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
8006c1c: 78 01 08 01 mvhi r1,0x801
8006c20: 38 21 49 d8 ori r1,r1,0x49d8
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
8006c24: 28 65 00 00 lw r5,(r3+0)
8006c28: 28 28 00 00 lw r8,(r1+0)
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
8006c2c: 34 01 00 02 mvi r1,2
8006c30: 58 41 00 08 sw (r2+8),r1
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
8006c34: 58 44 00 10 sw (r2+16),r4
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
8006c38: 58 43 00 04 sw (r2+4),r3
before_node = after_node->next;
after_node->next = the_node;
8006c3c: 58 62 00 00 sw (r3+0),r2
the_node->next = before_node;
before_node->previous = the_node;
8006c40: 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;
8006c44: 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;
8006c48: 58 48 00 14 sw (r2+20),r8
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
8006c4c: 58 e9 00 00 sw (r7+0),r9
_Watchdog_Sync_count--;
8006c50: 29 81 00 00 lw r1,(r12+0)
8006c54: 34 21 ff ff addi r1,r1,-1
8006c58: 59 81 00 00 sw (r12+0),r1
_ISR_Enable( level );
8006c5c: d0 06 00 00 wcsr IE,r6
}
8006c60: 2b 8b 00 08 lw r11,(sp+8)
8006c64: 2b 8c 00 04 lw r12,(sp+4)
8006c68: 37 9c 00 08 addi sp,sp,8
8006c6c: c3 a0 00 00 ret
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
8006c70: d0 06 00 00 wcsr IE,r6
8006c74: d0 08 00 00 wcsr IE,r8
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
8006c78: 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;
8006c7c: c8 85 20 00 sub r4,r4,r5
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
8006c80: 5d 6a ff f3 bne r11,r10,8006c4c <_Watchdog_Insert+0xe4> <== NEVER TAKEN
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
8006c84: 28 e5 00 00 lw r5,(r7+0)
8006c88: 54 a9 00 07 bgu r5,r9,8006ca4 <_Watchdog_Insert+0x13c> <== NEVER TAKEN
8006c8c: e3 ff ff db bi 8006bf8 <_Watchdog_Insert+0x90>
* 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 ) {
_ISR_Enable( level );
8006c90: d0 06 00 00 wcsr IE,r6
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
8006c94: 2b 8b 00 08 lw r11,(sp+8)
8006c98: 2b 8c 00 04 lw r12,(sp+4)
8006c9c: 37 9c 00 08 addi sp,sp,8
8006ca0: c3 a0 00 00 ret
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
8006ca4: 58 e9 00 00 sw (r7+0),r9
goto restart;
8006ca8: e3 ff ff c6 bi 8006bc0 <_Watchdog_Insert+0x58>
08006d14 <_Watchdog_Remove>:
{
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
8006d14: 90 00 20 00 rcsr r4,IE
8006d18: 34 02 ff fe mvi r2,-2
8006d1c: a0 82 10 00 and r2,r4,r2
8006d20: d0 02 00 00 wcsr IE,r2
previous_state = the_watchdog->state;
8006d24: 28 22 00 08 lw r2,(r1+8)
switch ( previous_state ) {
8006d28: 34 03 00 01 mvi r3,1
8006d2c: 44 43 00 27 be r2,r3,8006dc8 <_Watchdog_Remove+0xb4>
8006d30: 5c 40 00 08 bne r2,r0,8006d50 <_Watchdog_Remove+0x3c>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
8006d34: 78 03 08 01 mvhi r3,0x801
8006d38: 38 63 49 d8 ori r3,r3,0x49d8
8006d3c: 28 63 00 00 lw r3,(r3+0)
8006d40: 58 23 00 18 sw (r1+24),r3
_ISR_Enable( level );
8006d44: d0 04 00 00 wcsr IE,r4
return( previous_state );
}
8006d48: b8 40 08 00 mv r1,r2
8006d4c: c3 a0 00 00 ret
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
8006d50: 34 03 00 03 mvi r3,3
8006d54: 54 43 ff f8 bgu r2,r3,8006d34 <_Watchdog_Remove+0x20> <== NEVER TAKEN
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
8006d58: 28 23 00 00 lw r3,(r1+0)
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
8006d5c: 58 20 00 08 sw (r1+8),r0
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
8006d60: 28 65 00 00 lw r5,(r3+0)
8006d64: 44 a0 00 05 be r5,r0,8006d78 <_Watchdog_Remove+0x64>
next_watchdog->delta_interval += the_watchdog->delta_interval;
8006d68: 28 66 00 10 lw r6,(r3+16)
8006d6c: 28 25 00 10 lw r5,(r1+16)
8006d70: b4 c5 28 00 add r5,r6,r5
8006d74: 58 65 00 10 sw (r3+16),r5
if ( _Watchdog_Sync_count )
8006d78: 78 05 08 01 mvhi r5,0x801
8006d7c: 38 a5 49 d4 ori r5,r5,0x49d4
8006d80: 28 a5 00 00 lw r5,(r5+0)
8006d84: 44 a0 00 07 be r5,r0,8006da0 <_Watchdog_Remove+0x8c>
_Watchdog_Sync_level = _ISR_Nest_level;
8006d88: 78 05 08 01 mvhi r5,0x801
8006d8c: 38 a5 4d 74 ori r5,r5,0x4d74
8006d90: 28 a6 00 08 lw r6,(r5+8)
8006d94: 78 05 08 01 mvhi r5,0x801
8006d98: 38 a5 49 6c ori r5,r5,0x496c
8006d9c: 58 a6 00 00 sw (r5+0),r6
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
8006da0: 28 25 00 04 lw r5,(r1+4)
next->previous = previous;
8006da4: 58 65 00 04 sw (r3+4),r5
previous->next = next;
8006da8: 58 a3 00 00 sw (r5+0),r3
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
8006dac: 78 03 08 01 mvhi r3,0x801
8006db0: 38 63 49 d8 ori r3,r3,0x49d8
8006db4: 28 63 00 00 lw r3,(r3+0)
8006db8: 58 23 00 18 sw (r1+24),r3
_ISR_Enable( level );
8006dbc: d0 04 00 00 wcsr IE,r4
return( previous_state );
}
8006dc0: b8 40 08 00 mv r1,r2
8006dc4: 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;
8006dc8: 78 03 08 01 mvhi r3,0x801
8006dcc: 38 63 49 d8 ori r3,r3,0x49d8
8006dd0: 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;
8006dd4: 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;
8006dd8: 58 23 00 18 sw (r1+24),r3
_ISR_Enable( level );
8006ddc: d0 04 00 00 wcsr IE,r4
return( previous_state );
}
8006de0: b8 40 08 00 mv r1,r2
8006de4: c3 a0 00 00 ret
080089c8 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
80089c8: 37 9c ff ec addi sp,sp,-20
80089cc: 5b 8b 00 14 sw (sp+20),r11
80089d0: 5b 8c 00 10 sw (sp+16),r12
80089d4: 5b 8d 00 0c sw (sp+12),r13
80089d8: 5b 8e 00 08 sw (sp+8),r14
80089dc: 5b 9d 00 04 sw (sp+4),ra
80089e0: b8 20 70 00 mv r14,r1
80089e4: b8 40 60 00 mv r12,r2
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
80089e8: 90 00 68 00 rcsr r13,IE
80089ec: 34 01 ff fe mvi r1,-2
80089f0: a1 a1 08 00 and r1,r13,r1
80089f4: d0 01 00 00 wcsr IE,r1
printk( "Watchdog Chain: %s %p\n", name, header );
80089f8: 78 01 08 01 mvhi r1,0x801
80089fc: b9 80 18 00 mv r3,r12
8008a00: 38 21 f0 d0 ori r1,r1,0xf0d0
8008a04: b9 c0 10 00 mv r2,r14
8008a08: fb ff ea d7 calli 8003564 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
8008a0c: 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 );
8008a10: 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 ) ) {
8008a14: 45 6c 00 12 be r11,r12,8008a5c <_Watchdog_Report_chain+0x94>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
8008a18: b9 60 10 00 mv r2,r11
8008a1c: 34 01 00 00 mvi r1,0
8008a20: f8 00 00 13 calli 8008a6c <_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 )
8008a24: 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 ) ;
8008a28: 5d 6c ff fc bne r11,r12,8008a18 <_Watchdog_Report_chain+0x50><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
8008a2c: 78 01 08 01 mvhi r1,0x801
8008a30: 38 21 f0 e8 ori r1,r1,0xf0e8
8008a34: b9 c0 10 00 mv r2,r14
8008a38: fb ff ea cb calli 8003564 <printk>
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
8008a3c: d0 0d 00 00 wcsr IE,r13
}
8008a40: 2b 9d 00 04 lw ra,(sp+4)
8008a44: 2b 8b 00 14 lw r11,(sp+20)
8008a48: 2b 8c 00 10 lw r12,(sp+16)
8008a4c: 2b 8d 00 0c lw r13,(sp+12)
8008a50: 2b 8e 00 08 lw r14,(sp+8)
8008a54: 37 9c 00 14 addi sp,sp,20
8008a58: c3 a0 00 00 ret
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
8008a5c: 78 01 08 01 mvhi r1,0x801
8008a60: 38 21 f0 f8 ori r1,r1,0xf0f8
8008a64: fb ff ea c0 calli 8003564 <printk>
8008a68: e3 ff ff f5 bi 8008a3c <_Watchdog_Report_chain+0x74>
08006de8 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
8006de8: 37 9c ff e4 addi sp,sp,-28
8006dec: 5b 8b 00 1c sw (sp+28),r11
8006df0: 5b 8c 00 18 sw (sp+24),r12
8006df4: 5b 8d 00 14 sw (sp+20),r13
8006df8: 5b 8e 00 10 sw (sp+16),r14
8006dfc: 5b 8f 00 0c sw (sp+12),r15
8006e00: 5b 90 00 08 sw (sp+8),r16
8006e04: 5b 9d 00 04 sw (sp+4),ra
8006e08: 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 );
8006e0c: 90 00 68 00 rcsr r13,IE
8006e10: 34 01 ff fe mvi r1,-2
8006e14: a1 a1 08 00 and r1,r13,r1
8006e18: d0 01 00 00 wcsr IE,r1
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
8006e1c: 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 );
8006e20: 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 );
8006e24: b9 a0 10 00 mv r2,r13
if ( _Chain_Is_empty( header ) )
8006e28: 45 6e 00 1e be r11,r14,8006ea0 <_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) {
8006e2c: 29 61 00 10 lw r1,(r11+16)
8006e30: 5c 20 00 26 bne r1,r0,8006ec8 <_Watchdog_Tickle+0xe0>
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
_ISR_Enable( level );
switch( watchdog_state ) {
8006e34: 34 10 00 02 mvi r16,2
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
8006e38: 34 0f ff fe mvi r15,-2
8006e3c: e0 00 00 0a bi 8006e64 <_Watchdog_Tickle+0x7c>
8006e40: 90 00 10 00 rcsr r2,IE <== NOT EXECUTED
8006e44: a0 4f 08 00 and r1,r2,r15 <== NOT EXECUTED
8006e48: d0 01 00 00 wcsr IE,r1 <== NOT EXECUTED
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
8006e4c: 29 81 00 00 lw r1,(r12+0) <== NOT EXECUTED
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
8006e50: 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 ) );
8006e54: b8 20 58 00 mv r11,r1 <== NOT EXECUTED
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
8006e58: 44 2e 00 12 be r1,r14,8006ea0 <_Watchdog_Tickle+0xb8> <== NOT EXECUTED
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
8006e5c: 28 21 00 10 lw r1,(r1+16)
8006e60: 5c 20 00 10 bne r1,r0,8006ea0 <_Watchdog_Tickle+0xb8>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
8006e64: b9 60 08 00 mv r1,r11
8006e68: fb ff ff ab calli 8006d14 <_Watchdog_Remove>
_ISR_Enable( level );
8006e6c: d0 0d 00 00 wcsr IE,r13
switch( watchdog_state ) {
8006e70: 5c 30 ff f4 bne r1,r16,8006e40 <_Watchdog_Tickle+0x58> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
8006e74: 29 63 00 1c lw r3,(r11+28)
8006e78: 29 61 00 20 lw r1,(r11+32)
8006e7c: 29 62 00 24 lw r2,(r11+36)
8006e80: d8 60 00 00 call r3
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
8006e84: 90 00 10 00 rcsr r2,IE
8006e88: a0 4f 08 00 and r1,r2,r15
8006e8c: d0 01 00 00 wcsr IE,r1
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
8006e90: 29 81 00 00 lw r1,(r12+0)
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
8006e94: b8 40 68 00 mv r13,r2
8006e98: b8 20 58 00 mv r11,r1
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
8006e9c: 5c 2e ff f0 bne r1,r14,8006e5c <_Watchdog_Tickle+0x74>
leave:
_ISR_Enable(level);
8006ea0: d0 02 00 00 wcsr IE,r2
}
8006ea4: 2b 9d 00 04 lw ra,(sp+4)
8006ea8: 2b 8b 00 1c lw r11,(sp+28)
8006eac: 2b 8c 00 18 lw r12,(sp+24)
8006eb0: 2b 8d 00 14 lw r13,(sp+20)
8006eb4: 2b 8e 00 10 lw r14,(sp+16)
8006eb8: 2b 8f 00 0c lw r15,(sp+12)
8006ebc: 2b 90 00 08 lw r16,(sp+8)
8006ec0: 37 9c 00 1c addi sp,sp,28
8006ec4: 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--;
8006ec8: 34 21 ff ff addi r1,r1,-1
8006ecc: 59 61 00 10 sw (r11+16),r1
if ( the_watchdog->delta_interval != 0 )
8006ed0: 44 20 ff d9 be r1,r0,8006e34 <_Watchdog_Tickle+0x4c>
8006ed4: e3 ff ff f3 bi 8006ea0 <_Watchdog_Tickle+0xb8>
080032dc <adjtime>:
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
80032dc: 37 9c ff e8 addi sp,sp,-24
80032e0: 5b 8b 00 10 sw (sp+16),r11
80032e4: 5b 8c 00 0c sw (sp+12),r12
80032e8: 5b 8d 00 08 sw (sp+8),r13
80032ec: 5b 9d 00 04 sw (sp+4),ra
80032f0: b8 20 58 00 mv r11,r1
80032f4: b8 40 60 00 mv r12,r2
long adjustment;
/*
* Simple validations
*/
if ( !delta )
80032f8: 44 20 00 06 be r1,r0,8003310 <adjtime+0x34>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
80032fc: 78 03 08 01 mvhi r3,0x801
8003300: 38 63 e1 04 ori r3,r3,0xe104
8003304: 28 22 00 04 lw r2,(r1+4)
8003308: 28 61 00 00 lw r1,(r3+0)
800330c: 50 22 00 0b bgeu r1,r2,8003338 <adjtime+0x5c>
rtems_set_errno_and_return_minus_one( EINVAL );
8003310: f8 00 2a cd calli 800de44 <__errno>
8003314: 34 02 00 16 mvi r2,22
8003318: 58 22 00 00 sw (r1+0),r2
800331c: 34 01 ff ff mvi r1,-1
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
8003320: 2b 9d 00 04 lw ra,(sp+4)
8003324: 2b 8b 00 10 lw r11,(sp+16)
8003328: 2b 8c 00 0c lw r12,(sp+12)
800332c: 2b 8d 00 08 lw r13,(sp+8)
8003330: 37 9c 00 18 addi sp,sp,24
8003334: 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 ) {
8003338: 45 80 00 04 be r12,r0,8003348 <adjtime+0x6c>
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
800333c: 59 80 00 04 sw (r12+4),r0
8003340: 29 62 00 04 lw r2,(r11+4)
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
olddelta->tv_sec = 0;
8003344: 59 80 00 00 sw (r12+0),r0
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
8003348: 29 63 00 00 lw r3,(r11+0)
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
800334c: 78 01 08 02 mvhi r1,0x802
8003350: 38 21 00 c4 ori r1,r1,0xc4
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
8003354: b4 63 20 00 add r4,r3,r3
8003358: b4 84 20 00 add r4,r4,r4
800335c: b4 84 20 00 add r4,r4,r4
8003360: b4 84 28 00 add r5,r4,r4
8003364: b4 a5 28 00 add r5,r5,r5
8003368: b4 a5 28 00 add r5,r5,r5
800336c: b4 a5 28 00 add r5,r5,r5
8003370: b4 a5 28 00 add r5,r5,r5
8003374: c8 a4 28 00 sub r5,r5,r4
8003378: b4 a5 20 00 add r4,r5,r5
800337c: b4 84 20 00 add r4,r4,r4
8003380: b4 84 20 00 add r4,r4,r4
8003384: b4 84 20 00 add r4,r4,r4
8003388: b4 84 20 00 add r4,r4,r4
800338c: b4 84 20 00 add r4,r4,r4
8003390: c8 85 20 00 sub r4,r4,r5
8003394: b4 83 18 00 add r3,r4,r3
8003398: b4 63 18 00 add r3,r3,r3
800339c: b4 63 18 00 add r3,r3,r3
80033a0: b4 63 18 00 add r3,r3,r3
80033a4: b4 63 18 00 add r3,r3,r3
80033a8: 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() )
80033ac: 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);
80033b0: b4 63 18 00 add r3,r3,r3
adjustment += delta->tv_usec;
80033b4: b4 43 18 00 add r3,r2,r3
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
return 0;
80033b8: 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() )
80033bc: 54 83 ff d9 bgu r4,r3,8003320 <adjtime+0x44>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
80033c0: 78 01 08 02 mvhi r1,0x802
80033c4: 38 21 09 a0 ori r1,r1,0x9a0
80033c8: 28 22 00 00 lw r2,(r1+0)
80033cc: 34 42 00 01 addi r2,r2,1
80033d0: 58 22 00 00 sw (r1+0),r2
* This prevents context switches while we are adjusting the TOD
*/
_Thread_Disable_dispatch();
_TOD_Get( &ts );
80033d4: 37 8d 00 14 addi r13,sp,20
80033d8: b9 a0 08 00 mv r1,r13
80033dc: f8 00 05 84 calli 80049ec <_TOD_Get>
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
80033e0: 29 63 00 04 lw r3,(r11+4)
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
80033e4: 78 04 08 01 mvhi r4,0x801
80033e8: 38 84 e2 80 ori r4,r4,0xe280
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
80033ec: b4 63 18 00 add r3,r3,r3
80033f0: b4 63 18 00 add r3,r3,r3
80033f4: b4 63 18 00 add r3,r3,r3
80033f8: b4 63 10 00 add r2,r3,r3
80033fc: b4 42 10 00 add r2,r2,r2
8003400: b4 62 18 00 add r3,r3,r2
8003404: b4 63 10 00 add r2,r3,r3
8003408: b4 42 10 00 add r2,r2,r2
800340c: b4 62 18 00 add r3,r3,r2
8003410: b4 63 10 00 add r2,r3,r3
8003414: b4 42 10 00 add r2,r2,r2
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
8003418: 29 61 00 00 lw r1,(r11+0)
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
800341c: b4 62 18 00 add r3,r3,r2
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
8003420: 28 82 00 00 lw r2,(r4+0)
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
8003424: 2b 84 00 14 lw r4,(sp+20)
8003428: b4 81 20 00 add r4,r4,r1
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
800342c: 2b 81 00 18 lw r1,(sp+24)
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
8003430: 5b 84 00 14 sw (sp+20),r4
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
8003434: b4 61 18 00 add r3,r3,r1
8003438: 5b 83 00 18 sw (sp+24),r3
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
800343c: 50 43 00 09 bgeu r2,r3,8003460 <adjtime+0x184>
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
8003440: 78 01 08 01 mvhi r1,0x801
8003444: 38 21 e2 84 ori r1,r1,0xe284
8003448: 28 25 00 00 lw r5,(r1+0)
800344c: b4 65 18 00 add r3,r3,r5
* At one point there was a static variable named adjustment
* used by this implementation. I don't see any reason for it
* to be here based upon the GNU/Linux documentation.
*/
int adjtime(
8003450: 34 84 00 01 addi r4,r4,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 ) {
8003454: 54 62 ff fe bgu r3,r2,800344c <adjtime+0x170> <== NEVER TAKEN
8003458: 5b 83 00 18 sw (sp+24),r3
800345c: 5b 84 00 14 sw (sp+20),r4
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) ) {
8003460: 78 04 08 01 mvhi r4,0x801
8003464: 38 84 e2 84 ori r4,r4,0xe284
8003468: 28 82 00 00 lw r2,(r4+0)
800346c: 54 62 00 0a bgu r3,r2,8003494 <adjtime+0x1b8> <== NEVER TAKEN
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
8003470: 78 01 08 01 mvhi r1,0x801
8003474: 38 21 e1 00 ori r1,r1,0xe100
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) ) {
8003478: 2b 84 00 14 lw r4,(sp+20)
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
800347c: 28 25 00 00 lw r5,(r1+0)
8003480: b4 65 18 00 add r3,r3,r5
* At one point there was a static variable named adjustment
* used by this implementation. I don't see any reason for it
* to be here based upon the GNU/Linux documentation.
*/
int adjtime(
8003484: 34 84 ff ff addi r4,r4,-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) ) {
8003488: 50 43 ff fe bgeu r2,r3,8003480 <adjtime+0x1a4>
800348c: 5b 83 00 18 sw (sp+24),r3
8003490: 5b 84 00 14 sw (sp+20),r4
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
}
_TOD_Set( &ts );
8003494: b9 a0 08 00 mv r1,r13
8003498: f8 00 05 87 calli 8004ab4 <_TOD_Set>
_Thread_Enable_dispatch();
800349c: f8 00 0b d3 calli 80063e8 <_Thread_Enable_dispatch>
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
80034a0: 34 01 00 00 mvi r1,0
_TOD_Set( &ts );
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
80034a4: 45 80 ff 9f be r12,r0,8003320 <adjtime+0x44>
*olddelta = *delta;
80034a8: 29 62 00 00 lw r2,(r11+0)
80034ac: 59 82 00 00 sw (r12+0),r2
80034b0: 29 62 00 04 lw r2,(r11+4)
80034b4: 59 82 00 04 sw (r12+4),r2
return 0;
}
80034b8: 2b 9d 00 04 lw ra,(sp+4)
80034bc: 2b 8b 00 10 lw r11,(sp+16)
80034c0: 2b 8c 00 0c lw r12,(sp+12)
80034c4: 2b 8d 00 08 lw r13,(sp+8)
80034c8: 37 9c 00 18 addi sp,sp,24
80034cc: c3 a0 00 00 ret
08003d40 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
8003d40: 37 9c ff ec addi sp,sp,-20
8003d44: 5b 8b 00 14 sw (sp+20),r11
8003d48: 5b 8c 00 10 sw (sp+16),r12
8003d4c: 5b 8d 00 0c sw (sp+12),r13
8003d50: 5b 8e 00 08 sw (sp+8),r14
8003d54: 5b 9d 00 04 sw (sp+4),ra
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
8003d58: 78 0b 08 01 mvhi r11,0x801
8003d5c: 39 6b 88 08 ori r11,r11,0x8808
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
8003d60: b8 20 60 00 mv r12,r1
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
8003d64: b9 60 08 00 mv r1,r11
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
8003d68: b8 40 68 00 mv r13,r2
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
8003d6c: f8 00 05 07 calli 8005188 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
8003d70: b9 80 08 00 mv r1,r12
8003d74: 34 02 00 01 mvi r2,1
8003d78: f8 00 1e dc calli 800b8e8 <fcntl>
8003d7c: 4c 20 00 08 bge r1,r0,8003d9c <aio_cancel+0x5c>
pthread_mutex_unlock(&aio_request_queue.mutex);
8003d80: b9 60 08 00 mv r1,r11
8003d84: f8 00 05 31 calli 8005248 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
8003d88: f8 00 30 6f calli 800ff44 <__errno>
8003d8c: 34 02 00 09 mvi r2,9
8003d90: 58 22 00 00 sw (r1+0),r2
8003d94: 34 0c ff ff mvi r12,-1
8003d98: e0 00 00 0b bi 8003dc4 <aio_cancel+0x84>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
8003d9c: 45 a0 00 2a be r13,r0,8003e44 <aio_cancel+0x104>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
8003da0: 29 ae 00 00 lw r14,(r13+0)
8003da4: 5d cc 00 58 bne r14,r12,8003f04 <aio_cancel+0x1c4>
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);
8003da8: 78 01 08 01 mvhi r1,0x801
8003dac: 38 21 88 50 ori r1,r1,0x8850
8003db0: b9 c0 10 00 mv r2,r14
8003db4: 34 03 00 00 mvi r3,0
8003db8: f8 00 00 d8 calli 8004118 <rtems_aio_search_fd>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
}
return AIO_ALLDONE;
8003dbc: 34 0c 00 02 mvi r12,2
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);
if (r_chain == NULL) {
8003dc0: 44 20 00 09 be r1,r0,8003de4 <aio_cancel+0xa4>
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
}
return AIO_ALLDONE;
}
8003dc4: b9 80 08 00 mv r1,r12
8003dc8: 2b 9d 00 04 lw ra,(sp+4)
8003dcc: 2b 8b 00 14 lw r11,(sp+20)
8003dd0: 2b 8c 00 10 lw r12,(sp+16)
8003dd4: 2b 8d 00 0c lw r13,(sp+12)
8003dd8: 2b 8e 00 08 lw r14,(sp+8)
8003ddc: 37 9c 00 14 addi sp,sp,20
8003de0: 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)) {
8003de4: 29 62 00 54 lw r2,(r11+84)
8003de8: 78 01 08 01 mvhi r1,0x801
8003dec: 38 21 88 60 ori r1,r1,0x8860
8003df0: 44 41 00 29 be r2,r1,8003e94 <aio_cancel+0x154> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
8003df4: 78 01 08 01 mvhi r1,0x801
8003df8: 38 21 88 5c ori r1,r1,0x885c
8003dfc: b9 c0 10 00 mv r2,r14
8003e00: 34 03 00 00 mvi r3,0
8003e04: f8 00 00 c5 calli 8004118 <rtems_aio_search_fd>
if (r_chain == NULL) {
8003e08: 44 20 00 3f be r1,r0,8003f04 <aio_cancel+0x1c4>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
8003e0c: b9 a0 10 00 mv r2,r13
8003e10: 34 21 00 08 addi r1,r1,8
8003e14: f8 00 01 e8 calli 80045b4 <rtems_aio_remove_req>
8003e18: b8 20 60 00 mv r12,r1
pthread_mutex_unlock (&aio_request_queue.mutex);
8003e1c: b9 60 08 00 mv r1,r11
8003e20: f8 00 05 0a calli 8005248 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
}
return AIO_ALLDONE;
}
8003e24: b9 80 08 00 mv r1,r12
8003e28: 2b 9d 00 04 lw ra,(sp+4)
8003e2c: 2b 8b 00 14 lw r11,(sp+20)
8003e30: 2b 8c 00 10 lw r12,(sp+16)
8003e34: 2b 8d 00 0c lw r13,(sp+12)
8003e38: 2b 8e 00 08 lw r14,(sp+8)
8003e3c: 37 9c 00 14 addi sp,sp,20
8003e40: c3 a0 00 00 ret
/* 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);
8003e44: 78 01 08 01 mvhi r1,0x801
8003e48: 38 21 88 50 ori r1,r1,0x8850
8003e4c: b9 80 10 00 mv r2,r12
8003e50: 34 03 00 00 mvi r3,0
8003e54: f8 00 00 b1 calli 8004118 <rtems_aio_search_fd>
8003e58: b8 20 70 00 mv r14,r1
if (r_chain == NULL) {
8003e5c: 44 2d 00 11 be r1,r13,8003ea0 <aio_cancel+0x160>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
8003e60: 34 2c 00 1c addi r12,r1,28
8003e64: b9 80 08 00 mv r1,r12
8003e68: f8 00 04 c8 calli 8005188 <pthread_mutex_lock>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
8003e6c: b9 c0 08 00 mv r1,r14
8003e70: f8 00 0b 0c calli 8006aa0 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
8003e74: b9 c0 08 00 mv r1,r14
8003e78: f8 00 01 b0 calli 8004538 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
8003e7c: b9 80 08 00 mv r1,r12
8003e80: f8 00 04 f2 calli 8005248 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
8003e84: b9 60 08 00 mv r1,r11
8003e88: f8 00 04 f0 calli 8005248 <pthread_mutex_unlock>
return AIO_CANCELED;
8003e8c: 34 0c 00 00 mvi r12,0
8003e90: e3 ff ff cd bi 8003dc4 <aio_cancel+0x84>
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);
8003e94: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8003e98: f8 00 04 ec calli 8005248 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
8003e9c: e3 ff ff ca bi 8003dc4 <aio_cancel+0x84> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
8003ea0: 29 62 00 54 lw r2,(r11+84)
8003ea4: 78 01 08 01 mvhi r1,0x801
8003ea8: 38 21 88 60 ori r1,r1,0x8860
8003eac: 44 41 00 1d be r2,r1,8003f20 <aio_cancel+0x1e0> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
8003eb0: 78 01 08 01 mvhi r1,0x801
8003eb4: b9 80 10 00 mv r2,r12
8003eb8: 38 21 88 5c ori r1,r1,0x885c
8003ebc: 34 03 00 00 mvi r3,0
8003ec0: f8 00 00 96 calli 8004118 <rtems_aio_search_fd>
8003ec4: b8 20 60 00 mv r12,r1
if (r_chain == NULL) {
8003ec8: 44 2e 00 16 be r1,r14,8003f20 <aio_cancel+0x1e0>
8003ecc: f8 00 0a f5 calli 8006aa0 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
8003ed0: b9 80 08 00 mv r1,r12
pthread_mutex_destroy (&r_chain->mutex);
8003ed4: 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);
8003ed8: f8 00 01 98 calli 8004538 <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
8003edc: b9 a0 08 00 mv r1,r13
8003ee0: f8 00 03 e2 calli 8004e68 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
8003ee4: b9 a0 08 00 mv r1,r13
8003ee8: f8 00 02 cf calli 8004a24 <pthread_cond_destroy>
free (r_chain);
8003eec: b9 80 08 00 mv r1,r12
8003ef0: fb ff f9 0e calli 8002328 <free>
pthread_mutex_unlock (&aio_request_queue.mutex);
8003ef4: b9 60 08 00 mv r1,r11
8003ef8: f8 00 04 d4 calli 8005248 <pthread_mutex_unlock>
return AIO_CANCELED;
8003efc: 34 0c 00 00 mvi r12,0
8003f00: e3 ff ff b1 bi 8003dc4 <aio_cancel+0x84>
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);
8003f04: b9 60 08 00 mv r1,r11
8003f08: f8 00 04 d0 calli 8005248 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
8003f0c: f8 00 30 0e calli 800ff44 <__errno>
8003f10: 34 02 00 16 mvi r2,22
8003f14: 58 22 00 00 sw (r1+0),r2
8003f18: 34 0c ff ff mvi r12,-1
8003f1c: e3 ff ff aa bi 8003dc4 <aio_cancel+0x84>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
}
pthread_mutex_unlock (&aio_request_queue.mutex);
8003f20: b9 60 08 00 mv r1,r11
8003f24: f8 00 04 c9 calli 8005248 <pthread_mutex_unlock>
return AIO_ALLDONE;
8003f28: 34 0c 00 02 mvi r12,2
8003f2c: e3 ff ff a6 bi 8003dc4 <aio_cancel+0x84>
08003f38 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
8003f38: 37 9c ff f4 addi sp,sp,-12
8003f3c: 5b 8b 00 0c sw (sp+12),r11
8003f40: 5b 8c 00 08 sw (sp+8),r12
8003f44: 5b 9d 00 04 sw (sp+4),ra
8003f48: b8 40 58 00 mv r11,r2
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
8003f4c: 34 02 20 00 mvi r2,8192
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
8003f50: 34 0c 00 16 mvi r12,22
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
8003f54: 5c 22 00 09 bne r1,r2,8003f78 <aio_fsync+0x40>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
8003f58: 29 61 00 00 lw r1,(r11+0)
8003f5c: 34 02 00 03 mvi r2,3
8003f60: f8 00 1e 62 calli 800b8e8 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
8003f64: 20 21 00 03 andi r1,r1,0x3
8003f68: 34 21 ff ff addi r1,r1,-1
8003f6c: 34 02 00 01 mvi r2,1
8003f70: 50 41 00 0d bgeu r2,r1,8003fa4 <aio_fsync+0x6c>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
8003f74: 34 0c 00 09 mvi r12,9
8003f78: 34 01 ff ff mvi r1,-1
8003f7c: 59 6c 00 2c sw (r11+44),r12
8003f80: 59 61 00 30 sw (r11+48),r1
8003f84: f8 00 2f f0 calli 800ff44 <__errno>
8003f88: 58 2c 00 00 sw (r1+0),r12
8003f8c: 34 01 ff ff mvi r1,-1
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
8003f90: 2b 9d 00 04 lw ra,(sp+4)
8003f94: 2b 8b 00 0c lw r11,(sp+12)
8003f98: 2b 8c 00 08 lw r12,(sp+8)
8003f9c: 37 9c 00 0c addi sp,sp,12
8003fa0: 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));
8003fa4: 34 01 00 18 mvi r1,24
8003fa8: fb ff fa b9 calli 8002a8c <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
8003fac: 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)
8003fb0: 44 20 ff f2 be r1,r0,8003f78 <aio_fsync+0x40> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
8003fb4: 34 03 00 03 mvi r3,3
8003fb8: 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;
8003fbc: 58 2b 00 14 sw (r1+20),r11
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
8003fc0: f8 00 01 a0 calli 8004640 <rtems_aio_enqueue>
}
8003fc4: 2b 9d 00 04 lw ra,(sp+4)
8003fc8: 2b 8b 00 0c lw r11,(sp+12)
8003fcc: 2b 8c 00 08 lw r12,(sp+8)
8003fd0: 37 9c 00 0c addi sp,sp,12
8003fd4: c3 a0 00 00 ret
08004854 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
8004854: 37 9c ff f4 addi sp,sp,-12
8004858: 5b 8b 00 0c sw (sp+12),r11
800485c: 5b 8c 00 08 sw (sp+8),r12
8004860: 5b 9d 00 04 sw (sp+4),ra
8004864: b8 20 58 00 mv r11,r1
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
8004868: 28 21 00 00 lw r1,(r1+0)
800486c: 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);
8004870: 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);
8004874: f8 00 1c 1d calli 800b8e8 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
8004878: 20 21 00 03 andi r1,r1,0x3
800487c: 7c 22 00 02 cmpnei r2,r1,2
8004880: 7c 21 00 00 cmpnei r1,r1,0
8004884: a0 41 08 00 and r1,r2,r1
8004888: 5c 20 00 06 bne r1,r0,80048a0 <aio_read+0x4c>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
800488c: 29 6c 00 10 lw r12,(r11+16)
8004890: 5d 81 00 03 bne r12,r1,800489c <aio_read+0x48>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
8004894: 29 61 00 04 lw r1,(r11+4)
8004898: 4c 2c 00 09 bge r1,r12,80048bc <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);
800489c: 34 0c 00 16 mvi r12,22
80048a0: 34 01 ff ff mvi r1,-1
80048a4: 59 6c 00 2c sw (r11+44),r12
80048a8: 59 61 00 30 sw (r11+48),r1
80048ac: f8 00 2d a6 calli 800ff44 <__errno>
80048b0: 58 2c 00 00 sw (r1+0),r12
80048b4: 34 01 ff ff mvi r1,-1
80048b8: e0 00 00 08 bi 80048d8 <aio_read+0x84>
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
80048bc: 34 01 00 18 mvi r1,24
80048c0: fb ff f8 73 calli 8002a8c <malloc>
if (req == NULL)
80048c4: 44 2c 00 0a be r1,r12,80048ec <aio_read+0x98> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
80048c8: 34 03 00 01 mvi r3,1
80048cc: 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;
80048d0: 58 2b 00 14 sw (r1+20),r11
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
80048d4: fb ff ff 5b calli 8004640 <rtems_aio_enqueue>
}
80048d8: 2b 9d 00 04 lw ra,(sp+4)
80048dc: 2b 8b 00 0c lw r11,(sp+12)
80048e0: 2b 8c 00 08 lw r12,(sp+8)
80048e4: 37 9c 00 0c addi sp,sp,12
80048e8: 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);
80048ec: 34 0c 00 0b mvi r12,11 <== NOT EXECUTED
80048f0: e3 ff ff ec bi 80048a0 <aio_read+0x4c> <== NOT EXECUTED
080048fc <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
80048fc: 37 9c ff f4 addi sp,sp,-12
8004900: 5b 8b 00 0c sw (sp+12),r11
8004904: 5b 8c 00 08 sw (sp+8),r12
8004908: 5b 9d 00 04 sw (sp+4),ra
800490c: b8 20 58 00 mv r11,r1
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
8004910: 28 21 00 00 lw r1,(r1+0)
8004914: 34 02 00 03 mvi r2,3
8004918: f8 00 1b f4 calli 800b8e8 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
800491c: 20 21 00 03 andi r1,r1,0x3
8004920: 34 21 ff ff addi r1,r1,-1
8004924: 34 02 00 01 mvi r2,1
8004928: 50 41 00 09 bgeu r2,r1,800494c <aio_write+0x50>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
800492c: 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);
8004930: 34 01 ff ff mvi r1,-1
8004934: 59 6c 00 2c sw (r11+44),r12
8004938: 59 61 00 30 sw (r11+48),r1
800493c: f8 00 2d 82 calli 800ff44 <__errno>
8004940: 58 2c 00 00 sw (r1+0),r12
8004944: 34 01 ff ff mvi r1,-1
8004948: e0 00 00 0f bi 8004984 <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)
800494c: 29 61 00 10 lw r1,(r11+16)
8004950: 5c 20 00 03 bne r1,r0,800495c <aio_write+0x60>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
8004954: 29 62 00 04 lw r2,(r11+4)
8004958: 4c 41 00 03 bge r2,r1,8004964 <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);
800495c: 34 0c 00 16 mvi r12,22
8004960: e3 ff ff f4 bi 8004930 <aio_write+0x34>
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
8004964: 34 01 00 18 mvi r1,24
8004968: fb ff f8 49 calli 8002a8c <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
800496c: 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)
8004970: 44 20 ff f0 be r1,r0,8004930 <aio_write+0x34> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
8004974: 34 03 00 02 mvi r3,2
8004978: 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;
800497c: 58 2b 00 14 sw (r1+20),r11
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
8004980: fb ff ff 30 calli 8004640 <rtems_aio_enqueue>
}
8004984: 2b 9d 00 04 lw ra,(sp+4)
8004988: 2b 8b 00 0c lw r11,(sp+12)
800498c: 2b 8c 00 08 lw r12,(sp+8)
8004990: 37 9c 00 0c addi sp,sp,12
8004994: c3 a0 00 00 ret
080030e8 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
80030e8: 37 9c ff fc addi sp,sp,-4
80030ec: 5b 9d 00 04 sw (sp+4),ra
if ( !tp )
80030f0: 44 40 00 09 be r2,r0,8003114 <clock_gettime+0x2c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
80030f4: 34 03 00 01 mvi r3,1
80030f8: 44 23 00 1b be r1,r3,8003164 <clock_gettime+0x7c>
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
80030fc: 34 03 00 04 mvi r3,4
8003100: 44 23 00 13 be r1,r3,800314c <clock_gettime+0x64> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
8003104: 34 03 00 02 mvi r3,2
8003108: 44 23 00 11 be r1,r3,800314c <clock_gettime+0x64>
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
800310c: 34 02 00 03 mvi r2,3
8003110: 44 22 00 08 be r1,r2,8003130 <clock_gettime+0x48>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
8003114: f8 00 2c 50 calli 800e254 <__errno>
8003118: 34 02 00 16 mvi r2,22
800311c: 58 22 00 00 sw (r1+0),r2
8003120: 34 01 ff ff mvi r1,-1
return 0;
}
8003124: 2b 9d 00 04 lw ra,(sp+4)
8003128: 37 9c 00 04 addi sp,sp,4
800312c: c3 a0 00 00 ret
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
8003130: f8 00 2c 49 calli 800e254 <__errno>
8003134: 34 02 00 58 mvi r2,88
8003138: 58 22 00 00 sw (r1+0),r2
800313c: 34 01 ff ff mvi r1,-1
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
8003140: 2b 9d 00 04 lw ra,(sp+4)
8003144: 37 9c 00 04 addi sp,sp,4
8003148: c3 a0 00 00 ret
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
_TOD_Get_uptime_as_timespec( tp );
800314c: b8 40 08 00 mv r1,r2
8003150: f8 00 07 62 calli 8004ed8 <_TOD_Get_uptime_as_timespec>
return 0;
8003154: 34 01 00 00 mvi r1,0
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
8003158: 2b 9d 00 04 lw ra,(sp+4)
800315c: 37 9c 00 04 addi sp,sp,4
8003160: c3 a0 00 00 ret
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
8003164: b8 40 08 00 mv r1,r2
8003168: f8 00 07 39 calli 8004e4c <_TOD_Get>
return 0;
800316c: 34 01 00 00 mvi r1,0
8003170: e3 ff ff ed bi 8003124 <clock_gettime+0x3c>
08003174 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
8003174: 37 9c ff fc addi sp,sp,-4
8003178: 5b 9d 00 04 sw (sp+4),ra
if ( !tp )
800317c: 44 40 00 07 be r2,r0,8003198 <clock_settime+0x24> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
8003180: 34 03 00 01 mvi r3,1
8003184: 44 23 00 0c be r1,r3,80031b4 <clock_settime+0x40>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
8003188: 34 02 00 02 mvi r2,2
800318c: 44 22 00 1c be r1,r2,80031fc <clock_settime+0x88>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
8003190: 34 02 00 03 mvi r2,3
8003194: 44 22 00 1a be r1,r2,80031fc <clock_settime+0x88>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
8003198: f8 00 2c 2f calli 800e254 <__errno>
800319c: 34 02 00 16 mvi r2,22
80031a0: 58 22 00 00 sw (r1+0),r2
80031a4: 34 01 ff ff mvi r1,-1
return 0;
}
80031a8: 2b 9d 00 04 lw ra,(sp+4)
80031ac: 37 9c 00 04 addi sp,sp,4
80031b0: 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 )
80031b4: 78 04 08 01 mvhi r4,0x801
80031b8: 38 84 ed 3c ori r4,r4,0xed3c
80031bc: 28 43 00 00 lw r3,(r2+0)
80031c0: 28 81 00 00 lw r1,(r4+0)
80031c4: 54 61 00 02 bgu r3,r1,80031cc <clock_settime+0x58>
80031c8: e3 ff ff f4 bi 8003198 <clock_settime+0x24>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
80031cc: 78 01 08 02 mvhi r1,0x802
80031d0: 38 21 08 b8 ori r1,r1,0x8b8
80031d4: 28 23 00 00 lw r3,(r1+0)
80031d8: 34 63 00 01 addi r3,r3,1
80031dc: 58 23 00 00 sw (r1+0),r3
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
80031e0: b8 40 08 00 mv r1,r2
80031e4: f8 00 07 5a calli 8004f4c <_TOD_Set>
_Thread_Enable_dispatch();
80031e8: f8 00 0d a6 calli 8006880 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
80031ec: 34 01 00 00 mvi r1,0
}
80031f0: 2b 9d 00 04 lw ra,(sp+4)
80031f4: 37 9c 00 04 addi sp,sp,4
80031f8: c3 a0 00 00 ret
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
80031fc: f8 00 2c 16 calli 800e254 <__errno>
8003200: 34 02 00 58 mvi r2,88
8003204: 58 22 00 00 sw (r1+0),r2
8003208: 34 01 ff ff mvi r1,-1
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
800320c: 2b 9d 00 04 lw ra,(sp+4)
8003210: 37 9c 00 04 addi sp,sp,4
8003214: c3 a0 00 00 ret
08026034 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
8026034: 37 9c ff d8 addi sp,sp,-40
8026038: 5b 8b 00 1c sw (sp+28),r11
802603c: 5b 8c 00 18 sw (sp+24),r12
8026040: 5b 8d 00 14 sw (sp+20),r13
8026044: 5b 8e 00 10 sw (sp+16),r14
8026048: 5b 8f 00 0c sw (sp+12),r15
802604c: 5b 90 00 08 sw (sp+8),r16
8026050: 5b 9d 00 04 sw (sp+4),ra
8026054: b8 20 58 00 mv r11,r1
8026058: b8 40 60 00 mv r12,r2
802605c: 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() )
8026060: fb ff fe e3 calli 8025bec <getpid>
8026064: 5c 2b 00 a5 bne r1,r11,80262f8 <killinfo+0x2c4>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
8026068: 45 80 00 04 be r12,r0,8026078 <killinfo+0x44>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
802606c: 35 82 ff ff addi r2,r12,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
8026070: 34 01 00 1f mvi r1,31
8026074: 50 22 00 0e bgeu r1,r2,80260ac <killinfo+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
8026078: fb ff b7 70 calli 8013e38 <__errno>
802607c: 34 02 00 16 mvi r2,22
8026080: 58 22 00 00 sw (r1+0),r2
8026084: 34 01 ff ff mvi r1,-1
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
8026088: 2b 9d 00 04 lw ra,(sp+4)
802608c: 2b 8b 00 1c lw r11,(sp+28)
8026090: 2b 8c 00 18 lw r12,(sp+24)
8026094: 2b 8d 00 14 lw r13,(sp+20)
8026098: 2b 8e 00 10 lw r14,(sp+16)
802609c: 2b 8f 00 0c lw r15,(sp+12)
80260a0: 2b 90 00 08 lw r16,(sp+8)
80260a4: 37 9c 00 28 addi sp,sp,40
80260a8: 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 )
80260ac: b5 8c 80 00 add r16,r12,r12
80260b0: b6 0c 08 00 add r1,r16,r12
80260b4: 78 0d 08 02 mvhi r13,0x802
80260b8: b4 21 08 00 add r1,r1,r1
80260bc: 39 ad af 38 ori r13,r13,0xaf38
80260c0: b4 21 08 00 add r1,r1,r1
80260c4: b5 a1 08 00 add r1,r13,r1
80260c8: 28 23 00 08 lw r3,(r1+8)
80260cc: 34 0f 00 01 mvi r15,1
return 0;
80260d0: 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 )
80260d4: 44 6f ff ed be r3,r15,8026088 <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 ) )
80260d8: 65 83 00 04 cmpei r3,r12,4
80260dc: 65 81 00 08 cmpei r1,r12,8
80260e0: b8 61 08 00 or r1,r3,r1
80260e4: 5c 20 00 3f bne r1,r0,80261e0 <killinfo+0x1ac>
80260e8: 34 01 00 0b mvi r1,11
80260ec: 45 81 00 3d be r12,r1,80261e0 <killinfo+0x1ac>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
80260f0: 34 01 00 01 mvi r1,1
80260f4: fb ff 70 1d calli 8002168 <__ashlsi3>
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
80260f8: 5b 8c 00 20 sw (sp+32),r12
siginfo->si_code = SI_USER;
80260fc: 5b 8f 00 24 sw (sp+36),r15
8026100: b8 20 58 00 mv r11,r1
if ( !value ) {
8026104: 45 c0 00 3b be r14,r0,80261f0 <killinfo+0x1bc>
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
8026108: 29 c1 00 00 lw r1,(r14+0)
802610c: 5b 81 00 28 sw (sp+40),r1
8026110: 78 01 08 02 mvhi r1,0x802
8026114: 38 21 aa 20 ori r1,r1,0xaa20
8026118: 28 22 00 00 lw r2,(r1+0)
802611c: 34 42 00 01 addi r2,r2,1
8026120: 58 22 00 00 sw (r1+0),r2
/*
* 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;
8026124: 78 01 08 02 mvhi r1,0x802
8026128: 38 21 ae ec ori r1,r1,0xaeec
802612c: 28 21 00 0c lw r1,(r1+12)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
8026130: 28 22 01 20 lw r2,(r1+288)
8026134: 28 42 00 d0 lw r2,(r2+208)
8026138: a4 40 10 00 not r2,r2
802613c: a1 62 10 00 and r2,r11,r2
8026140: 5c 40 00 18 bne r2,r0,80261a0 <killinfo+0x16c>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
8026144: 78 01 08 02 mvhi r1,0x802
8026148: 38 21 b0 c4 ori r1,r1,0xb0c4
802614c: 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 );
8026150: 78 04 08 02 mvhi r4,0x802
8026154: 38 84 b0 c8 ori r4,r4,0xb0c8
8026158: 44 64 00 28 be r3,r4,80261f8 <killinfo+0x1c4>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
802615c: 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;
8026160: b8 60 08 00 mv r1,r3
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8026164: 28 65 01 20 lw r5,(r3+288)
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
8026168: a1 62 10 00 and r2,r11,r2
802616c: 44 40 00 09 be r2,r0,8026190 <killinfo+0x15c>
8026170: e0 00 00 0c bi 80261a0 <killinfo+0x16c>
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 ) {
8026174: 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 );
8026178: 44 64 00 20 be r3,r4,80261f8 <killinfo+0x1c4> <== ALWAYS TAKEN
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
802617c: 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 ];
8026180: 28 65 01 20 lw r5,(r3+288) <== 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;
8026184: 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)
8026188: a1 62 10 00 and r2,r11,r2 <== NOT EXECUTED
802618c: 5c 40 00 05 bne r2,r0,80261a0 <killinfo+0x16c> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
8026190: 28 a5 00 d0 lw r5,(r5+208)
8026194: a4 a0 28 00 not r5,r5
8026198: a1 65 28 00 and r5,r11,r5
802619c: 44 a2 ff f6 be r5,r2,8026174 <killinfo+0x140>
/*
* 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 ) ) {
80261a0: b9 80 10 00 mv r2,r12
80261a4: 37 83 00 20 addi r3,sp,32
80261a8: f8 00 00 6a calli 8026350 <_POSIX_signals_Unblock_thread>
80261ac: 5c 20 00 0a bne r1,r0,80261d4 <killinfo+0x1a0>
/*
* 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 );
80261b0: b9 60 08 00 mv r1,r11
80261b4: f8 00 00 5c calli 8026324 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
80261b8: b6 0c 60 00 add r12,r16,r12
80261bc: b5 8c 08 00 add r1,r12,r12
80261c0: b4 21 08 00 add r1,r1,r1
80261c4: b5 a1 68 00 add r13,r13,r1
80261c8: 29 a2 00 00 lw r2,(r13+0)
80261cc: 34 01 00 02 mvi r1,2
80261d0: 44 41 00 38 be r2,r1,80262b0 <killinfo+0x27c>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
80261d4: fb ff 9a 16 calli 800ca2c <_Thread_Enable_dispatch>
return 0;
80261d8: 34 01 00 00 mvi r1,0
80261dc: e3 ff ff ab bi 8026088 <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 );
80261e0: f8 00 01 0b calli 802660c <pthread_self>
80261e4: b9 80 10 00 mv r2,r12
80261e8: f8 00 00 bd calli 80264dc <pthread_kill>
80261ec: e3 ff ff a7 bi 8026088 <killinfo+0x54>
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
80261f0: 5b 80 00 28 sw (sp+40),r0
80261f4: e3 ff ff c7 bi 8026110 <killinfo+0xdc>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
80261f8: 78 01 08 02 mvhi r1,0x802
80261fc: 38 21 a0 c0 ori r1,r1,0xa0c0
8026200: 40 26 00 00 lbu r6,(r1+0)
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
8026204: 78 01 08 02 mvhi r1,0x802
8026208: 38 21 a9 bc ori r1,r1,0xa9bc
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
802620c: 78 08 08 02 mvhi r8,0x802
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
8026210: 34 2a 00 10 addi r10,r1,16
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
8026214: 34 c6 00 01 addi r6,r6,1
8026218: 39 08 a9 c4 ori r8,r8,0xa9c4
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
802621c: 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);
8026220: 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 ] )
8026224: 29 02 00 00 lw r2,(r8+0)
8026228: 44 40 00 1e be r2,r0,80262a0 <killinfo+0x26c> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
802622c: 28 42 00 04 lw r2,(r2+4)
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
8026230: 2c 47 00 10 lhu r7,(r2+16)
object_table = the_info->local_table;
8026234: 28 44 00 1c lw r4,(r2+28)
for ( index = 1 ; index <= maximum ; index++ ) {
8026238: 44 e0 00 1a be r7,r0,80262a0 <killinfo+0x26c>
802623c: 34 03 00 01 mvi r3,1
the_thread = (Thread_Control *) object_table[ index ];
8026240: 28 82 00 04 lw r2,(r4+4)
if ( !the_thread )
8026244: 44 40 00 14 be r2,r0,8026294 <killinfo+0x260>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
8026248: 28 45 00 14 lw r5,(r2+20)
802624c: 54 a6 00 12 bgu r5,r6,8026294 <killinfo+0x260>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
8026250: 28 49 01 20 lw r9,(r2+288)
8026254: 29 29 00 d0 lw r9,(r9+208)
8026258: a5 20 48 00 not r9,r9
802625c: a1 69 48 00 and r9,r11,r9
8026260: 45 20 00 0d be r9,r0,8026294 <killinfo+0x260>
*
* 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 ) {
8026264: 54 c5 00 0a bgu r6,r5,802628c <killinfo+0x258>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
8026268: 44 20 00 0b be r1,r0,8026294 <killinfo+0x260> <== NEVER TAKEN
802626c: 28 29 00 10 lw r9,(r1+16)
8026270: 45 20 00 09 be r9,r0,8026294 <killinfo+0x260> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
8026274: 28 4e 00 10 lw r14,(r2+16)
8026278: 45 c0 00 05 be r14,r0,802628c <killinfo+0x258>
802627c: 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) ) {
8026280: 5d 20 00 05 bne r9,r0,8026294 <killinfo+0x260>
8026284: a1 cf 70 00 and r14,r14,r15
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
8026288: 45 c9 00 03 be r14,r9,8026294 <killinfo+0x260>
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
802628c: b8 a0 30 00 mv r6,r5
8026290: b8 40 08 00 mv r1,r2
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
8026294: 34 63 00 01 addi r3,r3,1
8026298: 34 84 00 04 addi r4,r4,4
802629c: 50 e3 ff e9 bgeu r7,r3,8026240 <killinfo+0x20c>
80262a0: 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++) {
80262a4: 5d 0a ff e0 bne r8,r10,8026224 <killinfo+0x1f0>
}
}
}
}
if ( interested ) {
80262a8: 5c 20 ff be bne r1,r0,80261a0 <killinfo+0x16c>
80262ac: e3 ff ff c1 bi 80261b0 <killinfo+0x17c>
_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 );
80262b0: 78 01 08 02 mvhi r1,0x802
80262b4: 38 21 b0 b8 ori r1,r1,0xb0b8
80262b8: fb ff 91 59 calli 800a81c <_Chain_Get>
80262bc: b8 20 10 00 mv r2,r1
if ( !psiginfo ) {
80262c0: 44 20 00 13 be r1,r0,802630c <killinfo+0x2d8>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
80262c4: 2b 83 00 20 lw r3,(sp+32)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
80262c8: b5 8c 60 00 add r12,r12,r12
80262cc: 78 01 08 02 mvhi r1,0x802
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
80262d0: 58 43 00 08 sw (r2+8),r3
80262d4: 2b 83 00 24 lw r3,(sp+36)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
80262d8: b5 8c 60 00 add r12,r12,r12
80262dc: 38 21 b1 30 ori r1,r1,0xb130
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
80262e0: 58 43 00 0c sw (r2+12),r3
80262e4: 2b 83 00 28 lw r3,(sp+40)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
80262e8: b5 81 08 00 add r1,r12,r1
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
80262ec: 58 43 00 10 sw (r2+16),r3
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
80262f0: fb ff 91 35 calli 800a7c4 <_Chain_Append>
80262f4: e3 ff ff b8 bi 80261d4 <killinfo+0x1a0>
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
80262f8: fb ff b6 d0 calli 8013e38 <__errno>
80262fc: 34 02 00 03 mvi r2,3
8026300: 58 22 00 00 sw (r1+0),r2
8026304: 34 01 ff ff mvi r1,-1
8026308: e3 ff ff 60 bi 8026088 <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();
802630c: fb ff 99 c8 calli 800ca2c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
8026310: fb ff b6 ca calli 8013e38 <__errno>
8026314: 34 02 00 0b mvi r2,11
8026318: 58 22 00 00 sw (r1+0),r2
802631c: 34 01 ff ff mvi r1,-1
8026320: e3 ff ff 5a bi 8026088 <killinfo+0x54>
08008df4 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
8008df4: 37 9c ff b8 addi sp,sp,-72
8008df8: 5b 8b 00 20 sw (sp+32),r11
8008dfc: 5b 8c 00 1c sw (sp+28),r12
8008e00: 5b 8d 00 18 sw (sp+24),r13
8008e04: 5b 8e 00 14 sw (sp+20),r14
8008e08: 5b 8f 00 10 sw (sp+16),r15
8008e0c: 5b 90 00 0c sw (sp+12),r16
8008e10: 5b 91 00 08 sw (sp+8),r17
8008e14: 5b 9d 00 04 sw (sp+4),ra
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8008e18: 78 09 08 02 mvhi r9,0x802
8008e1c: 39 29 9d b8 ori r9,r9,0x9db8
8008e20: 29 2a 00 00 lw r10,(r9+0)
8008e24: b8 20 80 00 mv r16,r1
8008e28: 5b 82 00 30 sw (sp+48),r2
8008e2c: 35 4a 00 01 addi r10,r10,1
8008e30: 5b 83 00 34 sw (sp+52),r3
8008e34: 5b 84 00 38 sw (sp+56),r4
8008e38: 5b 85 00 3c sw (sp+60),r5
8008e3c: 5b 86 00 40 sw (sp+64),r6
8008e40: 5b 87 00 44 sw (sp+68),r7
8008e44: 5b 88 00 48 sw (sp+72),r8
8008e48: b8 40 68 00 mv r13,r2
8008e4c: 59 2a 00 00 sw (r9+0),r10
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
8008e50: 20 4f 02 00 andi r15,r2,0x200
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
8008e54: 34 11 00 00 mvi r17,0
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
8008e58: 5d e0 00 38 bne r15,r0,8008f38 <mq_open+0x144>
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 );
8008e5c: 78 0c 08 02 mvhi r12,0x802
8008e60: 39 8c a2 18 ori r12,r12,0xa218
8008e64: b9 80 08 00 mv r1,r12
8008e68: f8 00 0c 20 calli 800bee8 <_Objects_Allocate>
8008e6c: b8 20 58 00 mv r11,r1
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
8008e70: 44 20 00 39 be r1,r0,8008f54 <mq_open+0x160> <== NEVER TAKEN
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
8008e74: 58 2d 00 14 sw (r1+20),r13
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
8008e78: 37 82 00 2c addi r2,sp,44
8008e7c: ba 00 08 00 mv r1,r16
8008e80: f8 00 1f 8b calli 8010cac <_POSIX_Message_queue_Name_to_id>
8008e84: b8 20 70 00 mv r14,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 ) {
8008e88: 5c 20 00 22 bne r1,r0,8008f10 <mq_open+0x11c>
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
8008e8c: 21 ad 0a 00 andi r13,r13,0xa00
8008e90: 34 01 0a 00 mvi r1,2560
8008e94: 45 a1 00 36 be r13,r1,8008f6c <mq_open+0x178>
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
_Objects_Get( &_POSIX_Message_queue_Information, id, location );
8008e98: 2b 82 00 2c lw r2,(sp+44)
8008e9c: 78 01 08 02 mvhi r1,0x802
8008ea0: 37 83 00 24 addi r3,sp,36
8008ea4: 38 21 a0 8c ori r1,r1,0xa08c
8008ea8: f8 00 0d 99 calli 800c50c <_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;
8008eac: 28 24 00 18 lw r4,(r1+24)
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
8008eb0: 2d 62 00 0a lhu r2,(r11+10)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8008eb4: 29 83 00 1c lw r3,(r12+28)
8008eb8: 34 84 00 01 addi r4,r4,1
8008ebc: b4 42 10 00 add r2,r2,r2
8008ec0: 58 24 00 18 sw (r1+24),r4
8008ec4: 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 );
8008ec8: 5b 81 00 28 sw (sp+40),r1
the_mq->open_count += 1;
the_mq_fd->Queue = the_mq;
8008ecc: 59 61 00 10 sw (r11+16),r1
8008ed0: b4 62 10 00 add r2,r3,r2
8008ed4: 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;
8008ed8: 59 60 00 0c sw (r11+12),r0
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
8008edc: f8 00 11 2a calli 800d384 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
8008ee0: f8 00 11 29 calli 800d384 <_Thread_Enable_dispatch>
return (mqd_t)the_mq_fd->Object.id;
8008ee4: 29 61 00 08 lw r1,(r11+8)
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
8008ee8: 2b 9d 00 04 lw ra,(sp+4)
8008eec: 2b 8b 00 20 lw r11,(sp+32)
8008ef0: 2b 8c 00 1c lw r12,(sp+28)
8008ef4: 2b 8d 00 18 lw r13,(sp+24)
8008ef8: 2b 8e 00 14 lw r14,(sp+20)
8008efc: 2b 8f 00 10 lw r15,(sp+16)
8008f00: 2b 90 00 0c lw r16,(sp+12)
8008f04: 2b 91 00 08 lw r17,(sp+8)
8008f08: 37 9c 00 48 addi sp,sp,72
8008f0c: 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) ) ) {
8008f10: 34 01 00 02 mvi r1,2
8008f14: 45 c1 00 1f be r14,r1,8008f90 <mq_open+0x19c>
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 );
8008f18: b9 80 08 00 mv r1,r12
8008f1c: b9 60 10 00 mv r2,r11
8008f20: f8 00 0d 02 calli 800c328 <_Objects_Free>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
8008f24: f8 00 11 18 calli 800d384 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
8008f28: f8 00 30 e0 calli 80152a8 <__errno>
8008f2c: 58 2e 00 00 sw (r1+0),r14
8008f30: 34 01 ff ff mvi r1,-1
8008f34: e3 ff ff ed bi 8008ee8 <mq_open+0xf4>
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 );
8008f38: 78 0c 08 02 mvhi r12,0x802
8008f3c: 39 8c a2 18 ori r12,r12,0xa218
8008f40: b9 80 08 00 mv r1,r12
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
8008f44: 2b 91 00 38 lw r17,(sp+56)
8008f48: f8 00 0b e8 calli 800bee8 <_Objects_Allocate>
8008f4c: b8 20 58 00 mv r11,r1
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
8008f50: 5c 20 ff c9 bne r1,r0,8008e74 <mq_open+0x80>
_Thread_Enable_dispatch();
8008f54: f8 00 11 0c calli 800d384 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
8008f58: f8 00 30 d4 calli 80152a8 <__errno>
8008f5c: 34 02 00 17 mvi r2,23
8008f60: 58 22 00 00 sw (r1+0),r2
8008f64: 34 01 ff ff mvi r1,-1
8008f68: e3 ff ff e0 bi 8008ee8 <mq_open+0xf4>
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 );
8008f6c: b9 60 10 00 mv r2,r11
8008f70: b9 80 08 00 mv r1,r12
8008f74: f8 00 0c ed calli 800c328 <_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();
8008f78: f8 00 11 03 calli 800d384 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
8008f7c: f8 00 30 cb calli 80152a8 <__errno>
8008f80: 34 02 00 11 mvi r2,17
8008f84: 58 22 00 00 sw (r1+0),r2
8008f88: 34 01 ff ff mvi r1,-1
8008f8c: e3 ff ff d7 bi 8008ee8 <mq_open+0xf4>
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) ) ) {
8008f90: 45 e0 ff e2 be r15,r0,8008f18 <mq_open+0x124>
/*
* 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(
8008f94: 34 02 00 01 mvi r2,1
8008f98: ba 00 08 00 mv r1,r16
8008f9c: ba 20 18 00 mv r3,r17
8008fa0: 37 84 00 28 addi r4,sp,40
8008fa4: f8 00 1e d4 calli 8010af4 <_POSIX_Message_queue_Create_support>
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
8008fa8: 34 02 ff ff mvi r2,-1
8008fac: 44 22 00 0d be r1,r2,8008fe0 <mq_open+0x1ec>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
8008fb0: 2d 61 00 0a lhu r1,(r11+10)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8008fb4: 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;
8008fb8: 2b 83 00 28 lw r3,(sp+40)
8008fbc: b4 21 08 00 add r1,r1,r1
8008fc0: b4 21 08 00 add r1,r1,r1
8008fc4: b4 41 08 00 add r1,r2,r1
8008fc8: 59 63 00 10 sw (r11+16),r3
8008fcc: 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;
8008fd0: 59 60 00 0c sw (r11+12),r0
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
8008fd4: f8 00 10 ec calli 800d384 <_Thread_Enable_dispatch>
return (mqd_t) the_mq_fd->Object.id;
8008fd8: 29 61 00 08 lw r1,(r11+8)
8008fdc: e3 ff ff c3 bi 8008ee8 <mq_open+0xf4>
8008fe0: b9 80 08 00 mv r1,r12
8008fe4: b9 60 10 00 mv r2,r11
8008fe8: f8 00 0c d0 calli 800c328 <_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();
8008fec: f8 00 10 e6 calli 800d384 <_Thread_Enable_dispatch>
return (mqd_t) -1;
8008ff0: 34 01 ff ff mvi r1,-1
8008ff4: e3 ff ff bd bi 8008ee8 <mq_open+0xf4>
08008564 <pthread_attr_setschedpolicy>:
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
8008564: 34 03 00 16 mvi r3,22
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
8008568: 44 20 00 09 be r1,r0,800858c <pthread_attr_setschedpolicy+0x28>
800856c: 28 24 00 00 lw r4,(r1+0)
8008570: 44 80 00 07 be r4,r0,800858c <pthread_attr_setschedpolicy+0x28>
return EINVAL;
switch ( policy ) {
8008574: 48 02 00 05 bg r0,r2,8008588 <pthread_attr_setschedpolicy+0x24>
8008578: 34 03 00 02 mvi r3,2
800857c: 4c 62 00 06 bge r3,r2,8008594 <pthread_attr_setschedpolicy+0x30>
8008580: 34 03 00 04 mvi r3,4
8008584: 44 43 00 04 be r2,r3,8008594 <pthread_attr_setschedpolicy+0x30><== ALWAYS TAKEN
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
8008588: 34 03 00 86 mvi r3,134
}
}
800858c: b8 60 08 00 mv r1,r3
8008590: c3 a0 00 00 ret
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
8008594: 34 03 00 00 mvi r3,0
switch ( policy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
8008598: 58 22 00 14 sw (r1+20),r2
return 0;
default:
return ENOTSUP;
}
}
800859c: b8 60 08 00 mv r1,r3
80085a0: c3 a0 00 00 ret
08003754 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
8003754: 37 9c ff d8 addi sp,sp,-40
8003758: 5b 8b 00 14 sw (sp+20),r11
800375c: 5b 8c 00 10 sw (sp+16),r12
8003760: 5b 8d 00 0c sw (sp+12),r13
8003764: 5b 8e 00 08 sw (sp+8),r14
8003768: 5b 9d 00 04 sw (sp+4),ra
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
800376c: 34 04 00 16 mvi r4,22
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
8003770: b8 20 58 00 mv r11,r1
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
8003774: 44 20 00 08 be r1,r0,8003794 <pthread_barrier_init+0x40>
return EINVAL;
if ( count == 0 )
8003778: 44 60 00 07 be r3,r0,8003794 <pthread_barrier_init+0x40>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
800377c: 44 40 00 34 be r2,r0,800384c <pthread_barrier_init+0xf8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
8003780: 28 41 00 00 lw r1,(r2+0)
return EINVAL;
8003784: 34 04 00 16 mvi r4,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
8003788: 44 20 00 03 be r1,r0,8003794 <pthread_barrier_init+0x40>
return EINVAL;
switch ( the_attr->process_shared ) {
800378c: 28 4e 00 04 lw r14,(r2+4)
8003790: 45 c0 00 09 be r14,r0,80037b4 <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;
}
8003794: b8 80 08 00 mv r1,r4
8003798: 2b 9d 00 04 lw ra,(sp+4)
800379c: 2b 8b 00 14 lw r11,(sp+20)
80037a0: 2b 8c 00 10 lw r12,(sp+16)
80037a4: 2b 8d 00 0c lw r13,(sp+12)
80037a8: 2b 8e 00 08 lw r14,(sp+8)
80037ac: 37 9c 00 28 addi sp,sp,40
80037b0: c3 a0 00 00 ret
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
80037b4: 78 01 08 01 mvhi r1,0x801
80037b8: 38 21 68 78 ori r1,r1,0x6878
80037bc: 28 22 00 00 lw r2,(r1+0)
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
80037c0: 5b 80 00 24 sw (sp+36),r0
the_attributes.maximum_count = count;
80037c4: 5b 83 00 28 sw (sp+40),r3
80037c8: 34 42 00 01 addi r2,r2,1
80037cc: 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 );
80037d0: 78 0d 08 01 mvhi r13,0x801
80037d4: 39 ad 6b cc ori r13,r13,0x6bcc
80037d8: b9 a0 08 00 mv r1,r13
80037dc: f8 00 08 43 calli 80058e8 <_Objects_Allocate>
80037e0: b8 20 60 00 mv r12,r1
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
80037e4: 44 2e 00 17 be r1,r14,8003840 <pthread_barrier_init+0xec>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
80037e8: 37 82 00 24 addi r2,sp,36
80037ec: 34 21 00 10 addi r1,r1,16
80037f0: f8 00 05 2c calli 8004ca0 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
80037f4: 29 82 00 08 lw r2,(r12+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80037f8: 29 a3 00 1c lw r3,(r13+28)
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
80037fc: 20 41 ff ff andi r1,r2,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8003800: b4 21 08 00 add r1,r1,r1
8003804: b4 21 08 00 add r1,r1,r1
8003808: b4 61 08 00 add r1,r3,r1
800380c: 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;
8003810: 59 80 00 0c sw (r12+12),r0
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
8003814: 59 62 00 00 sw (r11+0),r2
_Thread_Enable_dispatch();
8003818: f8 00 0c be calli 8006b10 <_Thread_Enable_dispatch>
return 0;
800381c: 34 04 00 00 mvi r4,0
}
8003820: b8 80 08 00 mv r1,r4
8003824: 2b 9d 00 04 lw ra,(sp+4)
8003828: 2b 8b 00 14 lw r11,(sp+20)
800382c: 2b 8c 00 10 lw r12,(sp+16)
8003830: 2b 8d 00 0c lw r13,(sp+12)
8003834: 2b 8e 00 08 lw r14,(sp+8)
8003838: 37 9c 00 28 addi sp,sp,40
800383c: c3 a0 00 00 ret
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
8003840: f8 00 0c b4 calli 8006b10 <_Thread_Enable_dispatch>
return EAGAIN;
8003844: 34 04 00 0b mvi r4,11
8003848: e3 ff ff d3 bi 8003794 <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 );
800384c: 37 8c 00 1c addi r12,sp,28
8003850: b9 80 08 00 mv r1,r12
8003854: 5b 83 00 18 sw (sp+24),r3
8003858: fb ff ff 7c calli 8003648 <pthread_barrierattr_init>
the_attr = &my_attr;
800385c: b9 80 10 00 mv r2,r12
8003860: 2b 83 00 18 lw r3,(sp+24)
8003864: e3 ff ff c7 bi 8003780 <pthread_barrier_init+0x2c>
08002f60 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
8002f60: 37 9c ff f4 addi sp,sp,-12
8002f64: 5b 8b 00 0c sw (sp+12),r11
8002f68: 5b 8c 00 08 sw (sp+8),r12
8002f6c: 5b 9d 00 04 sw (sp+4),ra
8002f70: b8 20 58 00 mv r11,r1
8002f74: 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 )
8002f78: 44 20 00 14 be r1,r0,8002fc8 <pthread_cleanup_push+0x68>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8002f7c: 78 03 08 01 mvhi r3,0x801
8002f80: 38 63 68 50 ori r3,r3,0x6850
8002f84: 28 61 00 00 lw r1,(r3+0)
8002f88: 34 21 00 01 addi r1,r1,1
8002f8c: 58 61 00 00 sw (r3+0),r1
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
8002f90: 34 01 00 10 mvi r1,16
8002f94: f8 00 12 1e calli 800780c <_Workspace_Allocate>
8002f98: b8 20 18 00 mv r3,r1
if ( handler ) {
8002f9c: 44 20 00 0a be r1,r0,8002fc4 <pthread_cleanup_push+0x64> <== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
8002fa0: 78 04 08 01 mvhi r4,0x801
8002fa4: 38 84 6d 1c ori r4,r4,0x6d1c
8002fa8: 28 81 00 0c lw r1,(r4+12)
handler_stack = &thread_support->Cancellation_Handlers;
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
8002fac: 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;
8002fb0: 28 21 01 20 lw r1,(r1+288)
handler->routine = routine;
8002fb4: 58 6b 00 08 sw (r3+8),r11
handler->arg = arg;
8002fb8: 58 6c 00 0c sw (r3+12),r12
_Chain_Append( handler_stack, &handler->Node );
8002fbc: 34 21 00 e4 addi r1,r1,228
8002fc0: f8 00 05 2c calli 8004470 <_Chain_Append>
}
_Thread_Enable_dispatch();
8002fc4: f8 00 0c a3 calli 8006250 <_Thread_Enable_dispatch>
}
8002fc8: 2b 9d 00 04 lw ra,(sp+4)
8002fcc: 2b 8b 00 0c lw r11,(sp+12)
8002fd0: 2b 8c 00 08 lw r12,(sp+8)
8002fd4: 37 9c 00 0c addi sp,sp,12
8002fd8: c3 a0 00 00 ret
0800406c <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
800406c: 37 9c ff ec addi sp,sp,-20
8004070: 5b 8b 00 10 sw (sp+16),r11
8004074: 5b 8c 00 0c sw (sp+12),r12
8004078: 5b 8d 00 08 sw (sp+8),r13
800407c: 5b 9d 00 04 sw (sp+4),ra
8004080: b8 20 68 00 mv r13,r1
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
8004084: 44 40 00 35 be r2,r0,8004158 <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 )
8004088: 28 44 00 04 lw r4,(r2+4)
800408c: 34 03 00 01 mvi r3,1
return EINVAL;
8004090: 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 )
8004094: 44 83 00 03 be r4,r3,80040a0 <pthread_cond_init+0x34> <== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
8004098: 28 43 00 00 lw r3,(r2+0)
800409c: 5c 60 00 07 bne r3,r0,80040b8 <pthread_cond_init+0x4c>
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
80040a0: 2b 9d 00 04 lw ra,(sp+4)
80040a4: 2b 8b 00 10 lw r11,(sp+16)
80040a8: 2b 8c 00 0c lw r12,(sp+12)
80040ac: 2b 8d 00 08 lw r13,(sp+8)
80040b0: 37 9c 00 14 addi sp,sp,20
80040b4: c3 a0 00 00 ret
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
80040b8: 78 03 08 01 mvhi r3,0x801
80040bc: 38 63 78 68 ori r3,r3,0x7868
80040c0: 28 61 00 00 lw r1,(r3+0)
80040c4: 34 21 00 01 addi r1,r1,1
80040c8: 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 );
80040cc: 78 0c 08 01 mvhi r12,0x801
80040d0: 39 8c 7c 54 ori r12,r12,0x7c54
80040d4: b9 80 08 00 mv r1,r12
80040d8: 5b 82 00 14 sw (sp+20),r2
80040dc: f8 00 09 e7 calli 8006878 <_Objects_Allocate>
80040e0: b8 20 58 00 mv r11,r1
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
80040e4: 2b 82 00 14 lw r2,(sp+20)
80040e8: 44 20 00 1f be r1,r0,8004164 <pthread_cond_init+0xf8>
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
80040ec: 78 01 08 01 mvhi r1,0x801
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
80040f0: 28 45 00 04 lw r5,(r2+4)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
80040f4: 38 21 61 e0 ori r1,r1,0x61e0
80040f8: 28 23 00 00 lw r3,(r1+0)
80040fc: 34 04 00 74 mvi r4,116
8004100: 35 61 00 18 addi r1,r11,24
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
8004104: 59 65 00 10 sw (r11+16),r5
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
8004108: 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;
800410c: 59 60 00 14 sw (r11+20),r0
_Thread_queue_Initialize(
8004110: f8 00 11 04 calli 8008520 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
8004114: 29 61 00 08 lw r1,(r11+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8004118: 29 83 00 1c lw r3,(r12+28)
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
800411c: 20 22 ff ff andi r2,r1,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8004120: b4 42 10 00 add r2,r2,r2
8004124: b4 42 10 00 add r2,r2,r2
8004128: b4 62 10 00 add r2,r3,r2
800412c: 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;
8004130: 59 60 00 0c sw (r11+12),r0
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
8004134: 59 a1 00 00 sw (r13+0),r1
_Thread_Enable_dispatch();
8004138: f8 00 0e c9 calli 8007c5c <_Thread_Enable_dispatch>
return 0;
800413c: 34 01 00 00 mvi r1,0
}
8004140: 2b 9d 00 04 lw ra,(sp+4)
8004144: 2b 8b 00 10 lw r11,(sp+16)
8004148: 2b 8c 00 0c lw r12,(sp+12)
800414c: 2b 8d 00 08 lw r13,(sp+8)
8004150: 37 9c 00 14 addi sp,sp,20
8004154: 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;
8004158: 78 02 08 01 mvhi r2,0x801
800415c: 38 42 61 d8 ori r2,r2,0x61d8
8004160: e3 ff ff ca bi 8004088 <pthread_cond_init+0x1c>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
8004164: f8 00 0e be calli 8007c5c <_Thread_Enable_dispatch>
return ENOMEM;
8004168: 34 01 00 0c mvi r1,12
800416c: e3 ff ff cd bi 80040a0 <pthread_cond_init+0x34>
08003ec8 <pthread_condattr_destroy>:
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
8003ec8: 34 02 00 16 mvi r2,22
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
8003ecc: 44 20 00 05 be r1,r0,8003ee0 <pthread_condattr_destroy+0x18>
8003ed0: 28 23 00 00 lw r3,(r1+0)
8003ed4: 44 60 00 03 be r3,r0,8003ee0 <pthread_condattr_destroy+0x18><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
8003ed8: 58 20 00 00 sw (r1+0),r0
return 0;
8003edc: 34 02 00 00 mvi r2,0
}
8003ee0: b8 40 08 00 mv r1,r2
8003ee4: c3 a0 00 00 ret
080033e8 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
80033e8: 37 9c ff a0 addi sp,sp,-96
80033ec: 5b 8b 00 3c sw (sp+60),r11
80033f0: 5b 8c 00 38 sw (sp+56),r12
80033f4: 5b 8d 00 34 sw (sp+52),r13
80033f8: 5b 8e 00 30 sw (sp+48),r14
80033fc: 5b 8f 00 2c sw (sp+44),r15
8003400: 5b 90 00 28 sw (sp+40),r16
8003404: 5b 91 00 24 sw (sp+36),r17
8003408: 5b 92 00 20 sw (sp+32),r18
800340c: 5b 93 00 1c sw (sp+28),r19
8003410: 5b 94 00 18 sw (sp+24),r20
8003414: 5b 95 00 14 sw (sp+20),r21
8003418: 5b 9d 00 10 sw (sp+16),ra
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
800341c: 34 0c 00 0e mvi r12,14
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
8003420: b8 60 68 00 mv r13,r3
8003424: b8 20 78 00 mv r15,r1
8003428: b8 80 70 00 mv r14,r4
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
800342c: 44 60 00 13 be r3,r0,8003478 <pthread_create+0x90> <== NEVER TAKEN
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
8003430: b8 40 58 00 mv r11,r2
8003434: 44 40 00 66 be r2,r0,80035cc <pthread_create+0x1e4>
if ( !the_attr->is_initialized )
8003438: 29 61 00 00 lw r1,(r11+0)
return EINVAL;
800343c: 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 )
8003440: 44 20 00 0e be r1,r0,8003478 <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) )
8003444: 29 61 00 04 lw r1,(r11+4)
8003448: 44 20 00 06 be r1,r0,8003460 <pthread_create+0x78>
800344c: 78 02 08 01 mvhi r2,0x801
8003450: 38 42 f0 e0 ori r2,r2,0xf0e0
8003454: 29 63 00 08 lw r3,(r11+8)
8003458: 28 41 00 00 lw r1,(r2+0)
800345c: 54 23 00 07 bgu r1,r3,8003478 <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 ) {
8003460: 29 61 00 10 lw r1,(r11+16)
8003464: 34 02 00 01 mvi r2,1
8003468: 44 22 00 5c be r1,r2,80035d8 <pthread_create+0x1f0>
800346c: 34 02 00 02 mvi r2,2
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
8003470: 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 ) {
8003474: 44 22 00 10 be r1,r2,80034b4 <pthread_create+0xcc>
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
8003478: b9 80 08 00 mv r1,r12
800347c: 2b 9d 00 10 lw ra,(sp+16)
8003480: 2b 8b 00 3c lw r11,(sp+60)
8003484: 2b 8c 00 38 lw r12,(sp+56)
8003488: 2b 8d 00 34 lw r13,(sp+52)
800348c: 2b 8e 00 30 lw r14,(sp+48)
8003490: 2b 8f 00 2c lw r15,(sp+44)
8003494: 2b 90 00 28 lw r16,(sp+40)
8003498: 2b 91 00 24 lw r17,(sp+36)
800349c: 2b 92 00 20 lw r18,(sp+32)
80034a0: 2b 93 00 1c lw r19,(sp+28)
80034a4: 2b 94 00 18 lw r20,(sp+24)
80034a8: 2b 95 00 14 lw r21,(sp+20)
80034ac: 37 9c 00 60 addi sp,sp,96
80034b0: c3 a0 00 00 ret
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
80034b4: 29 67 00 18 lw r7,(r11+24)
80034b8: 29 66 00 1c lw r6,(r11+28)
80034bc: 29 65 00 20 lw r5,(r11+32)
80034c0: 29 64 00 24 lw r4,(r11+36)
80034c4: 29 63 00 28 lw r3,(r11+40)
80034c8: 29 62 00 2c lw r2,(r11+44)
80034cc: 29 61 00 30 lw r1,(r11+48)
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
80034d0: 29 71 00 14 lw r17,(r11+20)
schedparam = the_attr->schedparam;
80034d4: 5b 87 00 40 sw (sp+64),r7
80034d8: 5b 86 00 44 sw (sp+68),r6
80034dc: 5b 85 00 48 sw (sp+72),r5
80034e0: 5b 84 00 4c sw (sp+76),r4
80034e4: 5b 83 00 50 sw (sp+80),r3
80034e8: 5b 82 00 54 sw (sp+84),r2
80034ec: 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 )
80034f0: 29 70 00 0c lw r16,(r11+12)
return ENOTSUP;
80034f4: 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 )
80034f8: 5e 00 ff e0 bne r16,r0,8003478 <pthread_create+0x90>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
80034fc: 2b 81 00 40 lw r1,(sp+64)
return EINVAL;
8003500: 34 0c 00 16 mvi r12,22
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
8003504: f8 00 1c 6a calli 800a6ac <_POSIX_Priority_Is_valid>
8003508: 44 30 ff dc be r1,r16,8003478 <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);
800350c: 78 05 08 01 mvhi r5,0x801
8003510: 38 a5 f0 e4 ori r5,r5,0xf0e4
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
8003514: ba 20 08 00 mv r1,r17
8003518: 37 82 00 40 addi r2,sp,64
800351c: 37 83 00 60 addi r3,sp,96
8003520: 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 );
8003524: 2b 94 00 40 lw r20,(sp+64)
8003528: 40 b5 00 00 lbu r21,(r5+0)
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
800352c: f8 00 1c 68 calli 800a6cc <_POSIX_Thread_Translate_sched_param>
8003530: b8 20 60 00 mv r12,r1
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
8003534: 5c 20 ff d1 bne r1,r0,8003478 <pthread_create+0x90>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
8003538: 78 12 08 01 mvhi r18,0x801
800353c: 3a 52 f9 18 ori r18,r18,0xf918
8003540: 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 );
8003544: 78 10 08 01 mvhi r16,0x801
8003548: 3a 10 fa 2c ori r16,r16,0xfa2c
800354c: f8 00 05 3a calli 8004a34 <_API_Mutex_Lock>
8003550: ba 00 08 00 mv r1,r16
8003554: f8 00 08 6a calli 80056fc <_Objects_Allocate>
8003558: 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 ) {
800355c: 44 2c 00 18 be r1,r12,80035bc <pthread_create+0x1d4>
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
8003560: 78 01 08 01 mvhi r1,0x801
8003564: 38 21 f0 e0 ori r1,r1,0xf0e0
8003568: 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(
800356c: 29 61 00 08 lw r1,(r11+8)
8003570: 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 )
8003574: 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(
8003578: 50 81 00 02 bgeu r4,r1,8003580 <pthread_create+0x198>
800357c: b8 20 20 00 mv r4,r1
8003580: 2b 89 00 5c lw r9,(sp+92)
8003584: 2b 88 00 60 lw r8,(sp+96)
8003588: ba 00 08 00 mv r1,r16
800358c: ba 60 10 00 mv r2,r19
8003590: 34 05 00 00 mvi r5,0
8003594: ca b4 30 00 sub r6,r21,r20
8003598: 34 07 00 01 mvi r7,1
800359c: 5b 89 00 04 sw (sp+4),r9
80035a0: 5b 80 00 08 sw (sp+8),r0
80035a4: 5b 80 00 0c sw (sp+12),r0
80035a8: f8 00 0d 42 calli 8006ab0 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
80035ac: 5c 20 00 1f bne r1,r0,8003628 <pthread_create+0x240> <== ALWAYS TAKEN
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
80035b0: ba 00 08 00 mv r1,r16 <== NOT EXECUTED
80035b4: ba 60 10 00 mv r2,r19 <== NOT EXECUTED
80035b8: f8 00 09 55 calli 8005b0c <_Objects_Free> <== NOT EXECUTED
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
80035bc: 2a 41 00 00 lw r1,(r18+0)
return EAGAIN;
80035c0: 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();
80035c4: f8 00 05 38 calli 8004aa4 <_API_Mutex_Unlock>
return EAGAIN;
80035c8: e3 ff ff ac bi 8003478 <pthread_create+0x90>
int rc;
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
80035cc: 78 0b 08 01 mvhi r11,0x801
80035d0: 39 6b db cc ori r11,r11,0xdbcc
80035d4: e3 ff ff 99 bi 8003438 <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 ];
80035d8: 78 01 08 01 mvhi r1,0x801
80035dc: 38 21 fd 24 ori r1,r1,0xfd24
80035e0: 28 21 00 0c lw r1,(r1+12)
80035e4: 28 22 01 20 lw r2,(r1+288)
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
80035e8: 28 48 00 88 lw r8,(r2+136)
80035ec: 28 47 00 8c lw r7,(r2+140)
80035f0: 28 46 00 90 lw r6,(r2+144)
80035f4: 28 45 00 94 lw r5,(r2+148)
80035f8: 28 44 00 98 lw r4,(r2+152)
80035fc: 28 43 00 9c lw r3,(r2+156)
8003600: 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;
8003604: 28 51 00 84 lw r17,(r2+132)
schedparam = api->schedparam;
8003608: 5b 88 00 40 sw (sp+64),r8
800360c: 5b 87 00 44 sw (sp+68),r7
8003610: 5b 86 00 48 sw (sp+72),r6
8003614: 5b 85 00 4c sw (sp+76),r5
8003618: 5b 84 00 50 sw (sp+80),r4
800361c: 5b 83 00 54 sw (sp+84),r3
8003620: 5b 81 00 58 sw (sp+88),r1
break;
8003624: e3 ff ff b3 bi 80034f0 <pthread_create+0x108>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8003628: 2a 70 01 20 lw r16,(r19+288)
api->Attributes = *the_attr;
800362c: 29 63 00 00 lw r3,(r11+0)
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003630: ba 60 08 00 mv r1,r19
8003634: 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;
8003638: 5a 03 00 00 sw (r16+0),r3
800363c: 29 65 00 04 lw r5,(r11+4)
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003640: b9 a0 18 00 mv r3,r13
8003644: 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;
8003648: 5a 05 00 04 sw (r16+4),r5
800364c: 29 66 00 08 lw r6,(r11+8)
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003650: 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;
8003654: 5a 06 00 08 sw (r16+8),r6
8003658: 29 66 00 0c lw r6,(r11+12)
800365c: 5a 06 00 0c sw (r16+12),r6
8003660: 29 66 00 10 lw r6,(r11+16)
8003664: 5a 06 00 10 sw (r16+16),r6
8003668: 29 66 00 14 lw r6,(r11+20)
800366c: 5a 06 00 14 sw (r16+20),r6
8003670: 29 66 00 18 lw r6,(r11+24)
8003674: 5a 06 00 18 sw (r16+24),r6
8003678: 29 66 00 1c lw r6,(r11+28)
800367c: 5a 06 00 1c sw (r16+28),r6
8003680: 29 66 00 20 lw r6,(r11+32)
8003684: 5a 06 00 20 sw (r16+32),r6
8003688: 29 66 00 24 lw r6,(r11+36)
800368c: 5a 06 00 24 sw (r16+36),r6
8003690: 29 66 00 28 lw r6,(r11+40)
8003694: 5a 06 00 28 sw (r16+40),r6
8003698: 29 66 00 2c lw r6,(r11+44)
800369c: 5a 06 00 2c sw (r16+44),r6
80036a0: 29 66 00 30 lw r6,(r11+48)
80036a4: 5a 06 00 30 sw (r16+48),r6
80036a8: 29 66 00 34 lw r6,(r11+52)
80036ac: 5a 06 00 34 sw (r16+52),r6
80036b0: 29 66 00 38 lw r6,(r11+56)
80036b4: 5a 06 00 38 sw (r16+56),r6
80036b8: 29 66 00 3c lw r6,(r11+60)
80036bc: 5a 06 00 3c sw (r16+60),r6
api->detachstate = the_attr->detachstate;
80036c0: 29 66 00 3c lw r6,(r11+60)
80036c4: 5a 06 00 40 sw (r16+64),r6
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
80036c8: 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;
80036cc: 5a 11 00 84 sw (r16+132),r17
api->schedparam = schedparam;
80036d0: 5a 06 00 88 sw (r16+136),r6
80036d4: 2b 86 00 44 lw r6,(sp+68)
80036d8: 5a 06 00 8c sw (r16+140),r6
80036dc: 2b 86 00 48 lw r6,(sp+72)
80036e0: 5a 06 00 90 sw (r16+144),r6
80036e4: 2b 86 00 4c lw r6,(sp+76)
80036e8: 5a 06 00 94 sw (r16+148),r6
80036ec: 2b 86 00 50 lw r6,(sp+80)
80036f0: 5a 06 00 98 sw (r16+152),r6
80036f4: 2b 86 00 54 lw r6,(sp+84)
80036f8: 5a 06 00 9c sw (r16+156),r6
80036fc: 2b 86 00 58 lw r6,(sp+88)
8003700: 5a 06 00 a0 sw (r16+160),r6
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
8003704: f8 00 0f c6 calli 800761c <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
8003708: 34 01 00 04 mvi r1,4
800370c: 46 21 00 06 be r17,r1,8003724 <pthread_create+0x33c>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
8003710: 2a 62 00 08 lw r2,(r19+8)
_RTEMS_Unlock_allocator();
8003714: 2a 41 00 00 lw r1,(r18+0)
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
8003718: 59 e2 00 00 sw (r15+0),r2
_RTEMS_Unlock_allocator();
800371c: f8 00 04 e2 calli 8004aa4 <_API_Mutex_Unlock>
return 0;
8003720: e3 ff ff 56 bi 8003478 <pthread_create+0x90>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
8003724: 36 01 00 90 addi r1,r16,144
8003728: f8 00 10 50 calli 8007868 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
800372c: 5a 01 00 b4 sw (r16+180),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8003730: 78 01 08 01 mvhi r1,0x801
8003734: 36 02 00 a8 addi r2,r16,168
8003738: 38 21 f9 38 ori r1,r1,0xf938
800373c: f8 00 11 96 calli 8007d94 <_Watchdog_Insert>
8003740: e3 ff ff f4 bi 8003710 <pthread_create+0x328>
0800c72c <pthread_exit>:
void pthread_exit(
void *value_ptr
)
{
800c72c: 37 9c ff fc addi sp,sp,-4
800c730: 5b 9d 00 04 sw (sp+4),ra
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
800c734: 78 03 08 01 mvhi r3,0x801
800c738: 38 63 4d 74 ori r3,r3,0x4d74
}
void pthread_exit(
void *value_ptr
)
{
800c73c: b8 20 10 00 mv r2,r1
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
800c740: 28 61 00 0c lw r1,(r3+12)
800c744: fb ff ff d4 calli 800c694 <_POSIX_Thread_Exit>
}
800c748: 2b 9d 00 04 lw ra,(sp+4)
800c74c: 37 9c 00 04 addi sp,sp,4 <== NOT EXECUTED
800c750: c3 a0 00 00 ret <== NOT EXECUTED
08005954 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
8005954: 37 9c ff f0 addi sp,sp,-16
8005958: 5b 8b 00 0c sw (sp+12),r11
800595c: 5b 8c 00 08 sw (sp+8),r12
8005960: 5b 9d 00 04 sw (sp+4),ra
8005964: 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 );
8005968: b8 40 08 00 mv r1,r2
800596c: 37 82 00 10 addi r2,sp,16
8005970: f8 00 00 49 calli 8005a94 <_POSIX_Absolute_timeout_to_ticks>
8005974: b8 20 58 00 mv r11,r1
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
8005978: 34 01 00 03 mvi r1,3
800597c: 45 61 00 15 be r11,r1,80059d0 <pthread_mutex_timedlock+0x7c>
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
8005980: 2b 83 00 10 lw r3,(sp+16)
8005984: 34 02 00 00 mvi r2,0
8005988: b9 80 08 00 mv r1,r12
800598c: fb ff ff 9f calli 8005808 <_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) ) {
8005990: 34 02 00 10 mvi r2,16
8005994: 44 22 00 06 be r1,r2,80059ac <pthread_mutex_timedlock+0x58><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
8005998: 2b 9d 00 04 lw ra,(sp+4)
800599c: 2b 8b 00 0c lw r11,(sp+12)
80059a0: 2b 8c 00 08 lw r12,(sp+8)
80059a4: 37 9c 00 10 addi sp,sp,16
80059a8: 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 )
80059ac: 45 60 00 12 be r11,r0,80059f4 <pthread_mutex_timedlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
80059b0: 35 6b ff ff addi r11,r11,-1
80059b4: 34 02 00 01 mvi r2,1
80059b8: 50 4b 00 11 bgeu r2,r11,80059fc <pthread_mutex_timedlock+0xa8><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
80059bc: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80059c0: 2b 8b 00 0c lw r11,(sp+12) <== NOT EXECUTED
80059c4: 2b 8c 00 08 lw r12,(sp+8) <== NOT EXECUTED
80059c8: 37 9c 00 10 addi sp,sp,16 <== NOT EXECUTED
80059cc: 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 );
80059d0: 2b 83 00 10 lw r3,(sp+16)
80059d4: b9 80 08 00 mv r1,r12
80059d8: 34 02 00 01 mvi r2,1
80059dc: fb ff ff 8b calli 8005808 <_POSIX_Mutex_Lock_support>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
80059e0: 2b 9d 00 04 lw ra,(sp+4)
80059e4: 2b 8b 00 0c lw r11,(sp+12)
80059e8: 2b 8c 00 08 lw r12,(sp+8)
80059ec: 37 9c 00 10 addi sp,sp,16
80059f0: 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;
80059f4: 34 01 00 16 mvi r1,22 <== NOT EXECUTED
80059f8: e3 ff ff e8 bi 8005998 <pthread_mutex_timedlock+0x44> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
80059fc: 34 01 00 74 mvi r1,116
8005a00: e3 ff ff e6 bi 8005998 <pthread_mutex_timedlock+0x44>
08002b88 <pthread_mutexattr_gettype>:
const pthread_mutexattr_t *attr,
int *type
)
{
if ( !attr )
return EINVAL;
8002b88: 34 03 00 16 mvi r3,22
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
if ( !attr )
8002b8c: 44 20 00 07 be r1,r0,8002ba8 <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !attr->is_initialized )
8002b90: 28 24 00 00 lw r4,(r1+0)
8002b94: 44 80 00 05 be r4,r0,8002ba8 <pthread_mutexattr_gettype+0x20>
return EINVAL;
if ( !type )
8002b98: 44 40 00 04 be r2,r0,8002ba8 <pthread_mutexattr_gettype+0x20><== NEVER TAKEN
return EINVAL;
*type = attr->type;
8002b9c: 28 21 00 10 lw r1,(r1+16)
return 0;
8002ba0: 34 03 00 00 mvi r3,0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
8002ba4: 58 41 00 00 sw (r2+0),r1
return 0;
}
8002ba8: b8 60 08 00 mv r1,r3
8002bac: c3 a0 00 00 ret
0800543c <pthread_mutexattr_setpshared>:
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
800543c: 34 03 00 16 mvi r3,22
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
8005440: 44 20 00 07 be r1,r0,800545c <pthread_mutexattr_setpshared+0x20>
8005444: 28 24 00 00 lw r4,(r1+0)
8005448: 44 80 00 05 be r4,r0,800545c <pthread_mutexattr_setpshared+0x20>
return EINVAL;
switch ( pshared ) {
800544c: 34 04 00 01 mvi r4,1
8005450: 54 44 00 03 bgu r2,r4,800545c <pthread_mutexattr_setpshared+0x20><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
8005454: 58 22 00 04 sw (r1+4),r2
return 0;
8005458: 34 03 00 00 mvi r3,0
default:
return EINVAL;
}
}
800545c: b8 60 08 00 mv r1,r3
8005460: c3 a0 00 00 ret
08002bfc <pthread_mutexattr_settype>:
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
8002bfc: 34 03 00 16 mvi r3,22
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
8002c00: 44 20 00 07 be r1,r0,8002c1c <pthread_mutexattr_settype+0x20>
8002c04: 28 24 00 00 lw r4,(r1+0)
8002c08: 44 80 00 05 be r4,r0,8002c1c <pthread_mutexattr_settype+0x20><== NEVER TAKEN
return EINVAL;
switch ( type ) {
8002c0c: 34 04 00 03 mvi r4,3
8002c10: 54 44 00 03 bgu r2,r4,8002c1c <pthread_mutexattr_settype+0x20>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
8002c14: 58 22 00 10 sw (r1+16),r2
return 0;
8002c18: 34 03 00 00 mvi r3,0
default:
return EINVAL;
}
}
8002c1c: b8 60 08 00 mv r1,r3
8002c20: c3 a0 00 00 ret
08003c5c <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
8003c5c: 37 9c ff ec addi sp,sp,-20
8003c60: 5b 8b 00 10 sw (sp+16),r11
8003c64: 5b 8c 00 0c sw (sp+12),r12
8003c68: 5b 8d 00 08 sw (sp+8),r13
8003c6c: 5b 9d 00 04 sw (sp+4),ra
if ( !once_control || !init_routine )
8003c70: 64 43 00 00 cmpei r3,r2,0
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
8003c74: b8 40 60 00 mv r12,r2
if ( !once_control || !init_routine )
8003c78: 64 22 00 00 cmpei r2,r1,0
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
8003c7c: b8 20 58 00 mv r11,r1
if ( !once_control || !init_routine )
8003c80: b8 62 18 00 or r3,r3,r2
return EINVAL;
8003c84: 34 01 00 16 mvi r1,22
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
8003c88: 5c 60 00 04 bne r3,r0,8003c98 <pthread_once+0x3c>
return EINVAL;
if ( !once_control->init_executed ) {
8003c8c: 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;
8003c90: 34 01 00 00 mvi r1,0
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
8003c94: 45 a3 00 07 be r13,r3,8003cb0 <pthread_once+0x54>
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
8003c98: 2b 9d 00 04 lw ra,(sp+4)
8003c9c: 2b 8b 00 10 lw r11,(sp+16)
8003ca0: 2b 8c 00 0c lw r12,(sp+12)
8003ca4: 2b 8d 00 08 lw r13,(sp+8)
8003ca8: 37 9c 00 14 addi sp,sp,20
8003cac: 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);
8003cb0: 34 01 01 00 mvi r1,256
8003cb4: 34 02 01 00 mvi r2,256
8003cb8: 37 83 00 14 addi r3,sp,20
8003cbc: f8 00 01 ab calli 8004368 <rtems_task_mode>
if ( !once_control->init_executed ) {
8003cc0: 29 61 00 04 lw r1,(r11+4)
8003cc4: 44 2d 00 0c be r1,r13,8003cf4 <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);
8003cc8: 2b 81 00 14 lw r1,(sp+20)
8003ccc: 34 02 01 00 mvi r2,256
8003cd0: 37 83 00 14 addi r3,sp,20
8003cd4: f8 00 01 a5 calli 8004368 <rtems_task_mode>
}
return 0;
8003cd8: 34 01 00 00 mvi r1,0
}
8003cdc: 2b 9d 00 04 lw ra,(sp+4)
8003ce0: 2b 8b 00 10 lw r11,(sp+16)
8003ce4: 2b 8c 00 0c lw r12,(sp+12)
8003ce8: 2b 8d 00 08 lw r13,(sp+8)
8003cec: 37 9c 00 14 addi sp,sp,20
8003cf0: 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;
8003cf4: 34 01 00 01 mvi r1,1
8003cf8: 59 61 00 00 sw (r11+0),r1
once_control->init_executed = true;
8003cfc: 59 61 00 04 sw (r11+4),r1
(*init_routine)();
8003d00: d9 80 00 00 call r12
8003d04: e3 ff ff f1 bi 8003cc8 <pthread_once+0x6c>
0800452c <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
800452c: 37 9c ff e0 addi sp,sp,-32
8004530: 5b 8b 00 14 sw (sp+20),r11
8004534: 5b 8c 00 10 sw (sp+16),r12
8004538: 5b 8d 00 0c sw (sp+12),r13
800453c: 5b 8e 00 08 sw (sp+8),r14
8004540: 5b 9d 00 04 sw (sp+4),ra
8004544: b8 20 58 00 mv r11,r1
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
8004548: 34 01 00 16 mvi r1,22
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
800454c: 45 60 00 07 be r11,r0,8004568 <pthread_rwlock_init+0x3c>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
8004550: 44 40 00 31 be r2,r0,8004614 <pthread_rwlock_init+0xe8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
8004554: 28 43 00 00 lw r3,(r2+0)
return EINVAL;
8004558: 34 01 00 16 mvi r1,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
800455c: 44 60 00 03 be r3,r0,8004568 <pthread_rwlock_init+0x3c> <== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
8004560: 28 4e 00 04 lw r14,(r2+4)
8004564: 45 c0 00 08 be r14,r0,8004584 <pthread_rwlock_init+0x58> <== ALWAYS TAKEN
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
8004568: 2b 9d 00 04 lw ra,(sp+4)
800456c: 2b 8b 00 14 lw r11,(sp+20)
8004570: 2b 8c 00 10 lw r12,(sp+16)
8004574: 2b 8d 00 0c lw r13,(sp+12)
8004578: 2b 8e 00 08 lw r14,(sp+8)
800457c: 37 9c 00 20 addi sp,sp,32
8004580: c3 a0 00 00 ret
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8004584: 78 01 08 01 mvhi r1,0x801
8004588: 38 21 98 78 ori r1,r1,0x9878
800458c: 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;
8004590: 5b 80 00 20 sw (sp+32),r0
8004594: 34 42 00 01 addi r2,r2,1
8004598: 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 );
800459c: 78 0d 08 01 mvhi r13,0x801
80045a0: 39 ad 9a 0c ori r13,r13,0x9a0c
80045a4: b9 a0 08 00 mv r1,r13
80045a8: f8 00 0a 14 calli 8006df8 <_Objects_Allocate>
80045ac: b8 20 60 00 mv r12,r1
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
80045b0: 44 2e 00 16 be r1,r14,8004608 <pthread_rwlock_init+0xdc>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
80045b4: 37 82 00 20 addi r2,sp,32
80045b8: 34 21 00 10 addi r1,r1,16
80045bc: f8 00 07 29 calli 8006260 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
80045c0: 29 82 00 08 lw r2,(r12+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80045c4: 29 a3 00 1c lw r3,(r13+28)
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
80045c8: 20 41 ff ff andi r1,r2,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80045cc: b4 21 08 00 add r1,r1,r1
80045d0: b4 21 08 00 add r1,r1,r1
80045d4: b4 61 08 00 add r1,r3,r1
80045d8: 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;
80045dc: 59 80 00 0c sw (r12+12),r0
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
80045e0: 59 62 00 00 sw (r11+0),r2
_Thread_Enable_dispatch();
80045e4: f8 00 0e 8f calli 8008020 <_Thread_Enable_dispatch>
return 0;
80045e8: 34 01 00 00 mvi r1,0
}
80045ec: 2b 9d 00 04 lw ra,(sp+4)
80045f0: 2b 8b 00 14 lw r11,(sp+20)
80045f4: 2b 8c 00 10 lw r12,(sp+16)
80045f8: 2b 8d 00 0c lw r13,(sp+12)
80045fc: 2b 8e 00 08 lw r14,(sp+8)
8004600: 37 9c 00 20 addi sp,sp,32
8004604: c3 a0 00 00 ret
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
8004608: f8 00 0e 86 calli 8008020 <_Thread_Enable_dispatch>
return EAGAIN;
800460c: 34 01 00 0b mvi r1,11
8004610: e3 ff ff d6 bi 8004568 <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 );
8004614: 37 8c 00 18 addi r12,sp,24
8004618: b9 80 08 00 mv r1,r12
800461c: f8 00 02 ee calli 80051d4 <pthread_rwlockattr_init>
the_attr = &default_attr;
8004620: b9 80 10 00 mv r2,r12
8004624: e3 ff ff cc bi 8004554 <pthread_rwlock_init+0x28>
080046ac <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
80046ac: 37 9c ff e0 addi sp,sp,-32
80046b0: 5b 8b 00 18 sw (sp+24),r11
80046b4: 5b 8c 00 14 sw (sp+20),r12
80046b8: 5b 8d 00 10 sw (sp+16),r13
80046bc: 5b 8e 00 0c sw (sp+12),r14
80046c0: 5b 8f 00 08 sw (sp+8),r15
80046c4: 5b 9d 00 04 sw (sp+4),ra
80046c8: 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;
80046cc: 34 0c 00 16 mvi r12,22
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
80046d0: 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 )
80046d4: 45 60 00 0c be r11,r0,8004704 <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 );
80046d8: 37 82 00 1c addi r2,sp,28
80046dc: f8 00 1c ef calli 800ba98 <_POSIX_Absolute_timeout_to_ticks>
80046e0: 78 03 08 01 mvhi r3,0x801
80046e4: 29 62 00 00 lw r2,(r11+0)
80046e8: b8 20 70 00 mv r14,r1
80046ec: b8 60 08 00 mv r1,r3
80046f0: 38 21 9a 0c ori r1,r1,0x9a0c
80046f4: 37 83 00 20 addi r3,sp,32
80046f8: f8 00 0b 12 calli 8007340 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
80046fc: 2b 8d 00 20 lw r13,(sp+32)
8004700: 45 a0 00 0a be r13,r0,8004728 <pthread_rwlock_timedrdlock+0x7c>
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
8004704: b9 80 08 00 mv r1,r12
8004708: 2b 9d 00 04 lw ra,(sp+4)
800470c: 2b 8b 00 18 lw r11,(sp+24)
8004710: 2b 8c 00 14 lw r12,(sp+20)
8004714: 2b 8d 00 10 lw r13,(sp+16)
8004718: 2b 8e 00 0c lw r14,(sp+12)
800471c: 2b 8f 00 08 lw r15,(sp+8)
8004720: 37 9c 00 20 addi sp,sp,32
8004724: 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,
8004728: 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(
800472c: 29 62 00 00 lw r2,(r11+0)
8004730: 2b 84 00 1c lw r4,(sp+28)
8004734: 34 21 00 10 addi r1,r1,16
8004738: b9 e0 18 00 mv r3,r15
800473c: 34 05 00 00 mvi r5,0
8004740: f8 00 06 d5 calli 8006294 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
8004744: f8 00 0e 37 calli 8008020 <_Thread_Enable_dispatch>
if ( !do_wait ) {
8004748: 5d ed 00 10 bne r15,r13,8004788 <pthread_rwlock_timedrdlock+0xdc>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
800474c: 78 01 08 01 mvhi r1,0x801
8004750: 38 21 9d 44 ori r1,r1,0x9d44
8004754: 28 21 00 0c lw r1,(r1+12)
8004758: 34 02 00 02 mvi r2,2
800475c: 28 21 00 34 lw r1,(r1+52)
8004760: 44 22 00 04 be r1,r2,8004770 <pthread_rwlock_timedrdlock+0xc4>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
8004764: f8 00 00 4a calli 800488c <_POSIX_RWLock_Translate_core_RWLock_return_code>
8004768: b8 20 60 00 mv r12,r1
800476c: e3 ff ff e6 bi 8004704 <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 )
8004770: 45 cf ff e5 be r14,r15,8004704 <pthread_rwlock_timedrdlock+0x58><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
8004774: 35 ce ff ff addi r14,r14,-1
8004778: 34 02 00 01 mvi r2,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
800477c: 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 ||
8004780: 50 4e ff e1 bgeu r2,r14,8004704 <pthread_rwlock_timedrdlock+0x58><== ALWAYS TAKEN
8004784: e3 ff ff f8 bi 8004764 <pthread_rwlock_timedrdlock+0xb8> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
8004788: 78 01 08 01 mvhi r1,0x801
800478c: 38 21 9d 44 ori r1,r1,0x9d44
8004790: 28 21 00 0c lw r1,(r1+12)
8004794: 28 21 00 34 lw r1,(r1+52)
8004798: e3 ff ff f3 bi 8004764 <pthread_rwlock_timedrdlock+0xb8>
0800479c <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
800479c: 37 9c ff e0 addi sp,sp,-32
80047a0: 5b 8b 00 18 sw (sp+24),r11
80047a4: 5b 8c 00 14 sw (sp+20),r12
80047a8: 5b 8d 00 10 sw (sp+16),r13
80047ac: 5b 8e 00 0c sw (sp+12),r14
80047b0: 5b 8f 00 08 sw (sp+8),r15
80047b4: 5b 9d 00 04 sw (sp+4),ra
80047b8: 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;
80047bc: 34 0c 00 16 mvi r12,22
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
80047c0: 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 )
80047c4: 45 60 00 0c be r11,r0,80047f4 <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 );
80047c8: 37 82 00 1c addi r2,sp,28
80047cc: f8 00 1c b3 calli 800ba98 <_POSIX_Absolute_timeout_to_ticks>
80047d0: 78 03 08 01 mvhi r3,0x801
80047d4: 29 62 00 00 lw r2,(r11+0)
80047d8: b8 20 70 00 mv r14,r1
80047dc: b8 60 08 00 mv r1,r3
80047e0: 38 21 9a 0c ori r1,r1,0x9a0c
80047e4: 37 83 00 20 addi r3,sp,32
80047e8: f8 00 0a d6 calli 8007340 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
80047ec: 2b 8d 00 20 lw r13,(sp+32)
80047f0: 45 a0 00 0a be r13,r0,8004818 <pthread_rwlock_timedwrlock+0x7c>
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
80047f4: b9 80 08 00 mv r1,r12
80047f8: 2b 9d 00 04 lw ra,(sp+4)
80047fc: 2b 8b 00 18 lw r11,(sp+24)
8004800: 2b 8c 00 14 lw r12,(sp+20)
8004804: 2b 8d 00 10 lw r13,(sp+16)
8004808: 2b 8e 00 0c lw r14,(sp+12)
800480c: 2b 8f 00 08 lw r15,(sp+8)
8004810: 37 9c 00 20 addi sp,sp,32
8004814: 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,
8004818: 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(
800481c: 29 62 00 00 lw r2,(r11+0)
8004820: 2b 84 00 1c lw r4,(sp+28)
8004824: 34 21 00 10 addi r1,r1,16
8004828: b9 e0 18 00 mv r3,r15
800482c: 34 05 00 00 mvi r5,0
8004830: f8 00 06 e5 calli 80063c4 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
8004834: f8 00 0d fb calli 8008020 <_Thread_Enable_dispatch>
if ( !do_wait &&
8004838: 5d ed 00 10 bne r15,r13,8004878 <pthread_rwlock_timedwrlock+0xdc>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
800483c: 78 01 08 01 mvhi r1,0x801
8004840: 38 21 9d 44 ori r1,r1,0x9d44
8004844: 28 21 00 0c lw r1,(r1+12)
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
8004848: 34 02 00 02 mvi r2,2
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
800484c: 28 21 00 34 lw r1,(r1+52)
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
8004850: 44 22 00 04 be r1,r2,8004860 <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(
8004854: f8 00 00 0e calli 800488c <_POSIX_RWLock_Translate_core_RWLock_return_code>
8004858: b8 20 60 00 mv r12,r1
800485c: e3 ff ff e6 bi 80047f4 <pthread_rwlock_timedwrlock+0x58>
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
8004860: 45 cf ff e5 be r14,r15,80047f4 <pthread_rwlock_timedwrlock+0x58><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
8004864: 35 ce ff ff addi r14,r14,-1
8004868: 34 02 00 01 mvi r2,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
800486c: 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 ||
8004870: 50 4e ff e1 bgeu r2,r14,80047f4 <pthread_rwlock_timedwrlock+0x58><== ALWAYS TAKEN
8004874: e3 ff ff f8 bi 8004854 <pthread_rwlock_timedwrlock+0xb8> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
8004878: 78 01 08 01 mvhi r1,0x801
800487c: 38 21 9d 44 ori r1,r1,0x9d44
8004880: 28 21 00 0c lw r1,(r1+12)
8004884: 28 21 00 34 lw r1,(r1+52)
8004888: e3 ff ff f3 bi 8004854 <pthread_rwlock_timedwrlock+0xb8>
080051f4 <pthread_rwlockattr_setpshared>:
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
return EINVAL;
80051f4: 34 03 00 16 mvi r3,22
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
80051f8: 44 20 00 07 be r1,r0,8005214 <pthread_rwlockattr_setpshared+0x20>
return EINVAL;
if ( !attr->is_initialized )
80051fc: 28 24 00 00 lw r4,(r1+0)
8005200: 44 80 00 05 be r4,r0,8005214 <pthread_rwlockattr_setpshared+0x20>
return EINVAL;
switch ( pshared ) {
8005204: 34 04 00 01 mvi r4,1
8005208: 54 44 00 03 bgu r2,r4,8005214 <pthread_rwlockattr_setpshared+0x20><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
800520c: 58 22 00 04 sw (r1+4),r2
return 0;
8005210: 34 03 00 00 mvi r3,0
default:
return EINVAL;
}
}
8005214: b8 60 08 00 mv r1,r3
8005218: c3 a0 00 00 ret
080064dc <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
80064dc: 37 9c ff dc addi sp,sp,-36
80064e0: 5b 8b 00 18 sw (sp+24),r11
80064e4: 5b 8c 00 14 sw (sp+20),r12
80064e8: 5b 8d 00 10 sw (sp+16),r13
80064ec: 5b 8e 00 0c sw (sp+12),r14
80064f0: 5b 8f 00 08 sw (sp+8),r15
80064f4: 5b 9d 00 04 sw (sp+4),ra
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
80064f8: 34 0c 00 16 mvi r12,22
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
80064fc: b8 60 58 00 mv r11,r3
8006500: b8 20 68 00 mv r13,r1
8006504: b8 40 70 00 mv r14,r2
int rc;
/*
* Check all the parameters
*/
if ( !param )
8006508: 44 60 00 08 be r3,r0,8006528 <pthread_setschedparam+0x4c>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
800650c: b8 40 08 00 mv r1,r2
8006510: 37 84 00 20 addi r4,sp,32
8006514: b8 60 10 00 mv r2,r3
8006518: 37 83 00 24 addi r3,sp,36
800651c: f8 00 1a 89 calli 800cf40 <_POSIX_Thread_Translate_sched_param>
8006520: b8 20 60 00 mv r12,r1
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
8006524: 44 20 00 0a be r1,r0,800654c <pthread_setschedparam+0x70>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
8006528: b9 80 08 00 mv r1,r12
800652c: 2b 9d 00 04 lw ra,(sp+4)
8006530: 2b 8b 00 18 lw r11,(sp+24)
8006534: 2b 8c 00 14 lw r12,(sp+20)
8006538: 2b 8d 00 10 lw r13,(sp+16)
800653c: 2b 8e 00 0c lw r14,(sp+12)
8006540: 2b 8f 00 08 lw r15,(sp+8)
8006544: 37 9c 00 24 addi sp,sp,36
8006548: c3 a0 00 00 ret
800654c: 78 01 08 01 mvhi r1,0x801
8006550: 38 21 aa 9c ori r1,r1,0xaa9c
8006554: b9 a0 10 00 mv r2,r13
8006558: 37 83 00 1c addi r3,sp,28
800655c: f8 00 07 be calli 8008454 <_Objects_Get>
8006560: b8 20 78 00 mv r15,r1
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
switch ( location ) {
8006564: 2b 81 00 1c lw r1,(sp+28)
8006568: 44 2c 00 03 be r1,r12,8006574 <pthread_setschedparam+0x98>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
800656c: 34 0c 00 03 mvi r12,3
8006570: e3 ff ff ee bi 8006528 <pthread_setschedparam+0x4c>
*/
the_thread = _POSIX_Threads_Get( thread, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8006574: 29 ed 01 20 lw r13,(r15+288)
if ( api->schedpolicy == SCHED_SPORADIC )
8006578: 34 01 00 04 mvi r1,4
800657c: 29 a2 00 84 lw r2,(r13+132)
8006580: 44 41 00 31 be r2,r1,8006644 <pthread_setschedparam+0x168>
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
8006584: 59 ae 00 84 sw (r13+132),r14
api->schedparam = *param;
8006588: 29 62 00 00 lw r2,(r11+0)
800658c: 59 a2 00 88 sw (r13+136),r2
8006590: 29 61 00 04 lw r1,(r11+4)
8006594: 59 a1 00 8c sw (r13+140),r1
8006598: 29 61 00 08 lw r1,(r11+8)
800659c: 59 a1 00 90 sw (r13+144),r1
80065a0: 29 61 00 0c lw r1,(r11+12)
80065a4: 59 a1 00 94 sw (r13+148),r1
80065a8: 29 61 00 10 lw r1,(r11+16)
80065ac: 59 a1 00 98 sw (r13+152),r1
80065b0: 29 61 00 14 lw r1,(r11+20)
80065b4: 59 a1 00 9c sw (r13+156),r1
80065b8: 29 61 00 18 lw r1,(r11+24)
80065bc: 59 a1 00 a0 sw (r13+160),r1
the_thread->budget_algorithm = budget_algorithm;
80065c0: 2b 81 00 24 lw r1,(sp+36)
80065c4: 59 e1 00 7c sw (r15+124),r1
the_thread->budget_callout = budget_callout;
80065c8: 2b 81 00 20 lw r1,(sp+32)
80065cc: 59 e1 00 80 sw (r15+128),r1
switch ( api->schedpolicy ) {
80065d0: 48 0e 00 05 bg r0,r14,80065e4 <pthread_setschedparam+0x108><== NEVER TAKEN
80065d4: 34 01 00 02 mvi r1,2
80065d8: 4c 2e 00 0d bge r1,r14,800660c <pthread_setschedparam+0x130>
80065dc: 34 01 00 04 mvi r1,4
80065e0: 45 c1 00 03 be r14,r1,80065ec <pthread_setschedparam+0x110><== ALWAYS TAKEN
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
80065e4: f8 00 0b 0c calli 8009214 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
80065e8: e3 ff ff d0 bi 8006528 <pthread_setschedparam+0x4c> <== NOT EXECUTED
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
80065ec: 59 a2 00 a4 sw (r13+164),r2
_Watchdog_Remove( &api->Sporadic_timer );
80065f0: 35 a1 00 a8 addi r1,r13,168
80065f4: f8 00 10 78 calli 800a7d4 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
80065f8: 34 01 00 00 mvi r1,0
80065fc: b9 e0 10 00 mv r2,r15
8006600: fb ff ff 66 calli 8006398 <_POSIX_Threads_Sporadic_budget_TSR>
break;
}
_Thread_Enable_dispatch();
8006604: f8 00 0b 04 calli 8009214 <_Thread_Enable_dispatch>
8006608: e3 ff ff c8 bi 8006528 <pthread_setschedparam+0x4c>
800660c: 78 03 08 01 mvhi r3,0x801
8006610: 38 63 a0 e4 ori r3,r3,0xa0e4
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
8006614: 78 01 08 01 mvhi r1,0x801
8006618: 38 21 a8 60 ori r1,r1,0xa860
800661c: 40 63 00 00 lbu r3,(r3+0)
8006620: 28 24 00 00 lw r4,(r1+0)
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
8006624: b9 e0 08 00 mv r1,r15
8006628: 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;
800662c: 59 e4 00 78 sw (r15+120),r4
the_thread->real_priority =
8006630: 59 e2 00 18 sw (r15+24),r2
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
8006634: 34 03 00 01 mvi r3,1
8006638: f8 00 09 98 calli 8008c98 <_Thread_Change_priority>
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
800663c: f8 00 0a f6 calli 8009214 <_Thread_Enable_dispatch>
8006640: e3 ff ff ba bi 8006528 <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 );
8006644: 35 a1 00 a8 addi r1,r13,168
8006648: f8 00 10 63 calli 800a7d4 <_Watchdog_Remove>
800664c: e3 ff ff ce bi 8006584 <pthread_setschedparam+0xa8>
08003934 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
8003934: 37 9c ff f8 addi sp,sp,-8
8003938: 5b 8b 00 08 sw (sp+8),r11
800393c: 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() )
8003940: 78 0b 08 01 mvhi r11,0x801
8003944: 39 6b 6d 1c ori r11,r11,0x6d1c
8003948: 29 62 00 08 lw r2,(r11+8)
800394c: 5c 40 00 10 bne r2,r0,800398c <pthread_testcancel+0x58> <== NEVER TAKEN
8003950: 78 01 08 01 mvhi r1,0x801
8003954: 38 21 68 50 ori r1,r1,0x6850
8003958: 28 24 00 00 lw r4,(r1+0)
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
800395c: 29 63 00 0c lw r3,(r11+12)
8003960: 34 84 00 01 addi r4,r4,1
8003964: 28 63 01 20 lw r3,(r3+288)
8003968: 58 24 00 00 sw (r1+0),r4
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
800396c: 28 61 00 d8 lw r1,(r3+216)
8003970: 5c 22 00 0b bne r1,r2,800399c <pthread_testcancel+0x68> <== NEVER TAKEN
8003974: 28 62 00 e0 lw r2,(r3+224)
8003978: 44 41 00 09 be r2,r1,800399c <pthread_testcancel+0x68>
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
800397c: f8 00 0a 35 calli 8006250 <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
8003980: 29 61 00 0c lw r1,(r11+12)
8003984: 34 02 ff ff mvi r2,-1
8003988: f8 00 19 a2 calli 800a010 <_POSIX_Thread_Exit>
}
800398c: 2b 9d 00 04 lw ra,(sp+4)
8003990: 2b 8b 00 08 lw r11,(sp+8)
8003994: 37 9c 00 08 addi sp,sp,8
8003998: c3 a0 00 00 ret
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
800399c: f8 00 0a 2d calli 8006250 <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
}
80039a0: 2b 9d 00 04 lw ra,(sp+4)
80039a4: 2b 8b 00 08 lw r11,(sp+8)
80039a8: 37 9c 00 08 addi sp,sp,8
80039ac: c3 a0 00 00 ret
08004640 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
8004640: 37 9c ff c4 addi sp,sp,-60
8004644: 5b 8b 00 18 sw (sp+24),r11
8004648: 5b 8c 00 14 sw (sp+20),r12
800464c: 5b 8d 00 10 sw (sp+16),r13
8004650: 5b 8e 00 0c sw (sp+12),r14
8004654: 5b 8f 00 08 sw (sp+8),r15
8004658: 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);
800465c: 78 0b 08 01 mvhi r11,0x801
8004660: 39 6b 88 08 ori r11,r11,0x8808
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
8004664: 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);
8004668: b9 60 08 00 mv r1,r11
800466c: f8 00 02 c7 calli 8005188 <pthread_mutex_lock>
8004670: b8 20 68 00 mv r13,r1
if (result != 0) {
8004674: 5c 20 00 52 bne r1,r0,80047bc <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);
8004678: f8 00 05 af calli 8005d34 <pthread_self>
800467c: 37 82 00 38 addi r2,sp,56
8004680: 37 83 00 1c addi r3,sp,28
8004684: f8 00 04 58 calli 80057e4 <pthread_getschedparam>
req->caller_thread = pthread_self ();
8004688: f8 00 05 ab calli 8005d34 <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
800468c: 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) &&
8004690: 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;
8004694: 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 ();
8004698: 59 81 00 10 sw (r12+16),r1
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
800469c: 2b 81 00 1c lw r1,(sp+28)
80046a0: c8 24 08 00 sub r1,r1,r4
80046a4: 59 81 00 0c sw (r12+12),r1
req->policy = policy;
80046a8: 2b 81 00 38 lw r1,(sp+56)
80046ac: 59 81 00 08 sw (r12+8),r1
req->aiocbp->error_code = EINPROGRESS;
80046b0: 34 01 00 77 mvi r1,119
80046b4: 58 41 00 2c sw (r2+44),r1
req->aiocbp->return_value = 0;
80046b8: 58 40 00 30 sw (r2+48),r0
if ((aio_request_queue.idle_threads == 0) &&
80046bc: 5c 6d 00 24 bne r3,r13,800474c <rtems_aio_enqueue+0x10c>
80046c0: 29 63 00 64 lw r3,(r11+100)
80046c4: 34 01 00 04 mvi r1,4
80046c8: 48 61 00 21 bg r3,r1,800474c <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);
80046cc: 28 42 00 00 lw r2,(r2+0)
80046d0: 78 01 08 01 mvhi r1,0x801
80046d4: 38 21 88 50 ori r1,r1,0x8850
80046d8: 34 03 00 01 mvi r3,1
80046dc: fb ff fe 8f calli 8004118 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
80046e0: 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);
80046e4: b8 20 70 00 mv r14,r1
if (r_chain->new_fd == 1) {
80046e8: 34 01 00 01 mvi r1,1
80046ec: 5c 41 00 1f bne r2,r1,8004768 <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);
80046f0: b9 80 10 00 mv r2,r12
80046f4: 35 c1 00 08 addi r1,r14,8
80046f8: f8 00 09 05 calli 8006b0c <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
80046fc: 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;
8004700: 59 c0 00 18 sw (r14+24),r0
pthread_mutex_init (&r_chain->mutex, NULL);
8004704: 35 c1 00 1c addi r1,r14,28
8004708: f8 00 02 3f calli 8005004 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
800470c: 34 02 00 00 mvi r2,0
8004710: 35 c1 00 20 addi r1,r14,32
8004714: f8 00 01 04 calli 8004b24 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
8004718: 78 02 08 01 mvhi r2,0x801
800471c: 78 03 08 00 mvhi r3,0x800
8004720: 37 81 00 3c addi r1,sp,60
8004724: 38 42 88 10 ori r2,r2,0x8810
8004728: 38 63 41 f8 ori r3,r3,0x41f8
800472c: b9 c0 20 00 mv r4,r14
8004730: f8 00 03 56 calli 8005488 <pthread_create>
8004734: b8 20 60 00 mv r12,r1
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
8004738: 5c 20 00 43 bne r1,r0,8004844 <rtems_aio_enqueue+0x204> <== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
800473c: 29 61 00 64 lw r1,(r11+100)
8004740: 34 21 00 01 addi r1,r1,1
8004744: 59 61 00 64 sw (r11+100),r1
8004748: e0 00 00 12 bi 8004790 <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,
800474c: 28 42 00 00 lw r2,(r2+0)
8004750: 78 01 08 01 mvhi r1,0x801
8004754: 38 21 88 50 ori r1,r1,0x8850
8004758: 34 03 00 00 mvi r3,0
800475c: fb ff fe 6f calli 8004118 <rtems_aio_search_fd>
8004760: b8 20 70 00 mv r14,r1
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
8004764: 44 20 00 19 be r1,r0,80047c8 <rtems_aio_enqueue+0x188>
{
pthread_mutex_lock (&r_chain->mutex);
8004768: 35 cf 00 1c addi r15,r14,28
800476c: b9 e0 08 00 mv r1,r15
8004770: f8 00 02 86 calli 8005188 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
8004774: 35 c1 00 08 addi r1,r14,8
8004778: b9 80 10 00 mv r2,r12
800477c: fb ff ff 56 calli 80044d4 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
8004780: 35 c1 00 20 addi r1,r14,32
8004784: f8 00 01 29 calli 8004c28 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
8004788: b9 e0 08 00 mv r1,r15
800478c: f8 00 02 af calli 8005248 <pthread_mutex_unlock>
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
8004790: b9 60 08 00 mv r1,r11
8004794: f8 00 02 ad calli 8005248 <pthread_mutex_unlock>
return 0;
}
8004798: b9 a0 08 00 mv r1,r13
800479c: 2b 9d 00 04 lw ra,(sp+4)
80047a0: 2b 8b 00 18 lw r11,(sp+24)
80047a4: 2b 8c 00 14 lw r12,(sp+20)
80047a8: 2b 8d 00 10 lw r13,(sp+16)
80047ac: 2b 8e 00 0c lw r14,(sp+12)
80047b0: 2b 8f 00 08 lw r15,(sp+8)
80047b4: 37 9c 00 3c addi sp,sp,60
80047b8: 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);
80047bc: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
80047c0: fb ff f6 da calli 8002328 <free> <== NOT EXECUTED
return result;
80047c4: e3 ff ff f5 bi 8004798 <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);
80047c8: 29 82 00 14 lw r2,(r12+20)
80047cc: 78 01 08 01 mvhi r1,0x801
80047d0: 38 21 88 5c ori r1,r1,0x885c
80047d4: 28 42 00 00 lw r2,(r2+0)
80047d8: 34 03 00 01 mvi r3,1
80047dc: fb ff fe 4f calli 8004118 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
80047e0: 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);
80047e4: b8 20 70 00 mv r14,r1
if (r_chain->new_fd == 1) {
80047e8: 34 01 00 01 mvi r1,1
80047ec: 44 41 00 05 be r2,r1,8004800 <rtems_aio_enqueue+0x1c0>
pthread_cond_init (&r_chain->cond, NULL);
pthread_cond_signal (&aio_request_queue.new_req);
++aio_request_queue.idle_threads;
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
80047f0: 35 c1 00 08 addi r1,r14,8
80047f4: b9 80 10 00 mv r2,r12
80047f8: fb ff ff 37 calli 80044d4 <rtems_aio_insert_prio>
80047fc: e3 ff ff e5 bi 8004790 <rtems_aio_enqueue+0x150>
8004800: 35 c1 00 08 addi r1,r14,8
8004804: b9 80 10 00 mv r2,r12
8004808: f8 00 08 c1 calli 8006b0c <_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);
800480c: 34 02 00 00 mvi r2,0
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;
8004810: 59 c0 00 18 sw (r14+24),r0
pthread_mutex_init (&r_chain->mutex, NULL);
8004814: 35 c1 00 1c addi r1,r14,28
8004818: f8 00 01 fb calli 8005004 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
800481c: 34 02 00 00 mvi r2,0
8004820: 35 c1 00 20 addi r1,r14,32
8004824: f8 00 00 c0 calli 8004b24 <pthread_cond_init>
pthread_cond_signal (&aio_request_queue.new_req);
8004828: 78 01 08 01 mvhi r1,0x801
800482c: 38 21 88 0c ori r1,r1,0x880c
8004830: f8 00 00 fe calli 8004c28 <pthread_cond_signal>
++aio_request_queue.idle_threads;
8004834: 29 61 00 68 lw r1,(r11+104)
8004838: 34 21 00 01 addi r1,r1,1
800483c: 59 61 00 68 sw (r11+104),r1
8004840: e3 ff ff d4 bi 8004790 <rtems_aio_enqueue+0x150>
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);
8004844: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8004848: f8 00 02 80 calli 8005248 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
800484c: b9 80 68 00 mv r13,r12 <== NOT EXECUTED
8004850: e3 ff ff d2 bi 8004798 <rtems_aio_enqueue+0x158> <== NOT EXECUTED
080041f8 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
80041f8: 37 9c ff 9c addi sp,sp,-100 <== NOT EXECUTED
80041fc: 5b 8b 00 3c sw (sp+60),r11 <== NOT EXECUTED
8004200: 5b 8c 00 38 sw (sp+56),r12 <== NOT EXECUTED
8004204: 5b 8d 00 34 sw (sp+52),r13 <== NOT EXECUTED
8004208: 5b 8e 00 30 sw (sp+48),r14 <== NOT EXECUTED
800420c: 5b 8f 00 2c sw (sp+44),r15 <== NOT EXECUTED
8004210: 5b 90 00 28 sw (sp+40),r16 <== NOT EXECUTED
8004214: 5b 91 00 24 sw (sp+36),r17 <== NOT EXECUTED
8004218: 5b 92 00 20 sw (sp+32),r18 <== NOT EXECUTED
800421c: 5b 93 00 1c sw (sp+28),r19 <== NOT EXECUTED
8004220: 5b 94 00 18 sw (sp+24),r20 <== NOT EXECUTED
8004224: 5b 95 00 14 sw (sp+20),r21 <== NOT EXECUTED
8004228: 5b 96 00 10 sw (sp+16),r22 <== NOT EXECUTED
800422c: 5b 97 00 0c sw (sp+12),r23 <== NOT EXECUTED
8004230: 5b 98 00 08 sw (sp+8),r24 <== NOT EXECUTED
8004234: 5b 9d 00 04 sw (sp+4),ra <== NOT EXECUTED
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
8004238: 78 13 08 01 mvhi r19,0x801 <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
800423c: 78 16 08 01 mvhi r22,0x801 <== NOT EXECUTED
++aio_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004240: 78 15 08 01 mvhi r21,0x801 <== NOT EXECUTED
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
8004244: 78 14 08 01 mvhi r20,0x801 <== NOT EXECUTED
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
8004248: b8 20 68 00 mv r13,r1 <== NOT EXECUTED
800424c: 34 2e 00 1c addi r14,r1,28 <== NOT EXECUTED
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
8004250: 3a 73 88 08 ori r19,r19,0x8808 <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
8004254: 37 97 00 5c addi r23,sp,92 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
&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) {
8004258: 34 18 00 74 mvi r24,116 <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
800425c: 3a d6 88 60 ori r22,r22,0x8860 <== NOT EXECUTED
++aio_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004260: 3a b5 88 0c ori r21,r21,0x880c <== NOT EXECUTED
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
8004264: 3a 94 88 50 ori r20,r20,0x8850 <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
8004268: 37 8f 00 40 addi r15,sp,64 <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
800426c: 34 10 00 02 mvi r16,2 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
8004270: 34 11 ff ff mvi r17,-1 <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
8004274: 34 12 00 03 mvi r18,3 <== 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);
8004278: b9 c0 08 00 mv r1,r14 <== NOT EXECUTED
800427c: f8 00 03 c3 calli 8005188 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
8004280: 5c 20 00 1f bne r1,r0,80042fc <rtems_aio_handle+0x104> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004284: 29 ab 00 08 lw r11,(r13+8) <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
8004288: 35 a4 00 0c addi r4,r13,12 <== NOT EXECUTED
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
800428c: 45 64 00 44 be r11,r4,800439c <rtems_aio_handle+0x1a4> <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
8004290: f8 00 06 a9 calli 8005d34 <pthread_self> <== NOT EXECUTED
8004294: 37 82 00 64 addi r2,sp,100 <== NOT EXECUTED
8004298: b9 e0 18 00 mv r3,r15 <== NOT EXECUTED
800429c: f8 00 05 52 calli 80057e4 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
80042a0: 29 64 00 0c lw r4,(r11+12) <== NOT EXECUTED
80042a4: 5b 84 00 40 sw (sp+64),r4 <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
80042a8: f8 00 06 a3 calli 8005d34 <pthread_self> <== NOT EXECUTED
80042ac: 29 62 00 08 lw r2,(r11+8) <== NOT EXECUTED
80042b0: b9 e0 18 00 mv r3,r15 <== NOT EXECUTED
80042b4: f8 00 06 a5 calli 8005d48 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
80042b8: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
80042bc: f8 00 09 f9 calli 8006aa0 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
80042c0: b9 c0 08 00 mv r1,r14 <== NOT EXECUTED
80042c4: f8 00 03 e1 calli 8005248 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
80042c8: 29 6c 00 14 lw r12,(r11+20) <== NOT EXECUTED
80042cc: 29 84 00 28 lw r4,(r12+40) <== NOT EXECUTED
80042d0: 44 90 00 2c be r4,r16,8004380 <rtems_aio_handle+0x188> <== NOT EXECUTED
80042d4: 44 92 00 27 be r4,r18,8004370 <rtems_aio_handle+0x178> <== NOT EXECUTED
80042d8: 34 05 00 01 mvi r5,1 <== NOT EXECUTED
80042dc: 44 85 00 1a be r4,r5,8004344 <rtems_aio_handle+0x14c> <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
80042e0: 59 91 00 30 sw (r12+48),r17 <== NOT EXECUTED
req->aiocbp->error_code = errno;
80042e4: f8 00 2f 18 calli 800ff44 <__errno> <== NOT EXECUTED
80042e8: 28 21 00 00 lw r1,(r1+0) <== NOT EXECUTED
80042ec: 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);
80042f0: b9 c0 08 00 mv r1,r14 <== NOT EXECUTED
80042f4: f8 00 03 a5 calli 8005188 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
80042f8: 44 20 ff e3 be r1,r0,8004284 <rtems_aio_handle+0x8c> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
80042fc: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
8004300: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8004304: 2b 8b 00 3c lw r11,(sp+60) <== NOT EXECUTED
8004308: 2b 8c 00 38 lw r12,(sp+56) <== NOT EXECUTED
800430c: 2b 8d 00 34 lw r13,(sp+52) <== NOT EXECUTED
8004310: 2b 8e 00 30 lw r14,(sp+48) <== NOT EXECUTED
8004314: 2b 8f 00 2c lw r15,(sp+44) <== NOT EXECUTED
8004318: 2b 90 00 28 lw r16,(sp+40) <== NOT EXECUTED
800431c: 2b 91 00 24 lw r17,(sp+36) <== NOT EXECUTED
8004320: 2b 92 00 20 lw r18,(sp+32) <== NOT EXECUTED
8004324: 2b 93 00 1c lw r19,(sp+28) <== NOT EXECUTED
8004328: 2b 94 00 18 lw r20,(sp+24) <== NOT EXECUTED
800432c: 2b 95 00 14 lw r21,(sp+20) <== NOT EXECUTED
8004330: 2b 96 00 10 lw r22,(sp+16) <== NOT EXECUTED
8004334: 2b 97 00 0c lw r23,(sp+12) <== NOT EXECUTED
8004338: 2b 98 00 08 lw r24,(sp+8) <== NOT EXECUTED
800433c: 37 9c 00 64 addi sp,sp,100 <== NOT EXECUTED
8004340: c3 a0 00 00 ret <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
result = pread (req->aiocbp->aio_fildes,
8004344: 29 84 00 04 lw r4,(r12+4) <== NOT EXECUTED
8004348: 29 81 00 00 lw r1,(r12+0) <== NOT EXECUTED
800434c: 29 82 00 08 lw r2,(r12+8) <== NOT EXECUTED
8004350: 29 83 00 0c lw r3,(r12+12) <== NOT EXECUTED
8004354: f8 00 32 ab calli 8010e00 <pread> <== NOT EXECUTED
8004358: b8 20 20 00 mv r4,r1 <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
800435c: 44 91 00 59 be r4,r17,80044c0 <rtems_aio_handle+0x2c8> <== NOT EXECUTED
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
8004360: 29 65 00 14 lw r5,(r11+20) <== NOT EXECUTED
8004364: 58 a4 00 30 sw (r5+48),r4 <== NOT EXECUTED
req->aiocbp->error_code = 0;
8004368: 58 a0 00 2c sw (r5+44),r0 <== NOT EXECUTED
800436c: e3 ff ff c3 bi 8004278 <rtems_aio_handle+0x80> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
8004370: 29 81 00 00 lw r1,(r12+0) <== NOT EXECUTED
8004374: f8 00 1d f4 calli 800bb44 <fsync> <== NOT EXECUTED
8004378: b8 20 20 00 mv r4,r1 <== NOT EXECUTED
break;
800437c: e3 ff ff f8 bi 800435c <rtems_aio_handle+0x164> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
result = pwrite (req->aiocbp->aio_fildes,
8004380: 29 84 00 04 lw r4,(r12+4) <== NOT EXECUTED
8004384: 29 81 00 00 lw r1,(r12+0) <== NOT EXECUTED
8004388: 29 82 00 08 lw r2,(r12+8) <== NOT EXECUTED
800438c: 29 83 00 0c lw r3,(r12+12) <== NOT EXECUTED
8004390: f8 00 32 e0 calli 8010f10 <pwrite> <== NOT EXECUTED
8004394: b8 20 20 00 mv r4,r1 <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
8004398: e3 ff ff f1 bi 800435c <rtems_aio_handle+0x164> <== NOT EXECUTED
wait for a signal on chain, this will unlock the queue.
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
800439c: b9 c0 08 00 mv r1,r14 <== NOT EXECUTED
80043a0: f8 00 03 aa calli 8005248 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
80043a4: ba 60 08 00 mv r1,r19 <== NOT EXECUTED
80043a8: f8 00 03 78 calli 8005188 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
80043ac: 29 a1 00 08 lw r1,(r13+8) <== NOT EXECUTED
80043b0: 5d 61 ff b2 bne r11,r1,8004278 <rtems_aio_handle+0x80> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
80043b4: ba e0 10 00 mv r2,r23 <== NOT EXECUTED
80043b8: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
80043bc: f8 00 01 77 calli 8004998 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
80043c0: 2b 84 00 5c lw r4,(sp+92) <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
80043c4: 35 ab 00 20 addi r11,r13,32 <== NOT EXECUTED
80043c8: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
80043cc: 34 84 00 03 addi r4,r4,3 <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
80043d0: ba 60 10 00 mv r2,r19 <== NOT EXECUTED
80043d4: ba e0 18 00 mv r3,r23 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
80043d8: 5b 84 00 5c sw (sp+92),r4 <== NOT EXECUTED
timeout.tv_nsec = 0;
80043dc: 5b 80 00 60 sw (sp+96),r0 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
80043e0: f8 00 02 3b calli 8004ccc <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex, &timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
80043e4: 5c 38 ff a5 bne r1,r24,8004278 <rtems_aio_handle+0x80> <== NOT EXECUTED
80043e8: b9 a0 08 00 mv r1,r13 <== NOT EXECUTED
80043ec: f8 00 09 ad calli 8006aa0 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
80043f0: b9 c0 08 00 mv r1,r14 <== NOT EXECUTED
80043f4: f8 00 02 9d calli 8004e68 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
80043f8: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
80043fc: f8 00 01 8a calli 8004a24 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
8004400: b9 a0 08 00 mv r1,r13 <== NOT EXECUTED
8004404: fb ff f7 c9 calli 8002328 <free> <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
8004408: 2a 61 00 54 lw r1,(r19+84) <== NOT EXECUTED
800440c: 44 36 00 04 be r1,r22,800441c <rtems_aio_handle+0x224> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
}
else
/* 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);
8004410: ba 60 08 00 mv r1,r19 <== NOT EXECUTED
8004414: f8 00 03 8d calli 8005248 <pthread_mutex_unlock> <== NOT EXECUTED
8004418: e3 ff ff 98 bi 8004278 <rtems_aio_handle+0x80> <== NOT EXECUTED
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)) {
++aio_request_queue.idle_threads;
800441c: 2a 63 00 68 lw r3,(r19+104) <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
8004420: ba e0 10 00 mv r2,r23 <== NOT EXECUTED
8004424: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
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)) {
++aio_request_queue.idle_threads;
8004428: 34 63 00 01 addi r3,r3,1 <== NOT EXECUTED
800442c: 5a 63 00 68 sw (r19+104),r3 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
8004430: f8 00 01 5a calli 8004998 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
8004434: 2b 84 00 5c lw r4,(sp+92) <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004438: ba a0 08 00 mv r1,r21 <== NOT EXECUTED
800443c: ba 60 10 00 mv r2,r19 <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
++aio_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
8004440: 34 84 00 03 addi r4,r4,3 <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004444: ba e0 18 00 mv r3,r23 <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
++aio_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
8004448: 5b 84 00 5c sw (sp+92),r4 <== NOT EXECUTED
timeout.tv_nsec = 0;
800444c: 5b 80 00 60 sw (sp+96),r0 <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
8004450: f8 00 02 1f calli 8004ccc <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
8004454: 44 38 00 1d be r1,r24,80044c8 <rtems_aio_handle+0x2d0> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004458: 2a 6b 00 54 lw r11,(r19+84) <== NOT EXECUTED
return NULL;
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
800445c: 2a 62 00 68 lw r2,(r19+104) <== NOT EXECUTED
8004460: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8004464: 34 42 ff ff addi r2,r2,-1 <== NOT EXECUTED
8004468: 5a 62 00 68 sw (r19+104),r2 <== NOT EXECUTED
800446c: f8 00 09 8d calli 8006aa0 <_Chain_Extract> <== NOT EXECUTED
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
8004470: 29 62 00 14 lw r2,(r11+20) <== NOT EXECUTED
8004474: 34 03 00 01 mvi r3,1 <== NOT EXECUTED
8004478: ba 80 08 00 mv r1,r20 <== NOT EXECUTED
800447c: fb ff ff 27 calli 8004118 <rtems_aio_search_fd> <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes,
1);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
8004480: 34 2e 00 1c addi r14,r1,28 <== NOT EXECUTED
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
8004484: b8 20 68 00 mv r13,r1 <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes,
1);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
8004488: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
((rtems_aio_request_chain *)node)->fildes,
1);
r_chain->new_fd = 0;
800448c: 58 20 00 18 sw (r1+24),r0 <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
8004490: b9 c0 08 00 mv r1,r14 <== NOT EXECUTED
8004494: f8 00 02 dc calli 8005004 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
8004498: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
800449c: 35 a1 00 20 addi r1,r13,32 <== NOT EXECUTED
80044a0: f8 00 01 a1 calli 8004b24 <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
80044a4: 29 62 00 08 lw r2,(r11+8) <== NOT EXECUTED
80044a8: 29 61 00 0c lw r1,(r11+12) <== NOT EXECUTED
80044ac: 29 63 00 10 lw r3,(r11+16) <== NOT EXECUTED
80044b0: 59 a2 00 08 sw (r13+8),r2 <== NOT EXECUTED
80044b4: 59 a1 00 0c sw (r13+12),r1 <== NOT EXECUTED
80044b8: 59 a3 00 10 sw (r13+16),r3 <== NOT EXECUTED
80044bc: e3 ff ff 6f bi 8004278 <rtems_aio_handle+0x80> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
80044c0: 29 6c 00 14 lw r12,(r11+20) <== NOT EXECUTED
80044c4: e3 ff ff 87 bi 80042e0 <rtems_aio_handle+0xe8> <== NOT EXECUTED
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
pthread_mutex_unlock (&aio_request_queue.mutex);
80044c8: ba 60 08 00 mv r1,r19 <== NOT EXECUTED
80044cc: f8 00 03 5f calli 8005248 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
80044d0: e3 ff ff 8b bi 80042fc <rtems_aio_handle+0x104> <== NOT EXECUTED
08003fd8 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
8003fd8: 37 9c ff f0 addi sp,sp,-16
8003fdc: 5b 8b 00 10 sw (sp+16),r11
8003fe0: 5b 8c 00 0c sw (sp+12),r12
8003fe4: 5b 8d 00 08 sw (sp+8),r13
8003fe8: 5b 9d 00 04 sw (sp+4),ra
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
8003fec: 78 0c 08 01 mvhi r12,0x801
8003ff0: 39 8c 88 10 ori r12,r12,0x8810
8003ff4: b9 80 08 00 mv r1,r12
8003ff8: f8 00 04 e3 calli 8005384 <pthread_attr_init>
8003ffc: b8 20 68 00 mv r13,r1
if (result != 0)
8004000: 44 20 00 08 be r1,r0,8004020 <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;
}
8004004: b9 a0 08 00 mv r1,r13 <== NOT EXECUTED
8004008: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
800400c: 2b 8b 00 10 lw r11,(sp+16) <== NOT EXECUTED
8004010: 2b 8c 00 0c lw r12,(sp+12) <== NOT EXECUTED
8004014: 2b 8d 00 08 lw r13,(sp+8) <== NOT EXECUTED
8004018: 37 9c 00 10 addi sp,sp,16 <== NOT EXECUTED
800401c: c3 a0 00 00 ret <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
8004020: b9 80 08 00 mv r1,r12
8004024: 34 02 00 00 mvi r2,0
8004028: f8 00 05 0e calli 8005460 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
800402c: 5c 2d 00 26 bne r1,r13,80040c4 <rtems_aio_init+0xec> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
8004030: 78 0b 08 01 mvhi r11,0x801
8004034: 39 6b 88 08 ori r11,r11,0x8808
8004038: b9 60 08 00 mv r1,r11
800403c: 34 02 00 00 mvi r2,0
8004040: f8 00 03 f1 calli 8005004 <pthread_mutex_init>
if (result != 0)
8004044: 5c 20 00 28 bne r1,r0,80040e4 <rtems_aio_init+0x10c> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
8004048: 78 01 08 01 mvhi r1,0x801
800404c: 38 21 88 0c ori r1,r1,0x880c
8004050: 34 02 00 00 mvi r2,0
8004054: f8 00 02 b4 calli 8004b24 <pthread_cond_init>
8004058: b8 20 68 00 mv r13,r1
if (result != 0) {
800405c: 5c 20 00 2a bne r1,r0,8004104 <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;
8004060: 78 01 08 01 mvhi r1,0x801
8004064: 38 21 88 5c ori r1,r1,0x885c
8004068: 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;
800406c: 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;
8004070: 38 01 b0 0b mvu r1,0xb00b
head->previous = NULL;
tail->previous = head;
8004074: 78 03 08 01 mvhi r3,0x801
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8004078: 78 02 08 01 mvhi r2,0x801
800407c: 38 84 88 54 ori r4,r4,0x8854
head->previous = NULL;
tail->previous = head;
8004080: 38 63 88 50 ori r3,r3,0x8850
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
8004084: 38 42 88 60 ori r2,r2,0x8860
8004088: 59 61 00 60 sw (r11+96),r1
return result;
}
800408c: b9 a0 08 00 mv r1,r13
8004090: 59 64 00 48 sw (r11+72),r4
head->previous = NULL;
8004094: 59 60 00 4c sw (r11+76),r0
tail->previous = head;
8004098: 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;
800409c: 59 62 00 54 sw (r11+84),r2
head->previous = NULL;
80040a0: 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;
80040a4: 59 60 00 64 sw (r11+100),r0
aio_request_queue.idle_threads = 0;
80040a8: 59 60 00 68 sw (r11+104),r0
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
80040ac: 2b 9d 00 04 lw ra,(sp+4)
80040b0: 2b 8b 00 10 lw r11,(sp+16)
80040b4: 2b 8c 00 0c lw r12,(sp+12)
80040b8: 2b 8d 00 08 lw r13,(sp+8)
80040bc: 37 9c 00 10 addi sp,sp,16
80040c0: 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);
80040c4: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
80040c8: 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);
80040cc: f8 00 04 a6 calli 8005364 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
80040d0: 39 6b 88 08 ori r11,r11,0x8808 <== NOT EXECUTED
80040d4: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
80040d8: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
80040dc: f8 00 03 ca calli 8005004 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
80040e0: 44 20 ff da be r1,r0,8004048 <rtems_aio_init+0x70> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
80040e4: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
80040e8: f8 00 04 9f calli 8005364 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
80040ec: 78 01 08 01 mvhi r1,0x801 <== NOT EXECUTED
80040f0: 38 21 88 0c ori r1,r1,0x880c <== NOT EXECUTED
80040f4: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
80040f8: f8 00 02 8b calli 8004b24 <pthread_cond_init> <== NOT EXECUTED
80040fc: b8 20 68 00 mv r13,r1 <== NOT EXECUTED
if (result != 0) {
8004100: 44 20 ff d8 be r1,r0,8004060 <rtems_aio_init+0x88> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
8004104: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8004108: f8 00 03 58 calli 8004e68 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
800410c: b9 80 08 00 mv r1,r12 <== NOT EXECUTED
8004110: f8 00 04 95 calli 8005364 <pthread_attr_destroy> <== NOT EXECUTED
8004114: e3 ff ff d3 bi 8004060 <rtems_aio_init+0x88> <== NOT EXECUTED
080044d4 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
80044d4: 37 9c ff fc addi sp,sp,-4
80044d8: 5b 9d 00 04 sw (sp+4),ra
}
AIO_printf ("Thread finished\n");
return NULL;
}
80044dc: 28 24 00 00 lw r4,(r1+0)
80044e0: 34 26 00 04 addi r6,r1,4
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
80044e4: 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)) {
80044e8: 44 86 00 10 be r4,r6,8004528 <rtems_aio_insert_prio+0x54> <== 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 &&
80044ec: 28 41 00 14 lw r1,(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;
80044f0: 28 82 00 14 lw r2,(r4+20)
while (req->aiocbp->aio_reqprio > prio &&
80044f4: b8 80 18 00 mv r3,r4
80044f8: 28 21 00 10 lw r1,(r1+16)
80044fc: 28 42 00 10 lw r2,(r2+16)
8004500: 4c 41 00 08 bge r2,r1,8004520 <rtems_aio_insert_prio+0x4c> <== ALWAYS TAKEN
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004504: 28 83 00 00 lw r3,(r4+0)
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;
8004508: 28 65 00 14 lw r5,(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 &&
800450c: b8 60 20 00 mv r4,r3 <== NOT EXECUTED
8004510: 28 a5 00 10 lw r5,(r5+16) <== NOT EXECUTED
8004514: 4c a1 00 03 bge r5,r1,8004520 <rtems_aio_insert_prio+0x4c> <== NOT EXECUTED
8004518: 5c 66 ff fb bne r3,r6,8004504 <rtems_aio_insert_prio+0x30> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
800451c: b8 c0 18 00 mv r3,r6 <== 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 );
8004520: 28 61 00 04 lw r1,(r3+4)
8004524: b8 e0 10 00 mv r2,r7
8004528: f8 00 09 79 calli 8006b0c <_Chain_Insert>
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
800452c: 2b 9d 00 04 lw ra,(sp+4)
8004530: 37 9c 00 04 addi sp,sp,4
8004534: c3 a0 00 00 ret
08004538 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
8004538: 37 9c ff e8 addi sp,sp,-24
800453c: 5b 8b 00 18 sw (sp+24),r11
8004540: 5b 8c 00 14 sw (sp+20),r12
8004544: 5b 8d 00 10 sw (sp+16),r13
8004548: 5b 8e 00 0c sw (sp+12),r14
800454c: 5b 8f 00 08 sw (sp+8),r15
8004550: 5b 9d 00 04 sw (sp+4),ra
}
AIO_printf ("Thread finished\n");
return NULL;
}
8004554: 28 2b 00 08 lw r11,(r1+8)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
8004558: 34 2d 00 0c addi r13,r1,12
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;
800455c: 34 0f 00 8c mvi r15,140
req->aiocbp->return_value = -1;
8004560: 34 0e ff ff mvi r14,-1
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
8004564: 5d 6d 00 03 bne r11,r13,8004570 <rtems_aio_remove_fd+0x38> <== ALWAYS TAKEN
8004568: e0 00 00 0b bi 8004594 <rtems_aio_remove_fd+0x5c> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
800456c: b9 80 58 00 mv r11,r12
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
8004570: b9 60 08 00 mv r1,r11
8004574: f8 00 09 4b calli 8006aa0 <_Chain_Extract>
req->aiocbp->error_code = ECANCELED;
8004578: 29 62 00 14 lw r2,(r11+20)
}
AIO_printf ("Thread finished\n");
return NULL;
}
800457c: 29 6c 00 00 lw r12,(r11+0)
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
8004580: b9 60 08 00 mv r1,r11
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;
8004584: 58 4f 00 2c sw (r2+44),r15
req->aiocbp->return_value = -1;
8004588: 58 4e 00 30 sw (r2+48),r14
free (req);
800458c: fb ff f7 67 calli 8002328 <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))
8004590: 5d 8d ff f7 bne r12,r13,800456c <rtems_aio_remove_fd+0x34>
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
8004594: 2b 9d 00 04 lw ra,(sp+4)
8004598: 2b 8b 00 18 lw r11,(sp+24)
800459c: 2b 8c 00 14 lw r12,(sp+20)
80045a0: 2b 8d 00 10 lw r13,(sp+16)
80045a4: 2b 8e 00 0c lw r14,(sp+12)
80045a8: 2b 8f 00 08 lw r15,(sp+8)
80045ac: 37 9c 00 18 addi sp,sp,24
80045b0: c3 a0 00 00 ret
080045b4 <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)
{
80045b4: 37 9c ff f8 addi sp,sp,-8
80045b8: 5b 8b 00 08 sw (sp+8),r11
80045bc: 5b 9d 00 04 sw (sp+4),ra
}
AIO_printf ("Thread finished\n");
return NULL;
}
80045c0: 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 );
80045c4: 34 25 00 04 addi r5,r1,4
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
80045c8: 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))
80045cc: 44 65 00 0b be r3,r5,80045f8 <rtems_aio_remove_req+0x44> <== NEVER TAKEN
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) {
80045d0: 28 61 00 14 lw r1,(r3+20)
return AIO_ALLDONE;
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
80045d4: b8 60 58 00 mv r11,r3
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
80045d8: 5c 22 00 05 bne r1,r2,80045ec <rtems_aio_remove_req+0x38> <== NEVER TAKEN
80045dc: e0 00 00 0b bi 8004608 <rtems_aio_remove_req+0x54>
80045e0: 28 64 00 14 lw r4,(r3+20) <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
80045e4: b8 60 58 00 mv r11,r3 <== 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) {
80045e8: 44 82 00 08 be r4,r2,8004608 <rtems_aio_remove_req+0x54> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
80045ec: 28 63 00 00 lw r3,(r3+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) {
80045f0: 5c 65 ff fc bne r3,r5,80045e0 <rtems_aio_remove_req+0x2c> <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
80045f4: 34 01 00 01 mvi r1,1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
80045f8: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
80045fc: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
8004600: 37 9c 00 08 addi sp,sp,8 <== NOT EXECUTED
8004604: c3 a0 00 00 ret <== 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) {
8004608: b9 60 08 00 mv r1,r11
800460c: f8 00 09 25 calli 8006aa0 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
8004610: 29 61 00 14 lw r1,(r11+20)
8004614: 34 02 00 8c mvi r2,140
8004618: 58 22 00 2c sw (r1+44),r2
current->aiocbp->return_value = -1;
800461c: 34 02 ff ff mvi r2,-1
8004620: 58 22 00 30 sw (r1+48),r2
free (current);
8004624: b9 60 08 00 mv r1,r11
8004628: fb ff f7 40 calli 8002328 <free>
}
return AIO_CANCELED;
800462c: 34 01 00 00 mvi r1,0
}
8004630: 2b 9d 00 04 lw ra,(sp+4)
8004634: 2b 8b 00 08 lw r11,(sp+8)
8004638: 37 9c 00 08 addi sp,sp,8
800463c: c3 a0 00 00 ret
08003ab0 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
8003ab0: 37 9c ff f4 addi sp,sp,-12
8003ab4: 5b 8b 00 0c sw (sp+12),r11
8003ab8: 5b 8c 00 08 sw (sp+8),r12
8003abc: 5b 9d 00 04 sw (sp+4),ra
8003ac0: b8 60 60 00 mv r12,r3
8003ac4: b8 80 58 00 mv r11,r4
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
8003ac8: f8 00 01 a6 calli 8004160 <_Chain_Append_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
8003acc: 34 05 00 00 mvi r5,0
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
8003ad0: 44 20 00 05 be r1,r0,8003ae4 <rtems_chain_append_with_notification+0x34><== NEVER TAKEN
sc = rtems_event_send( task, events );
8003ad4: b9 80 08 00 mv r1,r12
8003ad8: b9 60 10 00 mv r2,r11
8003adc: f8 00 19 29 calli 8009f80 <rtems_event_send>
8003ae0: b8 20 28 00 mv r5,r1
}
return sc;
}
8003ae4: b8 a0 08 00 mv r1,r5
8003ae8: 2b 9d 00 04 lw ra,(sp+4)
8003aec: 2b 8b 00 0c lw r11,(sp+12)
8003af0: 2b 8c 00 08 lw r12,(sp+8)
8003af4: 37 9c 00 0c addi sp,sp,12
8003af8: c3 a0 00 00 ret
08003b4c <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
8003b4c: 37 9c ff e4 addi sp,sp,-28
8003b50: 5b 8b 00 18 sw (sp+24),r11
8003b54: 5b 8c 00 14 sw (sp+20),r12
8003b58: 5b 8d 00 10 sw (sp+16),r13
8003b5c: 5b 8e 00 0c sw (sp+12),r14
8003b60: 5b 8f 00 08 sw (sp+8),r15
8003b64: 5b 9d 00 04 sw (sp+4),ra
8003b68: b8 20 70 00 mv r14,r1
8003b6c: b8 40 68 00 mv r13,r2
8003b70: b8 60 60 00 mv r12,r3
8003b74: 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 );
8003b78: b9 c0 08 00 mv r1,r14
8003b7c: f8 00 01 af calli 8004238 <_Chain_Get>
8003b80: 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(
8003b84: 34 02 00 00 mvi r2,0
8003b88: b9 a0 08 00 mv r1,r13
8003b8c: b9 80 18 00 mv r3,r12
8003b90: 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
8003b94: 5d 60 00 0e bne r11,r0,8003bcc <rtems_chain_get_with_wait+0x80>
) {
rtems_event_set out;
sc = rtems_event_receive(
8003b98: fb ff fd 9e calli 8003210 <rtems_event_receive>
8003b9c: b8 20 28 00 mv r5,r1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
8003ba0: 44 2b ff f6 be r1,r11,8003b78 <rtems_chain_get_with_wait+0x2c><== NEVER TAKEN
}
*node_ptr = node;
return sc;
}
8003ba4: b8 a0 08 00 mv r1,r5
timeout,
&out
);
}
*node_ptr = node;
8003ba8: 59 eb 00 00 sw (r15+0),r11
return sc;
}
8003bac: 2b 9d 00 04 lw ra,(sp+4)
8003bb0: 2b 8b 00 18 lw r11,(sp+24)
8003bb4: 2b 8c 00 14 lw r12,(sp+20)
8003bb8: 2b 8d 00 10 lw r13,(sp+16)
8003bbc: 2b 8e 00 0c lw r14,(sp+12)
8003bc0: 2b 8f 00 08 lw r15,(sp+8)
8003bc4: 37 9c 00 1c addi sp,sp,28
8003bc8: 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
8003bcc: 34 05 00 00 mvi r5,0
8003bd0: e3 ff ff f5 bi 8003ba4 <rtems_chain_get_with_wait+0x58>
08003bd4 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
8003bd4: 37 9c ff f4 addi sp,sp,-12
8003bd8: 5b 8b 00 0c sw (sp+12),r11
8003bdc: 5b 8c 00 08 sw (sp+8),r12
8003be0: 5b 9d 00 04 sw (sp+4),ra
8003be4: b8 60 60 00 mv r12,r3
8003be8: b8 80 58 00 mv r11,r4
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
8003bec: f8 00 01 af calli 80042a8 <_Chain_Prepend_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
8003bf0: 34 05 00 00 mvi r5,0
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
8003bf4: 44 20 00 05 be r1,r0,8003c08 <rtems_chain_prepend_with_notification+0x34><== NEVER TAKEN
sc = rtems_event_send( task, events );
8003bf8: b9 80 08 00 mv r1,r12
8003bfc: b9 60 10 00 mv r2,r11
8003c00: f8 00 18 e0 calli 8009f80 <rtems_event_send>
8003c04: b8 20 28 00 mv r5,r1
}
return sc;
}
8003c08: b8 a0 08 00 mv r1,r5
8003c0c: 2b 9d 00 04 lw ra,(sp+4)
8003c10: 2b 8b 00 0c lw r11,(sp+12)
8003c14: 2b 8c 00 08 lw r12,(sp+8)
8003c18: 37 9c 00 0c addi sp,sp,12
8003c1c: c3 a0 00 00 ret
08010300 <rtems_clock_set_nanoseconds_extension>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
8010300: b8 20 18 00 mv r3,r1
if ( !routine )
return RTEMS_INVALID_ADDRESS;
8010304: 34 01 00 09 mvi r1,9
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
if ( !routine )
8010308: 44 60 00 05 be r3,r0,801031c <rtems_clock_set_nanoseconds_extension+0x1c><== ALWAYS TAKEN
return RTEMS_INVALID_ADDRESS;
_Watchdog_Nanoseconds_since_tick_handler = routine;
801030c: 78 02 08 03 mvhi r2,0x803
8010310: 38 42 c1 40 ori r2,r2,0xc140
8010314: 58 43 00 00 sw (r2+0),r3
return RTEMS_SUCCESSFUL;
8010318: 34 01 00 00 mvi r1,0 <== NOT EXECUTED
}
801031c: c3 a0 00 00 ret
0800495c <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
)
{
800495c: 37 9c ff f8 addi sp,sp,-8
8004960: 5b 8b 00 08 sw (sp+8),r11
8004964: 5b 9d 00 04 sw (sp+4),ra
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
8004968: 78 04 08 01 mvhi r4,0x801
800496c: 38 84 ad ec ori r4,r4,0xadec
8004970: 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;
8004974: 78 04 08 01 mvhi r4,0x801
8004978: 38 84 b2 58 ori r4,r4,0xb258
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
)
{
800497c: b8 20 58 00 mv r11,r1
rtems_device_major_number major_limit = _IO_Number_of_drivers;
8004980: 28 86 00 00 lw r6,(r4+0)
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
8004984: 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() )
8004988: 5c a0 00 33 bne r5,r0,8004a54 <rtems_io_register_driver+0xf8>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
800498c: 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 )
8004990: 44 65 00 31 be r3,r5,8004a54 <rtems_io_register_driver+0xf8>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
8004994: 58 66 00 00 sw (r3+0),r6
if ( driver_table == NULL )
8004998: 44 40 00 2f be r2,r0,8004a54 <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;
800499c: 28 45 00 00 lw r5,(r2+0)
80049a0: 44 a0 00 42 be r5,r0,8004aa8 <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;
80049a4: 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 )
80049a8: 51 66 00 2b bgeu r11,r6,8004a54 <rtems_io_register_driver+0xf8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
80049ac: 78 01 08 01 mvhi r1,0x801
80049b0: 38 21 a9 20 ori r1,r1,0xa920
80049b4: 28 25 00 00 lw r5,(r1+0)
80049b8: 34 a5 00 01 addi r5,r5,1
80049bc: 58 25 00 00 sw (r1+0),r5
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
80049c0: 5d 60 00 29 bne r11,r0,8004a64 <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;
80049c4: 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 ) {
80049c8: 44 ab 00 3e be r5,r11,8004ac0 <rtems_io_register_driver+0x164><== NEVER TAKEN
80049cc: 78 06 08 01 mvhi r6,0x801
80049d0: 38 c6 b2 5c ori r6,r6,0xb25c
80049d4: 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;
80049d8: 28 24 00 00 lw r4,(r1+0)
80049dc: 44 80 00 36 be r4,r0,8004ab4 <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 ) {
80049e0: 35 6b 00 01 addi r11,r11,1
80049e4: 34 21 00 18 addi r1,r1,24
80049e8: 54 ab ff fc bgu r5,r11,80049d8 <rtems_io_register_driver+0x7c>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
80049ec: 58 6b 00 00 sw (r3+0),r11
if ( m != n )
80049f0: 44 ab 00 35 be r5,r11,8004ac4 <rtems_io_register_driver+0x168>
80049f4: b5 6b 08 00 add r1,r11,r11
80049f8: b4 2b 08 00 add r1,r1,r11
80049fc: b4 21 08 00 add r1,r1,r1
8004a00: b4 21 08 00 add r1,r1,r1
8004a04: b4 21 08 00 add r1,r1,r1
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
8004a08: 28 c3 00 00 lw r3,(r6+0)
8004a0c: 28 44 00 00 lw r4,(r2+0)
8004a10: b4 61 08 00 add r1,r3,r1
8004a14: 58 24 00 00 sw (r1+0),r4
8004a18: 28 43 00 04 lw r3,(r2+4)
8004a1c: 58 23 00 04 sw (r1+4),r3
8004a20: 28 43 00 08 lw r3,(r2+8)
8004a24: 58 23 00 08 sw (r1+8),r3
8004a28: 28 43 00 0c lw r3,(r2+12)
8004a2c: 58 23 00 0c sw (r1+12),r3
8004a30: 28 43 00 10 lw r3,(r2+16)
8004a34: 58 23 00 10 sw (r1+16),r3
8004a38: 28 42 00 14 lw r2,(r2+20)
8004a3c: 58 22 00 14 sw (r1+20),r2
_Thread_Enable_dispatch();
8004a40: f8 00 08 83 calli 8006c4c <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
8004a44: b9 60 08 00 mv r1,r11
8004a48: 34 02 00 00 mvi r2,0
8004a4c: 34 03 00 00 mvi r3,0
8004a50: f8 00 28 65 calli 800ebe4 <rtems_io_initialize>
}
8004a54: 2b 9d 00 04 lw ra,(sp+4)
8004a58: 2b 8b 00 08 lw r11,(sp+8)
8004a5c: 37 9c 00 08 addi sp,sp,8
8004a60: 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;
8004a64: b5 6b 08 00 add r1,r11,r11
8004a68: 78 06 08 01 mvhi r6,0x801
8004a6c: b4 2b 08 00 add r1,r1,r11
8004a70: 38 c6 b2 5c ori r6,r6,0xb25c
8004a74: b4 21 08 00 add r1,r1,r1
8004a78: 28 c5 00 00 lw r5,(r6+0)
8004a7c: b4 21 08 00 add r1,r1,r1
8004a80: b4 21 08 00 add r1,r1,r1
8004a84: 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;
8004a88: 28 a4 00 00 lw r4,(r5+0)
8004a8c: 44 80 00 11 be r4,r0,8004ad0 <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();
8004a90: f8 00 08 6f calli 8006c4c <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
8004a94: 34 01 00 0c mvi r1,12
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
8004a98: 2b 9d 00 04 lw ra,(sp+4)
8004a9c: 2b 8b 00 08 lw r11,(sp+8)
8004aa0: 37 9c 00 08 addi sp,sp,8
8004aa4: 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;
8004aa8: 28 47 00 04 lw r7,(r2+4)
8004aac: 5c e5 ff be bne r7,r5,80049a4 <rtems_io_register_driver+0x48>
8004ab0: e3 ff ff e9 bi 8004a54 <rtems_io_register_driver+0xf8>
8004ab4: 28 27 00 04 lw r7,(r1+4)
8004ab8: 5c e4 ff ca bne r7,r4,80049e0 <rtems_io_register_driver+0x84>
8004abc: e3 ff ff cc bi 80049ec <rtems_io_register_driver+0x90>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
8004ac0: 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();
8004ac4: f8 00 08 62 calli 8006c4c <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
8004ac8: 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;
8004acc: e3 ff ff e2 bi 8004a54 <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;
8004ad0: 28 a5 00 04 lw r5,(r5+4)
8004ad4: 5c a4 ff ef bne r5,r4,8004a90 <rtems_io_register_driver+0x134>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
8004ad8: 58 6b 00 00 sw (r3+0),r11
8004adc: e3 ff ff cb bi 8004a08 <rtems_io_register_driver+0xac>
08004ae0 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
8004ae0: 37 9c ff fc addi sp,sp,-4
8004ae4: 5b 9d 00 04 sw (sp+4),ra
if ( rtems_interrupt_is_in_progress() )
8004ae8: 78 02 08 01 mvhi r2,0x801
8004aec: 38 42 ad ec ori r2,r2,0xadec
8004af0: 28 43 00 08 lw r3,(r2+8)
return RTEMS_CALLED_FROM_ISR;
8004af4: 34 02 00 12 mvi r2,18
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
8004af8: 5c 60 00 19 bne r3,r0,8004b5c <rtems_io_unregister_driver+0x7c><== NEVER TAKEN
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
8004afc: 78 02 08 01 mvhi r2,0x801
8004b00: 38 42 b2 58 ori r2,r2,0xb258
8004b04: 28 43 00 00 lw r3,(r2+0)
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
8004b08: 34 02 00 0d mvi r2,13
)
{
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
8004b0c: 50 23 00 14 bgeu r1,r3,8004b5c <rtems_io_unregister_driver+0x7c><== NEVER TAKEN
8004b10: 78 02 08 01 mvhi r2,0x801
8004b14: 38 42 a9 20 ori r2,r2,0xa920
8004b18: 28 43 00 00 lw r3,(r2+0)
8004b1c: 34 63 00 01 addi r3,r3,1
8004b20: 58 43 00 00 sw (r2+0),r3
_Thread_Disable_dispatch();
memset(
8004b24: 78 02 08 01 mvhi r2,0x801
&_IO_Driver_address_table[major],
8004b28: b4 21 18 00 add r3,r1,r1
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
8004b2c: 38 42 b2 5c ori r2,r2,0xb25c
&_IO_Driver_address_table[major],
8004b30: b4 61 08 00 add r1,r3,r1
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
8004b34: 28 44 00 00 lw r4,(r2+0)
&_IO_Driver_address_table[major],
8004b38: b4 21 08 00 add r1,r1,r1
8004b3c: b4 21 08 00 add r1,r1,r1
8004b40: b4 21 08 00 add r1,r1,r1
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
8004b44: 34 02 00 00 mvi r2,0
8004b48: 34 03 00 18 mvi r3,24
8004b4c: b4 81 08 00 add r1,r4,r1
8004b50: f8 00 37 be calli 8012a48 <memset>
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
8004b54: f8 00 08 3e calli 8006c4c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8004b58: 34 02 00 00 mvi r2,0
}
return RTEMS_UNSATISFIED;
}
8004b5c: b8 40 08 00 mv r1,r2
8004b60: 2b 9d 00 04 lw ra,(sp+4)
8004b64: 37 9c 00 04 addi sp,sp,4
8004b68: c3 a0 00 00 ret
08006378 <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)
{
8006378: 37 9c ff e4 addi sp,sp,-28
800637c: 5b 8b 00 1c sw (sp+28),r11
8006380: 5b 8c 00 18 sw (sp+24),r12
8006384: 5b 8d 00 14 sw (sp+20),r13
8006388: 5b 8e 00 10 sw (sp+16),r14
800638c: 5b 8f 00 0c sw (sp+12),r15
8006390: 5b 90 00 08 sw (sp+8),r16
8006394: 5b 9d 00 04 sw (sp+4),ra
8006398: b8 20 78 00 mv r15,r1
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
800639c: 44 20 00 19 be r1,r0,8006400 <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)
80063a0: 78 01 08 02 mvhi r1,0x802
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
80063a4: 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)
80063a8: 38 21 a6 34 ori r1,r1,0xa634
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
80063ac: 39 ce a6 38 ori r14,r14,0xa638
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
80063b0: 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 ];
80063b4: 29 c1 00 00 lw r1,(r14+0)
80063b8: 28 2d 00 04 lw r13,(r1+4)
if ( !information )
80063bc: 45 a0 00 0f be r13,r0,80063f8 <rtems_iterate_over_all_threads+0x80>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
80063c0: 2d a3 00 10 lhu r3,(r13+16)
80063c4: 44 60 00 0d be r3,r0,80063f8 <rtems_iterate_over_all_threads+0x80>
80063c8: 34 0c 00 04 mvi r12,4
80063cc: 34 0b 00 01 mvi r11,1
the_thread = (Thread_Control *)information->local_table[ i ];
80063d0: 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++ ) {
80063d4: 35 6b 00 01 addi r11,r11,1
the_thread = (Thread_Control *)information->local_table[ i ];
80063d8: b4 4c 10 00 add r2,r2,r12
80063dc: 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++ ) {
80063e0: 35 8c 00 04 addi r12,r12,4
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
(*routine)(the_thread);
80063e4: 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 )
80063e8: 44 40 00 03 be r2,r0,80063f4 <rtems_iterate_over_all_threads+0x7c>
continue;
(*routine)(the_thread);
80063ec: d9 e0 00 00 call r15
80063f0: 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++ ) {
80063f4: 50 6b ff f7 bgeu r3,r11,80063d0 <rtems_iterate_over_all_threads+0x58>
80063f8: 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++ ) {
80063fc: 5d d0 ff ee bne r14,r16,80063b4 <rtems_iterate_over_all_threads+0x3c>
(*routine)(the_thread);
}
}
}
8006400: 2b 9d 00 04 lw ra,(sp+4)
8006404: 2b 8b 00 1c lw r11,(sp+28)
8006408: 2b 8c 00 18 lw r12,(sp+24)
800640c: 2b 8d 00 14 lw r13,(sp+20)
8006410: 2b 8e 00 10 lw r14,(sp+16)
8006414: 2b 8f 00 0c lw r15,(sp+12)
8006418: 2b 90 00 08 lw r16,(sp+8)
800641c: 37 9c 00 1c addi sp,sp,28
8006420: c3 a0 00 00 ret
08004de4 <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
)
{
8004de4: 37 9c ff f8 addi sp,sp,-8
8004de8: 5b 8b 00 08 sw (sp+8),r11
8004dec: 5b 9d 00 04 sw (sp+4),ra
8004df0: b8 60 58 00 mv r11,r3
/*
* Validate parameters and look up information structure.
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
8004df4: 34 03 00 09 mvi r3,9
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
8004df8: 45 60 00 1e be r11,r0,8004e70 <rtems_object_get_class_information+0x8c>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
8004dfc: 20 42 ff ff andi r2,r2,0xffff
8004e00: f8 00 07 c3 calli 8006d0c <_Objects_Get_information>
8004e04: b8 20 10 00 mv r2,r1
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
8004e08: 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 )
8004e0c: 44 20 00 19 be r1,r0,8004e70 <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;
8004e10: 28 24 00 08 lw r4,(r1+8)
info->maximum_id = obj_info->maximum_id;
8004e14: 28 23 00 0c lw r3,(r1+12)
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
8004e18: 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;
8004e1c: 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;
8004e20: 59 64 00 00 sw (r11+0),r4
info->maximum_id = obj_info->maximum_id;
8004e24: 59 63 00 04 sw (r11+4),r3
info->auto_extend = obj_info->auto_extend;
8004e28: 31 61 00 0c sb (r11+12),r1
info->maximum = obj_info->maximum;
8004e2c: 59 66 00 08 sw (r11+8),r6
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
8004e30: 34 04 00 00 mvi r4,0
8004e34: 44 c0 00 0d be r6,r0,8004e68 <rtems_object_get_class_information+0x84><== NEVER TAKEN
8004e38: 28 43 00 1c lw r3,(r2+28)
8004e3c: 34 01 00 01 mvi r1,1
8004e40: 34 02 00 01 mvi r2,1
if ( !obj_info->local_table[i] )
8004e44: b4 21 08 00 add r1,r1,r1
8004e48: b4 21 08 00 add r1,r1,r1
8004e4c: b4 61 08 00 add r1,r3,r1
8004e50: 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++ )
8004e54: 34 42 00 01 addi r2,r2,1
8004e58: b8 40 08 00 mv r1,r2
if ( !obj_info->local_table[i] )
unallocated++;
8004e5c: 64 a5 00 00 cmpei r5,r5,0
8004e60: 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++ )
8004e64: 50 c2 ff f8 bgeu r6,r2,8004e44 <rtems_object_get_class_information+0x60>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
8004e68: 59 64 00 10 sw (r11+16),r4
return RTEMS_SUCCESSFUL;
8004e6c: 34 03 00 00 mvi r3,0
}
8004e70: b8 60 08 00 mv r1,r3
8004e74: 2b 9d 00 04 lw ra,(sp+4)
8004e78: 2b 8b 00 08 lw r11,(sp+8)
8004e7c: 37 9c 00 08 addi sp,sp,8
8004e80: c3 a0 00 00 ret
080113c0 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
80113c0: 37 9c ff d8 addi sp,sp,-40
80113c4: 5b 8b 00 18 sw (sp+24),r11
80113c8: 5b 8c 00 14 sw (sp+20),r12
80113cc: 5b 8d 00 10 sw (sp+16),r13
80113d0: 5b 8e 00 0c sw (sp+12),r14
80113d4: 5b 8f 00 08 sw (sp+8),r15
80113d8: 5b 9d 00 04 sw (sp+4),ra
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
80113dc: 34 07 00 03 mvi r7,3
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
80113e0: b8 20 60 00 mv r12,r1
80113e4: b8 40 58 00 mv r11,r2
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
80113e8: 44 20 00 3e be r1,r0,80114e0 <rtems_partition_create+0x120>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
80113ec: 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 )
80113f0: 44 40 00 3c be r2,r0,80114e0 <rtems_partition_create+0x120>
return RTEMS_INVALID_ADDRESS;
if ( !id )
80113f4: 44 c0 00 3b be r6,r0,80114e0 <rtems_partition_create+0x120><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
80113f8: 64 82 00 00 cmpei r2,r4,0
80113fc: 64 61 00 00 cmpei r1,r3,0
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
8011400: 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 ||
8011404: b8 41 08 00 or r1,r2,r1
8011408: 5c 20 00 36 bne r1,r0,80114e0 <rtems_partition_create+0x120>
801140c: 54 83 00 35 bgu r4,r3,80114e0 <rtems_partition_create+0x120>
*/
RTEMS_INLINE_ROUTINE bool _Partition_Is_buffer_size_aligned (
uint32_t buffer_size
)
{
return ((buffer_size % CPU_PARTITION_ALIGNMENT) == 0);
8011410: 20 81 00 07 andi r1,r4,0x7
8011414: 5c 20 00 33 bne r1,r0,80114e0 <rtems_partition_create+0x120>
)
{
#if (CPU_ALIGNMENT == 0)
return true;
#else
return (((uintptr_t)address % CPU_ALIGNMENT) == 0);
8011418: 21 6f 00 07 andi r15,r11,0x7
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
801141c: 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 ) )
8011420: 5d e1 00 30 bne r15,r1,80114e0 <rtems_partition_create+0x120>
8011424: 78 01 08 04 mvhi r1,0x804
8011428: 38 21 0c b0 ori r1,r1,0xcb0
801142c: 28 22 00 00 lw r2,(r1+0)
8011430: 34 42 00 01 addi r2,r2,1
8011434: 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 );
8011438: 78 0e 08 04 mvhi r14,0x804
801143c: 39 ce 0b 08 ori r14,r14,0xb08
8011440: b9 c0 08 00 mv r1,r14
8011444: 5b 83 00 28 sw (sp+40),r3
8011448: 5b 84 00 20 sw (sp+32),r4
801144c: 5b 85 00 24 sw (sp+36),r5
8011450: 5b 86 00 1c sw (sp+28),r6
8011454: f8 00 16 f1 calli 8017018 <_Objects_Allocate>
8011458: b8 20 68 00 mv r13,r1
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
801145c: 2b 83 00 28 lw r3,(sp+40)
8011460: 2b 84 00 20 lw r4,(sp+32)
8011464: 2b 85 00 24 lw r5,(sp+36)
8011468: 2b 86 00 1c lw r6,(sp+28)
801146c: 44 2f 00 26 be r1,r15,8011504 <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;
8011470: 58 25 00 1c sw (r1+28),r5
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
8011474: 58 23 00 14 sw (r1+20),r3
the_partition->buffer_size = buffer_size;
8011478: 58 24 00 18 sw (r1+24),r4
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
801147c: 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;
8011480: 58 20 00 20 sw (r1+32),r0
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
8011484: 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,
8011488: 34 2f 00 24 addi r15,r1,36
length / buffer_size, buffer_size );
801148c: b8 60 08 00 mv r1,r3
8011490: 5b 86 00 1c sw (sp+28),r6
8011494: 5b 84 00 20 sw (sp+32),r4
8011498: f8 00 7f 08 calli 80310b8 <__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,
801149c: 2b 84 00 20 lw r4,(sp+32)
length / buffer_size, buffer_size );
80114a0: 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,
80114a4: b9 60 10 00 mv r2,r11
80114a8: b9 e0 08 00 mv r1,r15
80114ac: f8 00 0f 9c calli 801531c <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
80114b0: 29 a2 00 08 lw r2,(r13+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80114b4: 29 c3 00 1c lw r3,(r14+28)
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
80114b8: 20 41 ff ff andi r1,r2,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
80114bc: b4 21 08 00 add r1,r1,r1
80114c0: b4 21 08 00 add r1,r1,r1
80114c4: b4 61 08 00 add r1,r3,r1
80114c8: 58 2d 00 00 sw (r1+0),r13
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
80114cc: 59 ac 00 0c sw (r13+12),r12
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
80114d0: 2b 86 00 1c lw r6,(sp+28)
80114d4: 58 c2 00 00 sw (r6+0),r2
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
80114d8: f8 00 1c 41 calli 80185dc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80114dc: 34 07 00 00 mvi r7,0
}
80114e0: b8 e0 08 00 mv r1,r7
80114e4: 2b 9d 00 04 lw ra,(sp+4)
80114e8: 2b 8b 00 18 lw r11,(sp+24)
80114ec: 2b 8c 00 14 lw r12,(sp+20)
80114f0: 2b 8d 00 10 lw r13,(sp+16)
80114f4: 2b 8e 00 0c lw r14,(sp+12)
80114f8: 2b 8f 00 08 lw r15,(sp+8)
80114fc: 37 9c 00 28 addi sp,sp,40
8011500: c3 a0 00 00 ret
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
8011504: f8 00 1c 36 calli 80185dc <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
8011508: 34 07 00 05 mvi r7,5
801150c: e3 ff ff f5 bi 80114e0 <rtems_partition_create+0x120>
080042ec <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
80042ec: 37 9c ff e0 addi sp,sp,-32
80042f0: 5b 8b 00 18 sw (sp+24),r11
80042f4: 5b 8c 00 14 sw (sp+20),r12
80042f8: 5b 8d 00 10 sw (sp+16),r13
80042fc: 5b 8e 00 0c sw (sp+12),r14
8004300: 5b 8f 00 08 sw (sp+8),r15
8004304: 5b 9d 00 04 sw (sp+4),ra
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
8004308: 78 03 08 02 mvhi r3,0x802
800430c: b8 20 68 00 mv r13,r1
8004310: b8 60 08 00 mv r1,r3
8004314: b8 40 70 00 mv r14,r2
8004318: 38 21 18 90 ori r1,r1,0x1890
800431c: b9 a0 10 00 mv r2,r13
8004320: 37 83 00 20 addi r3,sp,32
8004324: f8 00 0a 8a calli 8006d4c <_Objects_Get>
8004328: 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 ) {
800432c: 2b 81 00 20 lw r1,(sp+32)
8004330: 44 20 00 0a be r1,r0,8004358 <rtems_rate_monotonic_period+0x6c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8004334: 34 01 00 04 mvi r1,4
}
8004338: 2b 9d 00 04 lw ra,(sp+4)
800433c: 2b 8b 00 18 lw r11,(sp+24)
8004340: 2b 8c 00 14 lw r12,(sp+20)
8004344: 2b 8d 00 10 lw r13,(sp+16)
8004348: 2b 8e 00 0c lw r14,(sp+12)
800434c: 2b 8f 00 08 lw r15,(sp+8)
8004350: 37 9c 00 20 addi sp,sp,32
8004354: c3 a0 00 00 ret
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
8004358: 78 0c 08 02 mvhi r12,0x802
800435c: 39 8c 1e 84 ori r12,r12,0x1e84
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
8004360: 29 62 00 40 lw r2,(r11+64)
8004364: 29 81 00 0c lw r1,(r12+12)
8004368: 44 41 00 0b be r2,r1,8004394 <rtems_rate_monotonic_period+0xa8>
_Thread_Enable_dispatch();
800436c: f8 00 0d f2 calli 8007b34 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
8004370: 34 01 00 17 mvi r1,23
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8004374: 2b 9d 00 04 lw ra,(sp+4)
8004378: 2b 8b 00 18 lw r11,(sp+24)
800437c: 2b 8c 00 14 lw r12,(sp+20)
8004380: 2b 8d 00 10 lw r13,(sp+16)
8004384: 2b 8e 00 0c lw r14,(sp+12)
8004388: 2b 8f 00 08 lw r15,(sp+8)
800438c: 37 9c 00 20 addi sp,sp,32
8004390: c3 a0 00 00 ret
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
8004394: 5d c0 00 0f bne r14,r0,80043d0 <rtems_rate_monotonic_period+0xe4>
switch ( the_period->state ) {
8004398: 29 62 00 38 lw r2,(r11+56)
800439c: 34 03 00 04 mvi r3,4
80043a0: 34 01 00 00 mvi r1,0
80043a4: 54 43 00 07 bgu r2,r3,80043c0 <rtems_rate_monotonic_period+0xd4><== NEVER TAKEN
80043a8: 78 01 08 01 mvhi r1,0x801
80043ac: b4 42 10 00 add r2,r2,r2
80043b0: 38 21 ef 90 ori r1,r1,0xef90
80043b4: b4 42 10 00 add r2,r2,r2
80043b8: b4 22 10 00 add r2,r1,r2
80043bc: 28 41 00 00 lw r1,(r2+0)
);
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
80043c0: 5b 81 00 1c sw (sp+28),r1
80043c4: f8 00 0d dc calli 8007b34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80043c8: 2b 81 00 1c lw r1,(sp+28)
80043cc: e3 ff ff db bi 8004338 <rtems_rate_monotonic_period+0x4c>
}
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
80043d0: 90 00 78 00 rcsr r15,IE
80043d4: 34 01 ff fe mvi r1,-2
80043d8: a1 e1 08 00 and r1,r15,r1
80043dc: d0 01 00 00 wcsr IE,r1
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
80043e0: 29 62 00 38 lw r2,(r11+56)
80043e4: 44 40 00 15 be r2,r0,8004438 <rtems_rate_monotonic_period+0x14c>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
80043e8: 34 01 00 02 mvi r1,2
80043ec: 44 41 00 26 be r2,r1,8004484 <rtems_rate_monotonic_period+0x198>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
80043f0: 34 01 00 04 mvi r1,4
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
80043f4: 5c 41 ff d1 bne r2,r1,8004338 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
80043f8: b9 60 08 00 mv r1,r11
80043fc: fb ff ff 72 calli 80041c4 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
8004400: d0 0f 00 00 wcsr IE,r15
the_period->state = RATE_MONOTONIC_ACTIVE;
8004404: 34 03 00 02 mvi r3,2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8004408: 78 01 08 02 mvhi r1,0x802
800440c: 38 21 1a 98 ori r1,r1,0x1a98
8004410: 35 62 00 10 addi r2,r11,16
8004414: 59 63 00 38 sw (r11+56),r3
the_period->next_length = length;
8004418: 59 6e 00 3c sw (r11+60),r14
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
800441c: 59 6e 00 1c sw (r11+28),r14
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8004420: f8 00 13 3e calli 8009118 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
8004424: 34 01 00 06 mvi r1,6
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
8004428: 5b 81 00 1c sw (sp+28),r1
800442c: f8 00 0d c2 calli 8007b34 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
8004430: 2b 81 00 1c lw r1,(sp+28)
8004434: e3 ff ff c1 bi 8004338 <rtems_rate_monotonic_period+0x4c>
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
8004438: d0 0f 00 00 wcsr IE,r15
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
800443c: b9 60 08 00 mv r1,r11
8004440: fb ff ff 36 calli 8004118 <_Rate_monotonic_Initiate_statistics>
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
8004444: 78 03 08 00 mvhi r3,0x800
8004448: 38 63 48 7c ori r3,r3,0x487c
the_period->state = RATE_MONOTONIC_ACTIVE;
800444c: 34 04 00 02 mvi r4,2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8004450: 78 01 08 02 mvhi r1,0x802
8004454: 38 21 1a 98 ori r1,r1,0x1a98
8004458: 35 62 00 10 addi r2,r11,16
800445c: 59 64 00 38 sw (r11+56),r4
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8004460: 59 60 00 18 sw (r11+24),r0
the_watchdog->routine = routine;
8004464: 59 63 00 2c sw (r11+44),r3
the_watchdog->id = id;
8004468: 59 6d 00 30 sw (r11+48),r13
the_watchdog->user_data = user_data;
800446c: 59 60 00 34 sw (r11+52),r0
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
8004470: 59 6e 00 3c sw (r11+60),r14
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
8004474: 59 6e 00 1c sw (r11+28),r14
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
8004478: f8 00 13 28 calli 8009118 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
800447c: 34 01 00 00 mvi r1,0
8004480: e3 ff ff d0 bi 80043c0 <rtems_rate_monotonic_period+0xd4>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
8004484: b9 60 08 00 mv r1,r11
8004488: fb ff ff 4f calli 80041c4 <_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;
800448c: 34 01 00 01 mvi r1,1
8004490: 59 61 00 38 sw (r11+56),r1
the_period->next_length = length;
8004494: 59 6e 00 3c sw (r11+60),r14
_ISR_Enable( level );
8004498: d0 0f 00 00 wcsr IE,r15
_Thread_Executing->Wait.id = the_period->Object.id;
800449c: 29 83 00 0c lw r3,(r12+12)
80044a0: 29 64 00 08 lw r4,(r11+8)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
80044a4: 34 02 40 00 mvi r2,16384
80044a8: 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;
80044ac: 58 64 00 20 sw (r3+32),r4
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
80044b0: f8 00 10 3b calli 800859c <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
80044b4: 90 00 08 00 rcsr r1,IE
80044b8: 34 02 ff fe mvi r2,-2
80044bc: a0 22 10 00 and r2,r1,r2
80044c0: d0 02 00 00 wcsr IE,r2
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
80044c4: 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;
80044c8: 29 62 00 38 lw r2,(r11+56)
the_period->state = RATE_MONOTONIC_ACTIVE;
80044cc: 59 63 00 38 sw (r11+56),r3
_ISR_Enable( level );
80044d0: 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 )
80044d4: 34 01 00 03 mvi r1,3
80044d8: 44 41 00 04 be r2,r1,80044e8 <rtems_rate_monotonic_period+0x1fc><== NEVER TAKEN
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
80044dc: f8 00 0d 96 calli 8007b34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80044e0: 34 01 00 00 mvi r1,0
80044e4: e3 ff ff 95 bi 8004338 <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 );
80044e8: 29 81 00 0c lw r1,(r12+12) <== NOT EXECUTED
80044ec: 34 02 40 00 mvi r2,16384 <== NOT EXECUTED
80044f0: f8 00 0c b6 calli 80077c8 <_Thread_Clear_state> <== NOT EXECUTED
80044f4: e3 ff ff fa bi 80044dc <rtems_rate_monotonic_period+0x1f0> <== NOT EXECUTED
080044f8 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
80044f8: 37 9c ff 5c addi sp,sp,-164
80044fc: 5b 8b 00 44 sw (sp+68),r11
8004500: 5b 8c 00 40 sw (sp+64),r12
8004504: 5b 8d 00 3c sw (sp+60),r13
8004508: 5b 8e 00 38 sw (sp+56),r14
800450c: 5b 8f 00 34 sw (sp+52),r15
8004510: 5b 90 00 30 sw (sp+48),r16
8004514: 5b 91 00 2c sw (sp+44),r17
8004518: 5b 92 00 28 sw (sp+40),r18
800451c: 5b 93 00 24 sw (sp+36),r19
8004520: 5b 94 00 20 sw (sp+32),r20
8004524: 5b 95 00 1c sw (sp+28),r21
8004528: 5b 96 00 18 sw (sp+24),r22
800452c: 5b 97 00 14 sw (sp+20),r23
8004530: 5b 98 00 10 sw (sp+16),r24
8004534: 5b 99 00 0c sw (sp+12),r25
8004538: 5b 9b 00 08 sw (sp+8),fp
800453c: 5b 9d 00 04 sw (sp+4),ra
8004540: b8 40 68 00 mv r13,r2
8004544: 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 )
8004548: 44 40 00 2f be r2,r0,8004604 <rtems_rate_monotonic_report_statistics_with_plugin+0x10c><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
800454c: 78 02 08 01 mvhi r2,0x801
8004550: 38 42 ef a4 ori r2,r2,0xefa4
8004554: d9 a0 00 00 call r13
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
8004558: 78 02 08 01 mvhi r2,0x801
800455c: 38 42 ef c4 ori r2,r2,0xefc4
8004560: b9 e0 08 00 mv r1,r15
8004564: d9 a0 00 00 call r13
(*print)( context, "--- Wall times are in seconds ---\n" );
8004568: 78 02 08 01 mvhi r2,0x801
800456c: 38 42 ef e8 ori r2,r2,0xefe8
8004570: b9 e0 08 00 mv r1,r15
8004574: d9 a0 00 00 call r13
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
8004578: 78 02 08 01 mvhi r2,0x801
800457c: 38 42 f0 0c ori r2,r2,0xf00c
8004580: b9 e0 08 00 mv r1,r15
8004584: d9 a0 00 00 call r13
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
8004588: 78 02 08 01 mvhi r2,0x801
/*
* 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 ;
800458c: 78 0c 08 02 mvhi r12,0x802
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
8004590: b9 e0 08 00 mv r1,r15
8004594: 38 42 f0 58 ori r2,r2,0xf058
/*
* 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 ;
8004598: 39 8c 18 90 ori r12,r12,0x1890
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
800459c: 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 ;
80045a0: 29 81 00 0c lw r1,(r12+12)
80045a4: 29 8b 00 08 lw r11,(r12+8)
80045a8: 55 61 00 17 bgu r11,r1,8004604 <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,
80045ac: 78 12 08 01 mvhi r18,0x801
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,
80045b0: 78 15 08 01 mvhi r21,0x801
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,
80045b4: 78 14 08 01 mvhi r20,0x801
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
80045b8: 78 11 08 01 mvhi r17,0x801
80045bc: 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 );
80045c0: 37 98 00 80 addi r24,sp,128
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
80045c4: 37 93 00 a0 addi r19,sp,160
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
80045c8: 3a 52 f0 a4 ori r18,r18,0xf0a4
{
#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;
80045cc: 37 97 00 60 addi r23,sp,96
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
80045d0: 37 96 00 98 addi r22,sp,152
(*print)( context,
80045d4: 3a b5 f0 bc ori r21,r21,0xf0bc
{
#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;
80045d8: 37 9b 00 78 addi fp,sp,120
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
(*print)( context,
80045dc: 3a 94 f0 dc ori r20,r20,0xf0dc
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
80045e0: 3a 31 e5 e0 ori r17,r17,0xe5e0
* 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 );
80045e4: b9 60 08 00 mv r1,r11
80045e8: ba 00 10 00 mv r2,r16
80045ec: f8 00 1e 5e calli 800bf64 <rtems_rate_monotonic_get_statistics>
80045f0: b8 20 70 00 mv r14,r1
if ( status != RTEMS_SUCCESSFUL )
80045f4: 44 20 00 17 be r1,r0,8004650 <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 ;
80045f8: 29 85 00 0c lw r5,(r12+12)
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
80045fc: 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 ;
8004600: 50 ab ff f9 bgeu r5,r11,80045e4 <rtems_rate_monotonic_report_statistics_with_plugin+0xec>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
8004604: 2b 9d 00 04 lw ra,(sp+4)
8004608: 2b 8b 00 44 lw r11,(sp+68)
800460c: 2b 8c 00 40 lw r12,(sp+64)
8004610: 2b 8d 00 3c lw r13,(sp+60)
8004614: 2b 8e 00 38 lw r14,(sp+56)
8004618: 2b 8f 00 34 lw r15,(sp+52)
800461c: 2b 90 00 30 lw r16,(sp+48)
8004620: 2b 91 00 2c lw r17,(sp+44)
8004624: 2b 92 00 28 lw r18,(sp+40)
8004628: 2b 93 00 24 lw r19,(sp+36)
800462c: 2b 94 00 20 lw r20,(sp+32)
8004630: 2b 95 00 1c lw r21,(sp+28)
8004634: 2b 96 00 18 lw r22,(sp+24)
8004638: 2b 97 00 14 lw r23,(sp+20)
800463c: 2b 98 00 10 lw r24,(sp+16)
8004640: 2b 99 00 0c lw r25,(sp+12)
8004644: 2b 9b 00 08 lw fp,(sp+8)
8004648: 37 9c 00 a4 addi sp,sp,164
800464c: 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 );
8004650: bb 00 10 00 mv r2,r24
8004654: b9 60 08 00 mv r1,r11
8004658: f8 00 1e 83 calli 800c064 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
800465c: 2b 81 00 80 lw r1,(sp+128)
8004660: ba 60 18 00 mv r3,r19
8004664: 34 02 00 05 mvi r2,5
8004668: f8 00 00 ba calli 8004950 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
800466c: 2b 85 00 48 lw r5,(sp+72)
8004670: 2b 86 00 4c lw r6,(sp+76)
8004674: ba 40 10 00 mv r2,r18
8004678: b9 60 18 00 mv r3,r11
800467c: b9 e0 08 00 mv r1,r15
8004680: ba 60 20 00 mv r4,r19
8004684: d9 a0 00 00 call r13
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
8004688: 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 );
800468c: ba c0 18 00 mv r3,r22
8004690: ba e0 08 00 mv r1,r23
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
8004694: ba 20 10 00 mv r2,r17
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
8004698: 5c ae 00 04 bne r5,r14,80046a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1b0>
(*print)( context, "\n" );
800469c: b9 e0 08 00 mv r1,r15
80046a0: d9 a0 00 00 call r13
continue;
80046a4: e3 ff ff d5 bi 80045f8 <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 );
80046a8: b8 a0 10 00 mv r2,r5
80046ac: f8 00 10 b4 calli 800897c <_Timespec_Divide_by_integer>
(*print)( context,
80046b0: 2b 81 00 54 lw r1,(sp+84)
80046b4: 34 02 03 e8 mvi r2,1000
80046b8: f8 00 62 b0 calli 801d178 <__divsi3>
80046bc: b8 20 c8 00 mv r25,r1
80046c0: 2b 81 00 5c lw r1,(sp+92)
80046c4: 34 02 03 e8 mvi r2,1000
80046c8: f8 00 62 ac calli 801d178 <__divsi3>
80046cc: b8 20 70 00 mv r14,r1
80046d0: 2b 81 00 9c lw r1,(sp+156)
80046d4: 34 02 03 e8 mvi r2,1000
80046d8: f8 00 62 a8 calli 801d178 <__divsi3>
80046dc: 2b 85 00 58 lw r5,(sp+88)
80046e0: 2b 87 00 98 lw r7,(sp+152)
80046e4: 2b 83 00 50 lw r3,(sp+80)
80046e8: b8 20 40 00 mv r8,r1
80046ec: bb 20 20 00 mv r4,r25
80046f0: b9 c0 30 00 mv r6,r14
80046f4: ba a0 10 00 mv r2,r21
80046f8: b9 e0 08 00 mv r1,r15
80046fc: 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);
8004700: 2b 82 00 48 lw r2,(sp+72)
8004704: ba c0 18 00 mv r3,r22
8004708: bb 60 08 00 mv r1,fp
800470c: f8 00 10 9c calli 800897c <_Timespec_Divide_by_integer>
(*print)( context,
8004710: 2b 81 00 6c lw r1,(sp+108)
8004714: 34 02 03 e8 mvi r2,1000
8004718: f8 00 62 98 calli 801d178 <__divsi3>
800471c: b8 20 c8 00 mv r25,r1
8004720: 2b 81 00 74 lw r1,(sp+116)
8004724: 34 02 03 e8 mvi r2,1000
8004728: f8 00 62 94 calli 801d178 <__divsi3>
800472c: b8 20 70 00 mv r14,r1
8004730: 2b 81 00 9c lw r1,(sp+156)
8004734: 34 02 03 e8 mvi r2,1000
8004738: f8 00 62 90 calli 801d178 <__divsi3>
800473c: 2b 83 00 68 lw r3,(sp+104)
8004740: 2b 85 00 70 lw r5,(sp+112)
8004744: 2b 87 00 98 lw r7,(sp+152)
8004748: b8 20 40 00 mv r8,r1
800474c: ba 80 10 00 mv r2,r20
8004750: b9 e0 08 00 mv r1,r15
8004754: bb 20 20 00 mv r4,r25
8004758: b9 c0 30 00 mv r6,r14
800475c: d9 a0 00 00 call r13
8004760: e3 ff ff a6 bi 80045f8 <rtems_rate_monotonic_report_statistics_with_plugin+0x100>
08004788 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
8004788: 37 9c ff f4 addi sp,sp,-12
800478c: 5b 8b 00 0c sw (sp+12),r11
8004790: 5b 8c 00 08 sw (sp+8),r12
8004794: 5b 9d 00 04 sw (sp+4),ra
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
8004798: 78 01 08 02 mvhi r1,0x802
800479c: 38 21 19 b8 ori r1,r1,0x19b8
80047a0: 28 22 00 00 lw r2,(r1+0)
80047a4: 34 42 00 01 addi r2,r2,1
80047a8: 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 ;
80047ac: 78 0c 08 02 mvhi r12,0x802
80047b0: 39 8c 18 90 ori r12,r12,0x1890
80047b4: 29 8b 00 08 lw r11,(r12+8)
80047b8: 29 81 00 0c lw r1,(r12+12)
80047bc: 55 61 00 06 bgu r11,r1,80047d4 <rtems_rate_monotonic_reset_all_statistics+0x4c><== NEVER TAKEN
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
80047c0: b9 60 08 00 mv r1,r11
80047c4: f8 00 00 0a calli 80047ec <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 ;
80047c8: 29 81 00 0c lw r1,(r12+12)
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
80047cc: 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 ;
80047d0: 50 2b ff fc bgeu r1,r11,80047c0 <rtems_rate_monotonic_reset_all_statistics+0x38>
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
80047d4: f8 00 0c d8 calli 8007b34 <_Thread_Enable_dispatch>
}
80047d8: 2b 9d 00 04 lw ra,(sp+4)
80047dc: 2b 8b 00 0c lw r11,(sp+12)
80047e0: 2b 8c 00 08 lw r12,(sp+8)
80047e4: 37 9c 00 0c addi sp,sp,12
80047e8: c3 a0 00 00 ret
08012fa8 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
8012fa8: 37 9c ff f4 addi sp,sp,-12
8012fac: 5b 8b 00 08 sw (sp+8),r11
8012fb0: 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;
8012fb4: 34 03 00 0a mvi r3,10
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
8012fb8: 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 )
8012fbc: 5c 40 00 06 bne r2,r0,8012fd4 <rtems_signal_send+0x2c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8012fc0: b8 60 08 00 mv r1,r3
8012fc4: 2b 9d 00 04 lw ra,(sp+4)
8012fc8: 2b 8b 00 08 lw r11,(sp+8)
8012fcc: 37 9c 00 0c addi sp,sp,12
8012fd0: c3 a0 00 00 ret
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
8012fd4: 37 82 00 0c addi r2,sp,12
8012fd8: f8 00 15 8e calli 8018610 <_Thread_Get>
switch ( location ) {
8012fdc: 2b 83 00 0c lw r3,(sp+12)
8012fe0: 44 60 00 07 be r3,r0,8012ffc <rtems_signal_send+0x54>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8012fe4: 34 03 00 04 mvi r3,4
}
8012fe8: b8 60 08 00 mv r1,r3
8012fec: 2b 9d 00 04 lw ra,(sp+4)
8012ff0: 2b 8b 00 08 lw r11,(sp+8)
8012ff4: 37 9c 00 0c addi sp,sp,12
8012ff8: c3 a0 00 00 ret
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
8012ffc: 28 22 01 1c lw r2,(r1+284)
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
8013000: 28 44 00 0c lw r4,(r2+12)
8013004: 44 83 00 23 be r4,r3,8013090 <rtems_signal_send+0xe8>
if ( asr->is_enabled ) {
8013008: 40 43 00 08 lbu r3,(r2+8)
801300c: 44 60 00 12 be r3,r0,8013054 <rtems_signal_send+0xac>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
8013010: 90 00 18 00 rcsr r3,IE
8013014: 34 04 ff fe mvi r4,-2
8013018: a0 64 20 00 and r4,r3,r4
801301c: d0 04 00 00 wcsr IE,r4
*signal_set |= signals;
8013020: 28 44 00 14 lw r4,(r2+20)
8013024: b8 8b 58 00 or r11,r4,r11
8013028: 58 4b 00 14 sw (r2+20),r11
_ISR_Enable( _level );
801302c: 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 ) )
8013030: 78 02 08 04 mvhi r2,0x804
8013034: 38 42 11 84 ori r2,r2,0x1184
8013038: 28 43 00 08 lw r3,(r2+8)
801303c: 44 60 00 0e be r3,r0,8013074 <rtems_signal_send+0xcc>
8013040: 28 43 00 0c lw r3,(r2+12)
8013044: 5c 23 00 0c bne r1,r3,8013074 <rtems_signal_send+0xcc> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
8013048: 34 01 00 01 mvi r1,1
801304c: 30 41 00 18 sb (r2+24),r1
8013050: e0 00 00 09 bi 8013074 <rtems_signal_send+0xcc>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
8013054: 90 00 08 00 rcsr r1,IE
8013058: 34 03 ff fe mvi r3,-2
801305c: a0 23 18 00 and r3,r1,r3
8013060: d0 03 00 00 wcsr IE,r3
*signal_set |= signals;
8013064: 28 43 00 18 lw r3,(r2+24)
8013068: b8 6b 58 00 or r11,r3,r11
801306c: 58 4b 00 18 sw (r2+24),r11
_ISR_Enable( _level );
8013070: d0 01 00 00 wcsr IE,r1
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
8013074: f8 00 15 5a calli 80185dc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8013078: 34 03 00 00 mvi r3,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
801307c: b8 60 08 00 mv r1,r3
8013080: 2b 9d 00 04 lw ra,(sp+4)
8013084: 2b 8b 00 08 lw r11,(sp+8)
8013088: 37 9c 00 0c addi sp,sp,12
801308c: c3 a0 00 00 ret
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
8013090: f8 00 15 53 calli 80185dc <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
8013094: 34 03 00 0b mvi r3,11
8013098: e3 ff ff ca bi 8012fc0 <rtems_signal_send+0x18>
0800c754 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
800c754: 37 9c ff dc addi sp,sp,-36
800c758: 5b 8b 00 24 sw (sp+36),r11
800c75c: 5b 8c 00 20 sw (sp+32),r12
800c760: 5b 8d 00 1c sw (sp+28),r13
800c764: 5b 8e 00 18 sw (sp+24),r14
800c768: 5b 8f 00 14 sw (sp+20),r15
800c76c: 5b 90 00 10 sw (sp+16),r16
800c770: 5b 91 00 0c sw (sp+12),r17
800c774: 5b 92 00 08 sw (sp+8),r18
800c778: 5b 9d 00 04 sw (sp+4),ra
800c77c: b8 40 70 00 mv r14,r2
800c780: b8 60 88 00 mv r17,r3
800c784: 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;
800c788: 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 )
800c78c: 44 60 00 46 be r3,r0,800c8a4 <rtems_task_mode+0x150>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
800c790: 78 0f 08 01 mvhi r15,0x801
800c794: 39 ef 4d 74 ori r15,r15,0x4d74
800c798: 29 eb 00 0c lw r11,(r15+12)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
800c79c: 41 6d 00 74 lbu r13,(r11+116)
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
800c7a0: 29 61 00 7c lw r1,(r11+124)
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
800c7a4: 29 6c 01 1c lw r12,(r11+284)
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
800c7a8: 65 ad 00 00 cmpei r13,r13,0
800c7ac: b5 ad 20 00 add r4,r13,r13
800c7b0: b4 84 20 00 add r4,r4,r4
800c7b4: b4 84 20 00 add r4,r4,r4
800c7b8: b4 84 20 00 add r4,r4,r4
800c7bc: b4 84 20 00 add r4,r4,r4
800c7c0: b4 84 20 00 add r4,r4,r4
800c7c4: b4 84 20 00 add r4,r4,r4
800c7c8: b4 84 68 00 add r13,r4,r4
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
800c7cc: 5c 20 00 42 bne r1,r0,800c8d4 <rtems_task_mode+0x180>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
800c7d0: 41 92 00 08 lbu r18,(r12+8)
old_mode |= _ISR_Get_level();
800c7d4: fb ff ea 67 calli 8007170 <_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;
800c7d8: 66 52 00 00 cmpei r18,r18,0
800c7dc: c8 12 90 00 sub r18,r0,r18
800c7e0: 22 52 04 00 andi r18,r18,0x400
800c7e4: ba 41 08 00 or r1,r18,r1
old_mode |= _ISR_Get_level();
800c7e8: b8 2d 68 00 or r13,r1,r13
*previous_mode_set = old_mode;
800c7ec: 5a 2d 00 00 sw (r17+0),r13
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
800c7f0: 21 c1 01 00 andi r1,r14,0x100
800c7f4: 44 20 00 04 be r1,r0,800c804 <rtems_task_mode+0xb0>
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;
800c7f8: 22 01 01 00 andi r1,r16,0x100
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
800c7fc: 64 21 00 00 cmpei r1,r1,0
800c800: 31 61 00 74 sb (r11+116),r1
if ( mask & RTEMS_TIMESLICE_MASK ) {
800c804: 21 c1 02 00 andi r1,r14,0x200
800c808: 44 20 00 09 be r1,r0,800c82c <rtems_task_mode+0xd8>
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_timeslice (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_TIMESLICE_MASK) == RTEMS_TIMESLICE;
800c80c: 22 01 02 00 andi r1,r16,0x200
if ( _Modes_Is_timeslice(mode_set) ) {
800c810: 44 20 00 3e be r1,r0,800c908 <rtems_task_mode+0x1b4>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
800c814: 78 01 08 01 mvhi r1,0x801
800c818: 38 21 48 40 ori r1,r1,0x4840
800c81c: 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;
800c820: 34 01 00 01 mvi r1,1
800c824: 59 61 00 7c sw (r11+124),r1
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
800c828: 59 62 00 78 sw (r11+120),r2
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
800c82c: 21 c1 00 01 andi r1,r14,0x1
800c830: 44 20 00 04 be r1,r0,800c840 <rtems_task_mode+0xec>
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
800c834: 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 ) );
800c838: 64 21 00 00 cmpei r1,r1,0
800c83c: 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 ) {
800c840: 21 ce 04 00 andi r14,r14,0x400
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
800c844: 34 04 00 00 mvi r4,0
if ( mask & RTEMS_ASR_MASK ) {
800c848: 45 c0 00 11 be r14,r0,800c88c <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;
800c84c: 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 ) {
800c850: 41 81 00 08 lbu r1,(r12+8)
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
800c854: 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 ) {
800c858: 44 30 00 0d be r1,r16,800c88c <rtems_task_mode+0x138>
asr->is_enabled = is_asr_enabled;
800c85c: 31 90 00 08 sb (r12+8),r16
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
800c860: 90 00 08 00 rcsr r1,IE
800c864: 34 02 ff fe mvi r2,-2
800c868: a0 22 10 00 and r2,r1,r2
800c86c: d0 02 00 00 wcsr IE,r2
_signals = information->signals_pending;
800c870: 29 83 00 18 lw r3,(r12+24)
information->signals_pending = information->signals_posted;
800c874: 29 82 00 14 lw r2,(r12+20)
information->signals_posted = _signals;
800c878: 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;
800c87c: 59 82 00 18 sw (r12+24),r2
information->signals_posted = _signals;
_ISR_Enable( _level );
800c880: d0 01 00 00 wcsr IE,r1
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
800c884: 29 84 00 14 lw r4,(r12+20)
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
800c888: 7c 84 00 00 cmpnei r4,r4,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
800c88c: 78 01 08 01 mvhi r1,0x801
800c890: 38 21 4a 20 ori r1,r1,0x4a20
800c894: 28 23 00 00 lw r3,(r1+0)
800c898: 34 01 00 03 mvi r1,3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
800c89c: 34 02 00 00 mvi r2,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
800c8a0: 44 61 00 0f be r3,r1,800c8dc <rtems_task_mode+0x188> <== ALWAYS TAKEN
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
800c8a4: b8 40 08 00 mv r1,r2
800c8a8: 2b 9d 00 04 lw ra,(sp+4)
800c8ac: 2b 8b 00 24 lw r11,(sp+36)
800c8b0: 2b 8c 00 20 lw r12,(sp+32)
800c8b4: 2b 8d 00 1c lw r13,(sp+28)
800c8b8: 2b 8e 00 18 lw r14,(sp+24)
800c8bc: 2b 8f 00 14 lw r15,(sp+20)
800c8c0: 2b 90 00 10 lw r16,(sp+16)
800c8c4: 2b 91 00 0c lw r17,(sp+12)
800c8c8: 2b 92 00 08 lw r18,(sp+8)
800c8cc: 37 9c 00 24 addi sp,sp,36
800c8d0: 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;
800c8d4: 39 ad 02 00 ori r13,r13,0x200
800c8d8: e3 ff ff be bi 800c7d0 <rtems_task_mode+0x7c>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
800c8dc: 29 e1 00 0c lw r1,(r15+12)
if ( are_signals_pending ||
800c8e0: 5c 80 00 05 bne r4,r0,800c8f4 <rtems_task_mode+0x1a0>
800c8e4: 29 e3 00 10 lw r3,(r15+16)
800c8e8: 44 23 ff ef be r1,r3,800c8a4 <rtems_task_mode+0x150>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
800c8ec: 40 21 00 74 lbu r1,(r1+116)
800c8f0: 44 20 ff ed be r1,r0,800c8a4 <rtems_task_mode+0x150> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
800c8f4: 34 01 00 01 mvi r1,1
800c8f8: 31 e1 00 18 sb (r15+24),r1
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
800c8fc: fb ff e3 85 calli 8005710 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
800c900: 34 02 00 00 mvi r2,0
800c904: e3 ff ff e8 bi 800c8a4 <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;
800c908: 59 60 00 7c sw (r11+124),r0
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
800c90c: 21 c1 00 01 andi r1,r14,0x1
800c910: 44 20 ff cc be r1,r0,800c840 <rtems_task_mode+0xec>
800c914: e3 ff ff c8 bi 800c834 <rtems_task_mode+0xe0>
08008bdc <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
8008bdc: 37 9c ff f0 addi sp,sp,-16
8008be0: 5b 8b 00 0c sw (sp+12),r11
8008be4: 5b 8c 00 08 sw (sp+8),r12
8008be8: 5b 9d 00 04 sw (sp+4),ra
8008bec: b8 40 58 00 mv r11,r2
8008bf0: b8 60 60 00 mv r12,r3
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
8008bf4: 44 40 00 06 be r2,r0,8008c0c <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 ) );
8008bf8: 78 02 08 01 mvhi r2,0x801
8008bfc: 38 42 b0 c0 ori r2,r2,0xb0c0
8008c00: 40 42 00 00 lbu r2,(r2+0)
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
8008c04: 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 ) &&
8008c08: 55 62 00 08 bgu r11,r2,8008c28 <rtems_task_set_priority+0x4c>
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
8008c0c: 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 )
8008c10: 45 80 00 06 be r12,r0,8008c28 <rtems_task_set_priority+0x4c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
8008c14: 37 82 00 10 addi r2,sp,16
8008c18: f8 00 0a bc calli 800b708 <_Thread_Get>
switch ( location ) {
8008c1c: 2b 82 00 10 lw r2,(sp+16)
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8008c20: 34 04 00 04 mvi r4,4
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
8008c24: 44 40 00 07 be r2,r0,8008c40 <rtems_task_set_priority+0x64>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8008c28: b8 80 08 00 mv r1,r4
8008c2c: 2b 9d 00 04 lw ra,(sp+4)
8008c30: 2b 8b 00 0c lw r11,(sp+12)
8008c34: 2b 8c 00 08 lw r12,(sp+8)
8008c38: 37 9c 00 10 addi sp,sp,16
8008c3c: 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;
8008c40: 28 23 00 14 lw r3,(r1+20)
8008c44: 59 83 00 00 sw (r12+0),r3
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
8008c48: 45 62 00 09 be r11,r2,8008c6c <rtems_task_set_priority+0x90>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
8008c4c: 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;
8008c50: 58 2b 00 18 sw (r1+24),r11
if ( the_thread->resource_count == 0 ||
8008c54: 44 40 00 03 be r2,r0,8008c60 <rtems_task_set_priority+0x84>
8008c58: 28 22 00 14 lw r2,(r1+20)
8008c5c: 51 62 00 04 bgeu r11,r2,8008c6c <rtems_task_set_priority+0x90><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
8008c60: b9 60 10 00 mv r2,r11
8008c64: 34 03 00 00 mvi r3,0
8008c68: f8 00 09 1e calli 800b0e0 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
8008c6c: f8 00 0a 9a calli 800b6d4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8008c70: 34 04 00 00 mvi r4,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8008c74: b8 80 08 00 mv r1,r4
8008c78: 2b 9d 00 04 lw ra,(sp+4)
8008c7c: 2b 8b 00 0c lw r11,(sp+12)
8008c80: 2b 8c 00 08 lw r12,(sp+8)
8008c84: 37 9c 00 10 addi sp,sp,16
8008c88: c3 a0 00 00 ret
08003248 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
8003248: 37 9c ff ec addi sp,sp,-20
800324c: 5b 8b 00 10 sw (sp+16),r11
8003250: 5b 8c 00 0c sw (sp+12),r12
8003254: 5b 8d 00 08 sw (sp+8),r13
8003258: 5b 9d 00 04 sw (sp+4),ra
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
800325c: 34 04 00 09 mvi r4,9
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
8003260: b8 40 58 00 mv r11,r2
8003264: b8 60 68 00 mv r13,r3
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
8003268: 44 40 00 06 be r2,r0,8003280 <rtems_task_start+0x38> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
800326c: 37 82 00 14 addi r2,sp,20
8003270: f8 00 09 a3 calli 80058fc <_Thread_Get>
switch ( location ) {
8003274: 2b 8c 00 14 lw r12,(sp+20)
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8003278: 34 04 00 04 mvi r4,4
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
800327c: 45 80 00 08 be r12,r0,800329c <rtems_task_start+0x54>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8003280: b8 80 08 00 mv r1,r4
8003284: 2b 9d 00 04 lw ra,(sp+4)
8003288: 2b 8b 00 10 lw r11,(sp+16)
800328c: 2b 8c 00 0c lw r12,(sp+12)
8003290: 2b 8d 00 08 lw r13,(sp+8)
8003294: 37 9c 00 14 addi sp,sp,20
8003298: c3 a0 00 00 ret
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
800329c: 34 02 00 00 mvi r2,0
80032a0: b9 60 18 00 mv r3,r11
80032a4: 34 04 00 00 mvi r4,0
80032a8: b9 a0 28 00 mv r5,r13
80032ac: f8 00 0c b6 calli 8006584 <_Thread_Start>
80032b0: 5c 2c 00 0a bne r1,r12,80032d8 <rtems_task_start+0x90>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
80032b4: f8 00 09 85 calli 80058c8 <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
80032b8: 34 04 00 0e mvi r4,14
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80032bc: b8 80 08 00 mv r1,r4
80032c0: 2b 9d 00 04 lw ra,(sp+4)
80032c4: 2b 8b 00 10 lw r11,(sp+16)
80032c8: 2b 8c 00 0c lw r12,(sp+12)
80032cc: 2b 8d 00 08 lw r13,(sp+8)
80032d0: 37 9c 00 14 addi sp,sp,20
80032d4: c3 a0 00 00 ret
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
80032d8: f8 00 09 7c calli 80058c8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80032dc: 34 04 00 00 mvi r4,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80032e0: b8 80 08 00 mv r1,r4
80032e4: 2b 9d 00 04 lw ra,(sp+4)
80032e8: 2b 8b 00 10 lw r11,(sp+16)
80032ec: 2b 8c 00 0c lw r12,(sp+12)
80032f0: 2b 8d 00 08 lw r13,(sp+8)
80032f4: 37 9c 00 14 addi sp,sp,20
80032f8: c3 a0 00 00 ret
08004118 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
8004118: 37 9c ff ec addi sp,sp,-20
800411c: 5b 8b 00 10 sw (sp+16),r11
8004120: 5b 8c 00 0c sw (sp+12),r12
8004124: 5b 8d 00 08 sw (sp+8),r13
8004128: 5b 9d 00 04 sw (sp+4),ra
800412c: b8 40 58 00 mv r11,r2
8004130: 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;
8004134: 34 02 00 09 mvi r2,9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
8004138: 45 60 00 07 be r11,r0,8004154 <rtems_task_variable_add+0x3c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
800413c: 37 82 00 14 addi r2,sp,20
8004140: f8 00 09 a3 calli 80067cc <_Thread_Get>
8004144: b8 20 60 00 mv r12,r1
switch (location) {
8004148: 2b 81 00 14 lw r1,(sp+20)
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
800414c: 34 02 00 04 mvi r2,4
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
8004150: 44 20 00 08 be r1,r0,8004170 <rtems_task_variable_add+0x58>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8004154: b8 40 08 00 mv r1,r2
8004158: 2b 9d 00 04 lw ra,(sp+4)
800415c: 2b 8b 00 10 lw r11,(sp+16)
8004160: 2b 8c 00 0c lw r12,(sp+12)
8004164: 2b 8d 00 08 lw r13,(sp+8)
8004168: 37 9c 00 14 addi sp,sp,20
800416c: 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;
8004170: 29 84 01 28 lw r4,(r12+296)
while (tvp) {
8004174: 44 81 00 08 be r4,r1,8004194 <rtems_task_variable_add+0x7c>
if (tvp->ptr == ptr) {
8004178: 28 81 00 04 lw r1,(r4+4)
800417c: 5c 2b 00 04 bne r1,r11,800418c <rtems_task_variable_add+0x74>
8004180: e0 00 00 18 bi 80041e0 <rtems_task_variable_add+0xc8>
8004184: 28 82 00 04 lw r2,(r4+4)
8004188: 44 4b 00 16 be r2,r11,80041e0 <rtems_task_variable_add+0xc8><== NEVER TAKEN
tvp->dtor = dtor;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
800418c: 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) {
8004190: 5c 80 ff fd bne r4,r0,8004184 <rtems_task_variable_add+0x6c>
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
8004194: 34 01 00 14 mvi r1,20
8004198: f8 00 0f 07 calli 8007db4 <_Workspace_Allocate>
if (new == NULL) {
800419c: 44 20 00 1b be r1,r0,8004208 <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;
80041a0: 29 82 01 28 lw r2,(r12+296)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
80041a4: 29 63 00 00 lw r3,(r11+0)
new->ptr = ptr;
80041a8: 58 2b 00 04 sw (r1+4),r11
new->dtor = dtor;
80041ac: 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;
80041b0: 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;
80041b4: 58 22 00 00 sw (r1+0),r2
the_thread->task_variables = new;
80041b8: 59 81 01 28 sw (r12+296),r1
_Thread_Enable_dispatch();
80041bc: f8 00 09 77 calli 8006798 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80041c0: 34 02 00 00 mvi r2,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80041c4: b8 40 08 00 mv r1,r2
80041c8: 2b 9d 00 04 lw ra,(sp+4)
80041cc: 2b 8b 00 10 lw r11,(sp+16)
80041d0: 2b 8c 00 0c lw r12,(sp+12)
80041d4: 2b 8d 00 08 lw r13,(sp+8)
80041d8: 37 9c 00 14 addi sp,sp,20
80041dc: 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;
80041e0: 58 8d 00 10 sw (r4+16),r13
_Thread_Enable_dispatch();
80041e4: f8 00 09 6d calli 8006798 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80041e8: 34 02 00 00 mvi r2,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80041ec: b8 40 08 00 mv r1,r2
80041f0: 2b 9d 00 04 lw ra,(sp+4)
80041f4: 2b 8b 00 10 lw r11,(sp+16)
80041f8: 2b 8c 00 0c lw r12,(sp+12)
80041fc: 2b 8d 00 08 lw r13,(sp+8)
8004200: 37 9c 00 14 addi sp,sp,20
8004204: 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();
8004208: f8 00 09 64 calli 8006798 <_Thread_Enable_dispatch>
return RTEMS_NO_MEMORY;
800420c: 34 02 00 1a mvi r2,26
8004210: e3 ff ff d1 bi 8004154 <rtems_task_variable_add+0x3c>
08004214 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
8004214: 37 9c ff f4 addi sp,sp,-12
8004218: 5b 8b 00 08 sw (sp+8),r11
800421c: 5b 9d 00 04 sw (sp+4),ra
8004220: 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;
8004224: 34 02 00 09 mvi r2,9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
8004228: 45 60 00 06 be r11,r0,8004240 <rtems_task_variable_delete+0x2c>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
800422c: 37 82 00 0c addi r2,sp,12
8004230: f8 00 09 67 calli 80067cc <_Thread_Get>
switch (location) {
8004234: 2b 82 00 0c lw r2,(sp+12)
8004238: 44 40 00 07 be r2,r0,8004254 <rtems_task_variable_delete+0x40>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
800423c: 34 02 00 04 mvi r2,4
}
8004240: b8 40 08 00 mv r1,r2
8004244: 2b 9d 00 04 lw ra,(sp+4)
8004248: 2b 8b 00 08 lw r11,(sp+8)
800424c: 37 9c 00 0c addi sp,sp,12
8004250: c3 a0 00 00 ret
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
8004254: 28 24 01 28 lw r4,(r1+296)
while (tvp) {
8004258: 44 82 00 09 be r4,r2,800427c <rtems_task_variable_delete+0x68>
if (tvp->ptr == ptr) {
800425c: 28 82 00 04 lw r2,(r4+4)
8004260: 5c 4b 00 05 bne r2,r11,8004274 <rtems_task_variable_delete+0x60>
8004264: e0 00 00 18 bi 80042c4 <rtems_task_variable_delete+0xb0>
8004268: 28 62 00 04 lw r2,(r3+4)
800426c: 44 4b 00 0b be r2,r11,8004298 <rtems_task_variable_delete+0x84>
8004270: 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;
8004274: 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) {
8004278: 5c 60 ff fc bne r3,r0,8004268 <rtems_task_variable_delete+0x54><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
800427c: f8 00 09 47 calli 8006798 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
8004280: 34 02 00 09 mvi r2,9
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8004284: b8 40 08 00 mv r1,r2
8004288: 2b 9d 00 04 lw ra,(sp+4)
800428c: 2b 8b 00 08 lw r11,(sp+8)
8004290: 37 9c 00 0c addi sp,sp,12
8004294: 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;
8004298: 28 62 00 00 lw r2,(r3+0)
800429c: 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 );
80042a0: b8 60 10 00 mv r2,r3
80042a4: f8 00 00 39 calli 8004388 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
80042a8: f8 00 09 3c calli 8006798 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
80042ac: 34 02 00 00 mvi r2,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80042b0: b8 40 08 00 mv r1,r2
80042b4: 2b 9d 00 04 lw ra,(sp+4)
80042b8: 2b 8b 00 08 lw r11,(sp+8)
80042bc: 37 9c 00 0c addi sp,sp,12
80042c0: 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;
80042c4: 28 82 00 00 lw r2,(r4+0)
80042c8: b8 80 18 00 mv r3,r4
80042cc: 58 22 01 28 sw (r1+296),r2
80042d0: e3 ff ff f4 bi 80042a0 <rtems_task_variable_delete+0x8c>
080042d4 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
80042d4: 37 9c ff f0 addi sp,sp,-16
80042d8: 5b 8b 00 0c sw (sp+12),r11
80042dc: 5b 8c 00 08 sw (sp+8),r12
80042e0: 5b 9d 00 04 sw (sp+4),ra
80042e4: b8 40 58 00 mv r11,r2
80042e8: 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;
80042ec: 34 02 00 09 mvi r2,9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
80042f0: 45 60 00 07 be r11,r0,800430c <rtems_task_variable_get+0x38>
return RTEMS_INVALID_ADDRESS;
if ( !result )
80042f4: 44 60 00 06 be r3,r0,800430c <rtems_task_variable_get+0x38>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
80042f8: 37 82 00 10 addi r2,sp,16
80042fc: f8 00 09 34 calli 80067cc <_Thread_Get>
switch (location) {
8004300: 2b 82 00 10 lw r2,(sp+16)
8004304: 44 40 00 08 be r2,r0,8004324 <rtems_task_variable_get+0x50>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8004308: 34 02 00 04 mvi r2,4
}
800430c: b8 40 08 00 mv r1,r2
8004310: 2b 9d 00 04 lw ra,(sp+4)
8004314: 2b 8b 00 0c lw r11,(sp+12)
8004318: 2b 8c 00 08 lw r12,(sp+8)
800431c: 37 9c 00 10 addi sp,sp,16
8004320: c3 a0 00 00 ret
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
8004324: 28 21 01 28 lw r1,(r1+296)
while (tvp) {
8004328: 5c 22 00 04 bne r1,r2,8004338 <rtems_task_variable_get+0x64>
800432c: e0 00 00 0f bi 8004368 <rtems_task_variable_get+0x94>
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
8004330: 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) {
8004334: 44 20 00 0d be r1,r0,8004368 <rtems_task_variable_get+0x94><== NEVER TAKEN
if (tvp->ptr == ptr) {
8004338: 28 22 00 04 lw r2,(r1+4)
800433c: 5c 4b ff fd bne r2,r11,8004330 <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;
8004340: 28 21 00 0c lw r1,(r1+12)
8004344: 59 81 00 00 sw (r12+0),r1
_Thread_Enable_dispatch();
8004348: f8 00 09 14 calli 8006798 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
800434c: 34 02 00 00 mvi r2,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8004350: b8 40 08 00 mv r1,r2
8004354: 2b 9d 00 04 lw ra,(sp+4)
8004358: 2b 8b 00 0c lw r11,(sp+12)
800435c: 2b 8c 00 08 lw r12,(sp+8)
8004360: 37 9c 00 10 addi sp,sp,16
8004364: c3 a0 00 00 ret
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
8004368: f8 00 09 0c calli 8006798 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
800436c: 34 02 00 09 mvi r2,9
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8004370: b8 40 08 00 mv r1,r2
8004374: 2b 9d 00 04 lw ra,(sp+4)
8004378: 2b 8b 00 0c lw r11,(sp+12)
800437c: 2b 8c 00 08 lw r12,(sp+8)
8004380: 37 9c 00 10 addi sp,sp,16
8004384: c3 a0 00 00 ret
08013bf8 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
8013bf8: 37 9c ff f8 addi sp,sp,-8
8013bfc: 5b 9d 00 04 sw (sp+4),ra
8013c00: b8 20 10 00 mv r2,r1
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
8013c04: 78 01 08 04 mvhi r1,0x804
8013c08: 38 21 15 b4 ori r1,r1,0x15b4
8013c0c: 37 83 00 08 addi r3,sp,8
8013c10: f8 00 0e 9c calli 8017680 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
8013c14: 2b 82 00 08 lw r2,(sp+8)
8013c18: 44 40 00 05 be r2,r0,8013c2c <rtems_timer_cancel+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8013c1c: 34 01 00 04 mvi r1,4
}
8013c20: 2b 9d 00 04 lw ra,(sp+4)
8013c24: 37 9c 00 08 addi sp,sp,8
8013c28: 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 ) )
8013c2c: 28 23 00 38 lw r3,(r1+56)
8013c30: 34 02 00 04 mvi r2,4
8013c34: 44 62 00 03 be r3,r2,8013c40 <rtems_timer_cancel+0x48> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
8013c38: 34 21 00 10 addi r1,r1,16
8013c3c: f8 00 18 7c calli 8019e2c <_Watchdog_Remove>
_Thread_Enable_dispatch();
8013c40: f8 00 12 67 calli 80185dc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
8013c44: 34 01 00 00 mvi r1,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
8013c48: 2b 9d 00 04 lw ra,(sp+4)
8013c4c: 37 9c 00 08 addi sp,sp,8
8013c50: c3 a0 00 00 ret
08014274 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
8014274: 37 9c ff dc addi sp,sp,-36
8014278: 5b 8b 00 20 sw (sp+32),r11
801427c: 5b 8c 00 1c sw (sp+28),r12
8014280: 5b 8d 00 18 sw (sp+24),r13
8014284: 5b 8e 00 14 sw (sp+20),r14
8014288: 5b 8f 00 10 sw (sp+16),r15
801428c: 5b 90 00 0c sw (sp+12),r16
8014290: 5b 91 00 08 sw (sp+8),r17
8014294: 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;
8014298: 78 05 08 04 mvhi r5,0x804
801429c: 38 a5 15 f4 ori r5,r5,0x15f4
80142a0: 28 ac 00 00 lw r12,(r5+0)
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
80142a4: b8 20 80 00 mv r16,r1
80142a8: b8 40 70 00 mv r14,r2
80142ac: b8 60 78 00 mv r15,r3
80142b0: 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;
80142b4: 34 0b 00 0e mvi r11,14
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
80142b8: 45 80 00 0c be r12,r0,80142e8 <rtems_timer_server_fire_when+0x74>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
80142bc: 78 05 08 04 mvhi r5,0x804
80142c0: 38 a5 0c c0 ori r5,r5,0xcc0
80142c4: 40 a5 00 00 lbu r5,(r5+0)
return RTEMS_NOT_DEFINED;
80142c8: 34 0b 00 0b mvi r11,11
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
80142cc: 44 a0 00 07 be r5,r0,80142e8 <rtems_timer_server_fire_when+0x74><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
80142d0: 34 0b 00 09 mvi r11,9
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
80142d4: 44 60 00 05 be r3,r0,80142e8 <rtems_timer_server_fire_when+0x74>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
80142d8: b8 40 08 00 mv r1,r2
80142dc: fb ff f0 af calli 8010598 <_TOD_Validate>
return RTEMS_INVALID_CLOCK;
80142e0: 34 0b 00 14 mvi r11,20
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
80142e4: 5c 20 00 0c bne r1,r0,8014314 <rtems_timer_server_fire_when+0xa0>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
80142e8: b9 60 08 00 mv r1,r11
80142ec: 2b 9d 00 04 lw ra,(sp+4)
80142f0: 2b 8b 00 20 lw r11,(sp+32)
80142f4: 2b 8c 00 1c lw r12,(sp+28)
80142f8: 2b 8d 00 18 lw r13,(sp+24)
80142fc: 2b 8e 00 14 lw r14,(sp+20)
8014300: 2b 8f 00 10 lw r15,(sp+16)
8014304: 2b 90 00 0c lw r16,(sp+12)
8014308: 2b 91 00 08 lw r17,(sp+8)
801430c: 37 9c 00 24 addi sp,sp,36
8014310: c3 a0 00 00 ret
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
8014314: b9 c0 08 00 mv r1,r14
if ( seconds <= _TOD_Seconds_since_epoch() )
8014318: 78 0d 08 04 mvhi r13,0x804
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
801431c: fb ff f0 46 calli 8010434 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
8014320: 39 ad 0d 58 ori r13,r13,0xd58
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
8014324: b8 20 70 00 mv r14,r1
if ( seconds <= _TOD_Seconds_since_epoch() )
8014328: 29 a1 00 00 lw r1,(r13+0)
801432c: 50 2e ff ef bgeu r1,r14,80142e8 <rtems_timer_server_fire_when+0x74>
8014330: 78 01 08 04 mvhi r1,0x804
8014334: 38 21 15 b4 ori r1,r1,0x15b4
8014338: ba 00 10 00 mv r2,r16
801433c: 37 83 00 24 addi r3,sp,36
8014340: f8 00 0c d0 calli 8017680 <_Objects_Get>
8014344: b8 20 58 00 mv r11,r1
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
8014348: 2b 81 00 24 lw r1,(sp+36)
801434c: 44 20 00 03 be r1,r0,8014358 <rtems_timer_server_fire_when+0xe4>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
8014350: 34 0b 00 04 mvi r11,4
8014354: e3 ff ff e5 bi 80142e8 <rtems_timer_server_fire_when+0x74>
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
8014358: 35 61 00 10 addi r1,r11,16
801435c: f8 00 16 b4 calli 8019e2c <_Watchdog_Remove>
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();
8014360: 29 a1 00 00 lw r1,(r13+0)
(*timer_server->schedule_operation)( timer_server, the_timer );
8014364: 29 83 00 04 lw r3,(r12+4)
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
8014368: 34 04 00 03 mvi r4,3
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
801436c: c9 c1 70 00 sub r14,r14,r1
(*timer_server->schedule_operation)( timer_server, the_timer );
8014370: b9 60 10 00 mv r2,r11
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
8014374: 59 64 00 38 sw (r11+56),r4
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
8014378: 59 6f 00 2c sw (r11+44),r15
the_watchdog->id = id;
801437c: 59 70 00 30 sw (r11+48),r16
the_watchdog->user_data = user_data;
8014380: 59 71 00 34 sw (r11+52),r17
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
8014384: 59 6e 00 1c sw (r11+28),r14
(*timer_server->schedule_operation)( timer_server, the_timer );
8014388: b9 80 08 00 mv r1,r12
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
801438c: 59 60 00 18 sw (r11+24),r0
8014390: d8 60 00 00 call r3
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
8014394: 34 0b 00 00 mvi r11,0
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
(*timer_server->schedule_operation)( timer_server, the_timer );
_Thread_Enable_dispatch();
8014398: f8 00 10 91 calli 80185dc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
801439c: e3 ff ff d3 bi 80142e8 <rtems_timer_server_fire_when+0x74>
08003d1c <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
8003d1c: 37 9c ff fc addi sp,sp,-4
8003d20: 5b 9d 00 04 sw (sp+4),ra
switch ( policy ) {
8003d24: 48 01 00 05 bg r0,r1,8003d38 <sched_get_priority_max+0x1c>
8003d28: 34 02 00 02 mvi r2,2
8003d2c: 4c 41 00 08 bge r2,r1,8003d4c <sched_get_priority_max+0x30>
8003d30: 34 02 00 04 mvi r2,4
8003d34: 44 22 00 06 be r1,r2,8003d4c <sched_get_priority_max+0x30> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
8003d38: f8 00 27 d0 calli 800dc78 <__errno>
8003d3c: 34 02 00 16 mvi r2,22
8003d40: 58 22 00 00 sw (r1+0),r2
8003d44: 34 01 ff ff mvi r1,-1
8003d48: e0 00 00 05 bi 8003d5c <sched_get_priority_max+0x40>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
8003d4c: 78 01 08 01 mvhi r1,0x801
8003d50: 38 21 f0 e4 ori r1,r1,0xf0e4
8003d54: 40 21 00 00 lbu r1,(r1+0)
8003d58: 34 21 ff ff addi r1,r1,-1
}
8003d5c: 2b 9d 00 04 lw ra,(sp+4)
8003d60: 37 9c 00 04 addi sp,sp,4
8003d64: c3 a0 00 00 ret
08003d68 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
8003d68: 37 9c ff fc addi sp,sp,-4
8003d6c: 5b 9d 00 04 sw (sp+4),ra
switch ( policy ) {
8003d70: 48 01 00 05 bg r0,r1,8003d84 <sched_get_priority_min+0x1c>
8003d74: 34 02 00 02 mvi r2,2
8003d78: 4c 41 00 08 bge r2,r1,8003d98 <sched_get_priority_min+0x30><== ALWAYS TAKEN
8003d7c: 34 02 00 04 mvi r2,4 <== NOT EXECUTED
8003d80: 44 22 00 06 be r1,r2,8003d98 <sched_get_priority_min+0x30> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
8003d84: f8 00 27 bd calli 800dc78 <__errno>
8003d88: 34 02 00 16 mvi r2,22
8003d8c: 58 22 00 00 sw (r1+0),r2
8003d90: 34 01 ff ff mvi r1,-1
8003d94: e0 00 00 02 bi 8003d9c <sched_get_priority_min+0x34>
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
8003d98: 34 01 00 01 mvi r1,1
}
8003d9c: 2b 9d 00 04 lw ra,(sp+4)
8003da0: 37 9c 00 04 addi sp,sp,4
8003da4: c3 a0 00 00 ret
08003da8 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
8003da8: 37 9c ff f4 addi sp,sp,-12
8003dac: 5b 8b 00 08 sw (sp+8),r11
8003db0: 5b 9d 00 04 sw (sp+4),ra
8003db4: b8 20 58 00 mv r11,r1
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
8003db8: 5c 20 00 0b bne r1,r0,8003de4 <sched_rr_get_interval+0x3c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
8003dbc: 44 40 00 13 be r2,r0,8003e08 <sched_rr_get_interval+0x60>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
8003dc0: 78 01 08 01 mvhi r1,0x801
8003dc4: 38 21 f7 f0 ori r1,r1,0xf7f0
8003dc8: 28 21 00 00 lw r1,(r1+0)
8003dcc: f8 00 0e 6b calli 8007778 <_Timespec_From_ticks>
return 0;
8003dd0: 34 01 00 00 mvi r1,0
}
8003dd4: 2b 9d 00 04 lw ra,(sp+4)
8003dd8: 2b 8b 00 08 lw r11,(sp+8)
8003ddc: 37 9c 00 0c addi sp,sp,12
8003de0: c3 a0 00 00 ret
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
8003de4: 5b 82 00 0c sw (sp+12),r2
8003de8: fb ff f8 21 calli 8001e6c <getpid>
8003dec: 2b 82 00 0c lw r2,(sp+12)
8003df0: 44 2b ff f3 be r1,r11,8003dbc <sched_rr_get_interval+0x14>
rtems_set_errno_and_return_minus_one( ESRCH );
8003df4: f8 00 27 a1 calli 800dc78 <__errno>
8003df8: 34 02 00 03 mvi r2,3
8003dfc: 58 22 00 00 sw (r1+0),r2
8003e00: 34 01 ff ff mvi r1,-1
8003e04: e3 ff ff f4 bi 8003dd4 <sched_rr_get_interval+0x2c>
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
8003e08: f8 00 27 9c calli 800dc78 <__errno>
8003e0c: 34 02 00 16 mvi r2,22
8003e10: 58 22 00 00 sw (r1+0),r2
8003e14: 34 01 ff ff mvi r1,-1
8003e18: e3 ff ff ef bi 8003dd4 <sched_rr_get_interval+0x2c>
08006190 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
8006190: 37 9c ff c0 addi sp,sp,-64
8006194: 5b 8b 00 18 sw (sp+24),r11
8006198: 5b 8c 00 14 sw (sp+20),r12
800619c: 5b 8d 00 10 sw (sp+16),r13
80061a0: 5b 8e 00 0c sw (sp+12),r14
80061a4: 5b 8f 00 08 sw (sp+8),r15
80061a8: 5b 9d 00 04 sw (sp+4),ra
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
80061ac: 78 09 08 02 mvhi r9,0x802
80061b0: 39 29 4a 50 ori r9,r9,0x4a50
80061b4: 29 2a 00 00 lw r10,(r9+0)
80061b8: b8 20 70 00 mv r14,r1
80061bc: 5b 82 00 28 sw (sp+40),r2
80061c0: 35 41 00 01 addi r1,r10,1
80061c4: 5b 83 00 2c sw (sp+44),r3
80061c8: 5b 84 00 30 sw (sp+48),r4
80061cc: 5b 85 00 34 sw (sp+52),r5
80061d0: 5b 86 00 38 sw (sp+56),r6
80061d4: 5b 87 00 3c sw (sp+60),r7
80061d8: 5b 88 00 40 sw (sp+64),r8
80061dc: b8 40 60 00 mv r12,r2
80061e0: 59 21 00 00 sw (r9+0),r1
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
80061e4: 20 4d 02 00 andi r13,r2,0x200
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
80061e8: 34 0f 00 00 mvi r15,0
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
80061ec: 5d a0 00 2d bne r13,r0,80062a0 <sem_open+0x110>
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
80061f0: b9 c0 08 00 mv r1,r14
80061f4: 37 82 00 24 addi r2,sp,36
80061f8: f8 00 1b f7 calli 800d1d4 <_POSIX_Semaphore_Name_to_id>
80061fc: b8 20 58 00 mv r11,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 ) {
8006200: 44 20 00 10 be r1,r0,8006240 <sem_open+0xb0>
/*
* 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) ) ) {
8006204: 34 01 00 02 mvi r1,2
8006208: 5d 61 00 02 bne r11,r1,8006210 <sem_open+0x80> <== NEVER TAKEN
800620c: 5d a0 00 27 bne r13,r0,80062a8 <sem_open+0x118>
_Thread_Enable_dispatch();
8006210: f8 00 0b 14 calli 8008e60 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
8006214: f8 00 2b cd calli 8011148 <__errno>
8006218: 58 2b 00 00 sw (r1+0),r11
800621c: 34 01 ff ff mvi r1,-1
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
8006220: 2b 9d 00 04 lw ra,(sp+4)
8006224: 2b 8b 00 18 lw r11,(sp+24)
8006228: 2b 8c 00 14 lw r12,(sp+20)
800622c: 2b 8d 00 10 lw r13,(sp+16)
8006230: 2b 8e 00 0c lw r14,(sp+12)
8006234: 2b 8f 00 08 lw r15,(sp+8)
8006238: 37 9c 00 40 addi sp,sp,64
800623c: c3 a0 00 00 ret
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
8006240: 21 8c 0a 00 andi r12,r12,0xa00
8006244: 34 01 0a 00 mvi r1,2560
8006248: 45 81 00 22 be r12,r1,80062d0 <sem_open+0x140>
800624c: 2b 82 00 24 lw r2,(sp+36)
8006250: 78 01 08 02 mvhi r1,0x802
8006254: 37 83 00 1c addi r3,sp,28
8006258: 38 21 4c a4 ori r1,r1,0x4ca4
800625c: f8 00 07 9b calli 80080c8 <_Objects_Get>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
8006260: 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( &the_semaphore_id, &location );
8006264: 5b 81 00 20 sw (sp+32),r1
the_semaphore->open_count += 1;
8006268: 34 42 00 01 addi r2,r2,1
800626c: 58 22 00 18 sw (r1+24),r2
_Thread_Enable_dispatch();
8006270: f8 00 0a fc calli 8008e60 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
8006274: f8 00 0a fb calli 8008e60 <_Thread_Enable_dispatch>
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
8006278: 2b 81 00 20 lw r1,(sp+32)
800627c: 34 21 00 08 addi r1,r1,8
#endif
return id;
}
8006280: 2b 9d 00 04 lw ra,(sp+4)
8006284: 2b 8b 00 18 lw r11,(sp+24)
8006288: 2b 8c 00 14 lw r12,(sp+20)
800628c: 2b 8d 00 10 lw r13,(sp+16)
8006290: 2b 8e 00 0c lw r14,(sp+12)
8006294: 2b 8f 00 08 lw r15,(sp+8)
8006298: 37 9c 00 40 addi sp,sp,64
800629c: c3 a0 00 00 ret
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
80062a0: 2b 8f 00 30 lw r15,(sp+48)
80062a4: e3 ff ff d3 bi 80061f0 <sem_open+0x60>
/*
* 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(
80062a8: 34 02 00 00 mvi r2,0
80062ac: b9 e0 18 00 mv r3,r15
80062b0: 37 84 00 20 addi r4,sp,32
80062b4: b9 c0 08 00 mv r1,r14
80062b8: f8 00 1b 59 calli 800d01c <_POSIX_Semaphore_Create_support>
80062bc: b8 20 58 00 mv r11,r1
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
80062c0: f8 00 0a e8 calli 8008e60 <_Thread_Enable_dispatch>
if ( status == -1 )
return SEM_FAILED;
80062c4: 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 )
80062c8: 5d 61 ff ec bne r11,r1,8006278 <sem_open+0xe8>
80062cc: e3 ff ff ed bi 8006280 <sem_open+0xf0>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
80062d0: f8 00 0a e4 calli 8008e60 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
80062d4: f8 00 2b 9d calli 8011148 <__errno>
80062d8: 34 02 00 11 mvi r2,17
80062dc: 58 22 00 00 sw (r1+0),r2
80062e0: 34 01 ff ff mvi r1,-1
80062e4: e3 ff ff e7 bi 8006280 <sem_open+0xf0>
0800634c <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
800634c: 37 9c ff f4 addi sp,sp,-12
8006350: 5b 8b 00 08 sw (sp+8),r11
8006354: 5b 9d 00 04 sw (sp+4),ra
8006358: 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 );
800635c: b8 40 08 00 mv r1,r2
8006360: 37 82 00 0c addi r2,sp,12
8006364: f8 00 17 ee calli 800c31c <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
8006368: 34 02 00 03 mvi r2,3
800636c: 44 22 00 09 be r1,r2,8006390 <sem_timedwait+0x44> <== ALWAYS TAKEN
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
8006370: 2b 83 00 0c lw r3,(sp+12) <== NOT EXECUTED
8006374: b9 60 08 00 mv r1,r11 <== NOT EXECUTED
8006378: 34 02 00 00 mvi r2,0 <== NOT EXECUTED
800637c: f8 00 1b bc calli 800d26c <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
8006380: 2b 9d 00 04 lw ra,(sp+4) <== NOT EXECUTED
8006384: 2b 8b 00 08 lw r11,(sp+8) <== NOT EXECUTED
8006388: 37 9c 00 0c addi sp,sp,12 <== NOT EXECUTED
800638c: 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 );
8006390: 2b 83 00 0c lw r3,(sp+12)
8006394: b9 60 08 00 mv r1,r11
8006398: 34 02 00 01 mvi r2,1
800639c: f8 00 1b b4 calli 800d26c <_POSIX_Semaphore_Wait_support>
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
80063a0: 2b 9d 00 04 lw ra,(sp+4)
80063a4: 2b 8b 00 08 lw r11,(sp+8)
80063a8: 37 9c 00 0c addi sp,sp,12
80063ac: c3 a0 00 00 ret
08003c74 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
8003c74: 37 9c ff f0 addi sp,sp,-16
8003c78: 5b 8b 00 10 sw (sp+16),r11
8003c7c: 5b 8c 00 0c sw (sp+12),r12
8003c80: 5b 8d 00 08 sw (sp+8),r13
8003c84: 5b 9d 00 04 sw (sp+4),ra
8003c88: b8 20 58 00 mv r11,r1
8003c8c: b8 40 60 00 mv r12,r2
ISR_Level level;
if ( oact )
8003c90: 44 60 00 0e be r3,r0,8003cc8 <sigaction+0x54>
*oact = _POSIX_signals_Vectors[ sig ];
8003c94: b4 21 08 00 add r1,r1,r1
8003c98: b4 2b 08 00 add r1,r1,r11
8003c9c: 78 02 08 02 mvhi r2,0x802
8003ca0: b4 21 08 00 add r1,r1,r1
8003ca4: 38 42 0d d0 ori r2,r2,0xdd0
8003ca8: b4 21 08 00 add r1,r1,r1
8003cac: b4 41 08 00 add r1,r2,r1
8003cb0: 28 22 00 00 lw r2,(r1+0)
8003cb4: 58 62 00 00 sw (r3+0),r2
8003cb8: 28 22 00 04 lw r2,(r1+4)
8003cbc: 58 62 00 04 sw (r3+4),r2
8003cc0: 28 21 00 08 lw r1,(r1+8)
8003cc4: 58 61 00 08 sw (r3+8),r1
if ( !sig )
8003cc8: 45 60 00 04 be r11,r0,8003cd8 <sigaction+0x64>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
8003ccc: 35 61 ff ff addi r1,r11,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
8003cd0: 34 02 00 1f mvi r2,31
8003cd4: 50 41 00 06 bgeu r2,r1,8003cec <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 );
8003cd8: f8 00 29 5f calli 800e254 <__errno>
8003cdc: 34 02 00 16 mvi r2,22
8003ce0: 58 22 00 00 sw (r1+0),r2
8003ce4: 34 01 ff ff mvi r1,-1
8003ce8: e0 00 00 1c bi 8003d58 <sigaction+0xe4>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
8003cec: 34 01 00 09 mvi r1,9
8003cf0: 45 61 ff fa be r11,r1,8003cd8 <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;
8003cf4: 34 01 00 00 mvi r1,0
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
8003cf8: 45 80 00 18 be r12,r0,8003d58 <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 );
8003cfc: 90 00 68 00 rcsr r13,IE
8003d00: 34 01 ff fe mvi r1,-2
8003d04: a1 a1 08 00 and r1,r13,r1
8003d08: d0 01 00 00 wcsr IE,r1
if ( act->sa_handler == SIG_DFL ) {
8003d0c: 29 81 00 08 lw r1,(r12+8)
8003d10: 44 20 00 18 be r1,r0,8003d70 <sigaction+0xfc>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
8003d14: b9 60 08 00 mv r1,r11
8003d18: f8 00 19 69 calli 800a2bc <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
8003d1c: b5 6b 08 00 add r1,r11,r11
8003d20: b4 2b 58 00 add r11,r1,r11
8003d24: 29 82 00 00 lw r2,(r12+0)
8003d28: 78 01 08 02 mvhi r1,0x802
8003d2c: b5 6b 58 00 add r11,r11,r11
8003d30: 38 21 0d d0 ori r1,r1,0xdd0
8003d34: b5 6b 58 00 add r11,r11,r11
8003d38: b4 2b 58 00 add r11,r1,r11
8003d3c: 59 62 00 00 sw (r11+0),r2
8003d40: 29 81 00 04 lw r1,(r12+4)
8003d44: 59 61 00 04 sw (r11+4),r1
8003d48: 29 81 00 08 lw r1,(r12+8)
8003d4c: 59 61 00 08 sw (r11+8),r1
}
_ISR_Enable( level );
8003d50: 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;
8003d54: 34 01 00 00 mvi r1,0
}
8003d58: 2b 9d 00 04 lw ra,(sp+4)
8003d5c: 2b 8b 00 10 lw r11,(sp+16)
8003d60: 2b 8c 00 0c lw r12,(sp+12)
8003d64: 2b 8d 00 08 lw r13,(sp+8)
8003d68: 37 9c 00 10 addi sp,sp,16
8003d6c: 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 ];
8003d70: b5 6b 08 00 add r1,r11,r11
8003d74: b4 2b 58 00 add r11,r1,r11
8003d78: b5 6b 58 00 add r11,r11,r11
8003d7c: 78 02 08 01 mvhi r2,0x801
8003d80: b5 6b 58 00 add r11,r11,r11
8003d84: 38 42 f1 70 ori r2,r2,0xf170
8003d88: b4 4b 10 00 add r2,r2,r11
8003d8c: 28 44 00 00 lw r4,(r2+0)
8003d90: 28 43 00 04 lw r3,(r2+4)
8003d94: 78 01 08 02 mvhi r1,0x802
8003d98: 28 42 00 08 lw r2,(r2+8)
8003d9c: 38 21 0d d0 ori r1,r1,0xdd0
8003da0: b4 2b 58 00 add r11,r1,r11
8003da4: 59 64 00 00 sw (r11+0),r4
8003da8: 59 63 00 04 sw (r11+4),r3
8003dac: 59 62 00 08 sw (r11+8),r2
8003db0: e3 ff ff e8 bi 8003d50 <sigaction+0xdc>
0800421c <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
800421c: 37 9c ff d8 addi sp,sp,-40
8004220: 5b 8b 00 1c sw (sp+28),r11
8004224: 5b 8c 00 18 sw (sp+24),r12
8004228: 5b 8d 00 14 sw (sp+20),r13
800422c: 5b 8e 00 10 sw (sp+16),r14
8004230: 5b 8f 00 0c sw (sp+12),r15
8004234: 5b 90 00 08 sw (sp+8),r16
8004238: 5b 9d 00 04 sw (sp+4),ra
800423c: b8 20 68 00 mv r13,r1
8004240: b8 40 58 00 mv r11,r2
8004244: b8 60 60 00 mv r12,r3
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
8004248: 44 20 00 70 be r1,r0,8004408 <sigtimedwait+0x1ec>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
800424c: 44 60 00 5c be r3,r0,80043bc <sigtimedwait+0x1a0>
if ( !_Timespec_Is_valid( timeout ) )
8004250: b8 60 08 00 mv r1,r3
8004254: f8 00 0e 84 calli 8007c64 <_Timespec_Is_valid>
8004258: 44 20 00 6c be r1,r0,8004408 <sigtimedwait+0x1ec>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
800425c: b9 80 08 00 mv r1,r12
8004260: f8 00 0e a3 calli 8007cec <_Timespec_To_ticks>
if ( !interval )
8004264: 44 20 00 69 be r1,r0,8004408 <sigtimedwait+0x1ec> <== NEVER TAKEN
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
8004268: 45 60 00 57 be r11,r0,80043c4 <sigtimedwait+0x1a8> <== NEVER TAKEN
the_thread = _Thread_Executing;
800426c: 78 0c 08 02 mvhi r12,0x802
8004270: 39 8c 1d 84 ori r12,r12,0x1d84
8004274: 29 83 00 0c lw r3,(r12+12)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
8004278: 28 6f 01 20 lw r15,(r3+288)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
800427c: 90 00 80 00 rcsr r16,IE
8004280: 34 02 ff fe mvi r2,-2
8004284: a2 02 10 00 and r2,r16,r2
8004288: d0 02 00 00 wcsr IE,r2
if ( *set & api->signals_pending ) {
800428c: 29 a5 00 00 lw r5,(r13+0)
8004290: 29 e4 00 d4 lw r4,(r15+212)
8004294: a0 a4 10 00 and r2,r5,r4
8004298: 5c 40 00 4d bne r2,r0,80043cc <sigtimedwait+0x1b0>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
800429c: 78 04 08 02 mvhi r4,0x802
80042a0: 38 84 1f c4 ori r4,r4,0x1fc4
80042a4: 28 84 00 00 lw r4,(r4+0)
80042a8: a0 a4 28 00 and r5,r5,r4
80042ac: 5c a2 00 35 bne r5,r2,8004380 <sigtimedwait+0x164>
80042b0: 78 02 08 02 mvhi r2,0x802
80042b4: 38 42 18 b8 ori r2,r2,0x18b8
80042b8: 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;
80042bc: 34 05 ff ff mvi r5,-1
80042c0: 59 65 00 00 sw (r11+0),r5
80042c4: 34 84 00 01 addi r4,r4,1
80042c8: 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;
80042cc: 34 02 00 04 mvi r2,4
80042d0: 58 62 00 34 sw (r3+52),r2
the_thread->Wait.option = *set;
80042d4: 29 a4 00 00 lw r4,(r13+0)
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
80042d8: 78 02 08 02 mvhi r2,0x802
80042dc: 38 42 1f 5c ori r2,r2,0x1f5c
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
80042e0: 58 64 00 30 sw (r3+48),r4
the_thread->Wait.return_argument = the_info;
80042e4: 58 6b 00 28 sw (r3+40),r11
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
80042e8: 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;
80042ec: 34 03 00 01 mvi r3,1
80042f0: 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 );
80042f4: d0 10 00 00 wcsr IE,r16
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
80042f8: 78 03 08 00 mvhi r3,0x800
80042fc: b8 20 10 00 mv r2,r1
8004300: 78 01 08 02 mvhi r1,0x802
8004304: 38 63 78 84 ori r3,r3,0x7884
8004308: 38 21 1f 5c ori r1,r1,0x1f5c
800430c: f8 00 0c 51 calli 8007450 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
8004310: f8 00 0b 16 calli 8006f68 <_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 );
8004314: 29 62 00 00 lw r2,(r11+0)
8004318: b9 e0 08 00 mv r1,r15
800431c: b9 60 18 00 mv r3,r11
8004320: 34 04 00 00 mvi r4,0
8004324: 34 05 00 00 mvi r5,0
8004328: f8 00 1a 49 calli 800ac4c <_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)
800432c: 29 81 00 0c lw r1,(r12+12)
8004330: 28 22 00 34 lw r2,(r1+52)
8004334: 34 01 00 04 mvi r1,4
8004338: 5c 41 00 39 bne r2,r1,800441c <sigtimedwait+0x200>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
800433c: 29 6e 00 00 lw r14,(r11+0)
8004340: 34 01 00 01 mvi r1,1
8004344: 35 c2 ff ff addi r2,r14,-1
8004348: f8 00 66 a4 calli 801ddd8 <__ashlsi3>
800434c: 29 a2 00 00 lw r2,(r13+0)
8004350: a0 22 08 00 and r1,r1,r2
8004354: 44 20 00 32 be r1,r0,800441c <sigtimedwait+0x200>
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
8004358: b9 c0 08 00 mv r1,r14
800435c: 2b 9d 00 04 lw ra,(sp+4)
8004360: 2b 8b 00 1c lw r11,(sp+28)
8004364: 2b 8c 00 18 lw r12,(sp+24)
8004368: 2b 8d 00 14 lw r13,(sp+20)
800436c: 2b 8e 00 10 lw r14,(sp+16)
8004370: 2b 8f 00 0c lw r15,(sp+12)
8004374: 2b 90 00 08 lw r16,(sp+8)
8004378: 37 9c 00 28 addi sp,sp,40
800437c: c3 a0 00 00 ret
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
8004380: b8 80 08 00 mv r1,r4
8004384: fb ff ff 86 calli 800419c <_POSIX_signals_Get_lowest>
8004388: b8 20 70 00 mv r14,r1
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
800438c: b9 c0 10 00 mv r2,r14
8004390: b9 e0 08 00 mv r1,r15
8004394: b9 60 18 00 mv r3,r11
8004398: 34 04 00 01 mvi r4,1
800439c: 34 05 00 00 mvi r5,0
80043a0: f8 00 1a 2b calli 800ac4c <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
80043a4: d0 10 00 00 wcsr IE,r16
the_info->si_signo = signo;
the_info->si_code = SI_USER;
80043a8: 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;
80043ac: 59 6e 00 00 sw (r11+0),r14
the_info->si_code = SI_USER;
80043b0: 59 61 00 04 sw (r11+4),r1
the_info->si_value.sival_int = 0;
80043b4: 59 60 00 08 sw (r11+8),r0
return signo;
80043b8: e3 ff ff e8 bi 8004358 <sigtimedwait+0x13c>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
80043bc: 34 01 00 00 mvi r1,0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
80043c0: 5d 60 ff ab bne r11,r0,800426c <sigtimedwait+0x50>
80043c4: 37 8b 00 20 addi r11,sp,32
80043c8: e3 ff ff a9 bi 800426c <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 );
80043cc: b8 80 08 00 mv r1,r4
80043d0: fb ff ff 73 calli 800419c <_POSIX_signals_Get_lowest>
80043d4: b8 20 10 00 mv r2,r1
80043d8: 59 61 00 00 sw (r11+0),r1
_POSIX_signals_Clear_signals(
80043dc: b9 60 18 00 mv r3,r11
80043e0: b9 e0 08 00 mv r1,r15
80043e4: 34 04 00 00 mvi r4,0
80043e8: 34 05 00 00 mvi r5,0
80043ec: f8 00 1a 18 calli 800ac4c <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
80043f0: d0 10 00 00 wcsr IE,r16
the_info->si_code = SI_USER;
80043f4: 34 01 00 01 mvi r1,1
80043f8: 59 61 00 04 sw (r11+4),r1
the_info->si_value.sival_int = 0;
80043fc: 59 60 00 08 sw (r11+8),r0
return the_info->si_signo;
8004400: 29 6e 00 00 lw r14,(r11+0)
8004404: e3 ff ff d5 bi 8004358 <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 );
8004408: f8 00 29 4f calli 800e944 <__errno>
800440c: 34 02 00 16 mvi r2,22
8004410: 58 22 00 00 sw (r1+0),r2
8004414: 34 0e ff ff mvi r14,-1
8004418: e3 ff ff d0 bi 8004358 <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;
800441c: f8 00 29 4a calli 800e944 <__errno>
8004420: 29 82 00 0c lw r2,(r12+12)
return -1;
8004424: 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;
8004428: 28 42 00 34 lw r2,(r2+52)
800442c: 58 22 00 00 sw (r1+0),r2
return -1;
8004430: e3 ff ff ca bi 8004358 <sigtimedwait+0x13c>
080064dc <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
80064dc: 37 9c ff f8 addi sp,sp,-8
80064e0: 5b 8b 00 08 sw (sp+8),r11
80064e4: 5b 9d 00 04 sw (sp+4),ra
int status;
status = sigtimedwait( set, NULL, NULL );
80064e8: 34 03 00 00 mvi r3,0
int sigwait(
const sigset_t *set,
int *sig
)
{
80064ec: b8 40 58 00 mv r11,r2
int status;
status = sigtimedwait( set, NULL, NULL );
80064f0: 34 02 00 00 mvi r2,0
80064f4: fb ff ff 6d calli 80062a8 <sigtimedwait>
if ( status != -1 ) {
80064f8: 34 02 ff ff mvi r2,-1
80064fc: 44 22 00 09 be r1,r2,8006520 <sigwait+0x44>
if ( sig )
*sig = status;
return 0;
8006500: 34 03 00 00 mvi r3,0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
8006504: 45 60 00 02 be r11,r0,800650c <sigwait+0x30> <== NEVER TAKEN
*sig = status;
8006508: 59 61 00 00 sw (r11+0),r1
return 0;
}
return errno;
}
800650c: b8 60 08 00 mv r1,r3
8006510: 2b 9d 00 04 lw ra,(sp+4)
8006514: 2b 8b 00 08 lw r11,(sp+8)
8006518: 37 9c 00 08 addi sp,sp,8
800651c: c3 a0 00 00 ret
if ( sig )
*sig = status;
return 0;
}
return errno;
8006520: f8 00 28 24 calli 80105b0 <__errno>
8006524: 28 23 00 00 lw r3,(r1+0)
}
8006528: b8 60 08 00 mv r1,r3
800652c: 2b 9d 00 04 lw ra,(sp+4)
8006530: 2b 8b 00 08 lw r11,(sp+8)
8006534: 37 9c 00 08 addi sp,sp,8
8006538: c3 a0 00 00 ret
08003130 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
8003130: 37 9c ff f0 addi sp,sp,-16
8003134: 5b 8b 00 10 sw (sp+16),r11
8003138: 5b 8c 00 0c sw (sp+12),r12
800313c: 5b 8d 00 08 sw (sp+8),r13
8003140: 5b 9d 00 04 sw (sp+4),ra
8003144: b8 40 58 00 mv r11,r2
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
8003148: 34 02 00 01 mvi r2,1
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
800314c: b8 60 68 00 mv r13,r3
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
8003150: 5c 22 00 06 bne r1,r2,8003168 <timer_create+0x38>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
8003154: 44 60 00 05 be r3,r0,8003168 <timer_create+0x38>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
8003158: 45 60 00 14 be r11,r0,80031a8 <timer_create+0x78>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
800315c: 29 62 00 00 lw r2,(r11+0)
8003160: 34 42 ff ff addi r2,r2,-1
8003164: 50 22 00 0b bgeu r1,r2,8003190 <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 );
8003168: f8 00 2b 47 calli 800de84 <__errno>
800316c: 34 02 00 16 mvi r2,22
8003170: 58 22 00 00 sw (r1+0),r2
8003174: 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;
}
8003178: 2b 9d 00 04 lw ra,(sp+4)
800317c: 2b 8b 00 10 lw r11,(sp+16)
8003180: 2b 8c 00 0c lw r12,(sp+12)
8003184: 2b 8d 00 08 lw r13,(sp+8)
8003188: 37 9c 00 10 addi sp,sp,16
800318c: 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 )
8003190: 29 61 00 04 lw r1,(r11+4)
8003194: 44 20 ff f5 be r1,r0,8003168 <timer_create+0x38> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
8003198: 34 21 ff ff addi r1,r1,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
800319c: 34 02 00 1f mvi r2,31
80031a0: 50 41 00 02 bgeu r2,r1,80031a8 <timer_create+0x78> <== ALWAYS TAKEN
80031a4: e3 ff ff f1 bi 8003168 <timer_create+0x38> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
80031a8: 78 01 08 01 mvhi r1,0x801
80031ac: 38 21 f8 b8 ori r1,r1,0xf8b8
80031b0: 28 22 00 00 lw r2,(r1+0)
80031b4: 34 42 00 01 addi r2,r2,1
80031b8: 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 );
80031bc: 78 0c 08 01 mvhi r12,0x801
80031c0: 39 8c fb 4c ori r12,r12,0xfb4c
80031c4: b9 80 08 00 mv r1,r12
80031c8: f8 00 07 62 calli 8004f50 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
80031cc: 44 20 00 29 be r1,r0,8003270 <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;
80031d0: 78 02 08 01 mvhi r2,0x801
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;
80031d4: 34 03 00 02 mvi r3,2
80031d8: 30 23 00 3c sb (r1+60),r3
ptimer->thread_id = _Thread_Executing->Object.id;
80031dc: 38 42 fd 84 ori r2,r2,0xfd84
80031e0: 28 42 00 0c lw r2,(r2+12)
80031e4: 28 42 00 08 lw r2,(r2+8)
80031e8: 58 22 00 38 sw (r1+56),r2
if ( evp != NULL ) {
80031ec: 45 60 00 07 be r11,r0,8003208 <timer_create+0xd8>
ptimer->inf.sigev_notify = evp->sigev_notify;
80031f0: 29 64 00 00 lw r4,(r11+0)
ptimer->inf.sigev_signo = evp->sigev_signo;
80031f4: 29 63 00 04 lw r3,(r11+4)
ptimer->inf.sigev_value = evp->sigev_value;
80031f8: 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;
80031fc: 58 24 00 40 sw (r1+64),r4
ptimer->inf.sigev_signo = evp->sigev_signo;
8003200: 58 23 00 44 sw (r1+68),r3
ptimer->inf.sigev_value = evp->sigev_value;
8003204: 58 22 00 48 sw (r1+72),r2
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
8003208: 28 23 00 08 lw r3,(r1+8)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
800320c: 29 84 00 1c lw r4,(r12+28)
}
ptimer->overrun = 0;
8003210: 58 20 00 68 sw (r1+104),r0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
8003214: 20 62 ff ff andi r2,r3,0xffff
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
8003218: b4 42 10 00 add r2,r2,r2
800321c: b4 42 10 00 add r2,r2,r2
ptimer->timer_data.it_value.tv_sec = 0;
8003220: 58 20 00 5c sw (r1+92),r0
ptimer->timer_data.it_value.tv_nsec = 0;
8003224: 58 20 00 60 sw (r1+96),r0
ptimer->timer_data.it_interval.tv_sec = 0;
8003228: 58 20 00 54 sw (r1+84),r0
ptimer->timer_data.it_interval.tv_nsec = 0;
800322c: 58 20 00 58 sw (r1+88),r0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
8003230: 58 20 00 18 sw (r1+24),r0
the_watchdog->routine = routine;
8003234: 58 20 00 2c sw (r1+44),r0
the_watchdog->id = id;
8003238: 58 20 00 30 sw (r1+48),r0
the_watchdog->user_data = user_data;
800323c: 58 20 00 34 sw (r1+52),r0
8003240: b4 82 10 00 add r2,r4,r2
8003244: 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;
8003248: 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;
800324c: 59 a3 00 00 sw (r13+0),r3
_Thread_Enable_dispatch();
8003250: f8 00 0b b1 calli 8006114 <_Thread_Enable_dispatch>
return 0;
8003254: 34 01 00 00 mvi r1,0
}
8003258: 2b 9d 00 04 lw ra,(sp+4)
800325c: 2b 8b 00 10 lw r11,(sp+16)
8003260: 2b 8c 00 0c lw r12,(sp+12)
8003264: 2b 8d 00 08 lw r13,(sp+8)
8003268: 37 9c 00 10 addi sp,sp,16
800326c: c3 a0 00 00 ret
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
8003270: f8 00 0b a9 calli 8006114 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
8003274: f8 00 2b 04 calli 800de84 <__errno>
8003278: 34 02 00 0b mvi r2,11
800327c: 58 22 00 00 sw (r1+0),r2
8003280: 34 01 ff ff mvi r1,-1
8003284: e3 ff ff f5 bi 8003258 <timer_create+0x128>
08003288 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
8003288: 37 9c ff cc addi sp,sp,-52
800328c: 5b 8b 00 18 sw (sp+24),r11
8003290: 5b 8c 00 14 sw (sp+20),r12
8003294: 5b 8d 00 10 sw (sp+16),r13
8003298: 5b 8e 00 0c sw (sp+12),r14
800329c: 5b 8f 00 08 sw (sp+8),r15
80032a0: 5b 9d 00 04 sw (sp+4),ra
80032a4: b8 60 60 00 mv r12,r3
80032a8: b8 20 70 00 mv r14,r1
80032ac: b8 40 58 00 mv r11,r2
80032b0: b8 80 68 00 mv r13,r4
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
80032b4: 44 60 00 1e be r3,r0,800332c <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) ) ) {
80032b8: 34 61 00 08 addi r1,r3,8
80032bc: f8 00 0f 17 calli 8006f18 <_Timespec_Is_valid>
80032c0: 44 20 00 1b be r1,r0,800332c <timer_settime+0xa4>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
80032c4: b9 80 08 00 mv r1,r12
80032c8: f8 00 0f 14 calli 8006f18 <_Timespec_Is_valid>
80032cc: 44 20 00 18 be r1,r0,800332c <timer_settime+0xa4> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
80032d0: 7d 62 00 00 cmpnei r2,r11,0
80032d4: 7d 61 00 04 cmpnei r1,r11,4
80032d8: a0 41 08 00 and r1,r2,r1
80032dc: 5c 20 00 14 bne r1,r0,800332c <timer_settime+0xa4>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
80032e0: 29 81 00 0c lw r1,(r12+12)
80032e4: 29 84 00 00 lw r4,(r12+0)
80032e8: 29 83 00 04 lw r3,(r12+4)
80032ec: 29 82 00 08 lw r2,(r12+8)
80032f0: 5b 81 00 28 sw (sp+40),r1
80032f4: 5b 84 00 1c sw (sp+28),r4
80032f8: 5b 83 00 20 sw (sp+32),r3
80032fc: 5b 82 00 24 sw (sp+36),r2
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
8003300: 34 01 00 04 mvi r1,4
8003304: 45 61 00 46 be r11,r1,800341c <timer_settime+0x194>
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
8003308: 78 03 08 01 mvhi r3,0x801
800330c: b8 60 08 00 mv r1,r3
8003310: 38 21 fb 4c ori r1,r1,0xfb4c
8003314: b9 c0 10 00 mv r2,r14
8003318: 37 83 00 34 addi r3,sp,52
800331c: f8 00 08 53 calli 8005468 <_Objects_Get>
8003320: 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 ) {
8003324: 2b 81 00 34 lw r1,(sp+52)
8003328: 44 20 00 0d be r1,r0,800335c <timer_settime+0xd4>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
800332c: f8 00 2a d6 calli 800de84 <__errno>
8003330: 34 02 00 16 mvi r2,22
8003334: 58 22 00 00 sw (r1+0),r2
8003338: 34 01 ff ff mvi r1,-1
}
800333c: 2b 9d 00 04 lw ra,(sp+4)
8003340: 2b 8b 00 18 lw r11,(sp+24)
8003344: 2b 8c 00 14 lw r12,(sp+20)
8003348: 2b 8d 00 10 lw r13,(sp+16)
800334c: 2b 8e 00 0c lw r14,(sp+12)
8003350: 2b 8f 00 08 lw r15,(sp+8)
8003354: 37 9c 00 34 addi sp,sp,52
8003358: 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 ) {
800335c: 2b 82 00 24 lw r2,(sp+36)
8003360: 5c 41 00 03 bne r2,r1,800336c <timer_settime+0xe4>
8003364: 2b 8e 00 28 lw r14,(sp+40)
8003368: 45 c2 00 3a be r14,r2,8003450 <timer_settime+0x1c8>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
800336c: b9 80 08 00 mv r1,r12
8003370: f8 00 0f 0c calli 8006fa0 <_Timespec_To_ticks>
8003374: 59 61 00 64 sw (r11+100),r1
initial_period = _Timespec_To_ticks( &normalize.it_value );
8003378: 37 81 00 24 addi r1,sp,36
800337c: f8 00 0f 09 calli 8006fa0 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
8003380: 29 63 00 08 lw r3,(r11+8)
8003384: 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 );
8003388: b8 20 10 00 mv r2,r1
activated = _POSIX_Timer_Insert_helper(
800338c: 38 84 34 cc ori r4,r4,0x34cc
8003390: 35 61 00 10 addi r1,r11,16
8003394: b9 60 28 00 mv r5,r11
8003398: f8 00 1b aa calli 800a240 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
800339c: 44 20 00 16 be r1,r0,80033f4 <timer_settime+0x16c>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
80033a0: 45 a0 00 09 be r13,r0,80033c4 <timer_settime+0x13c>
*ovalue = ptimer->timer_data;
80033a4: 29 61 00 54 lw r1,(r11+84)
80033a8: 59 a1 00 00 sw (r13+0),r1
80033ac: 29 61 00 58 lw r1,(r11+88)
80033b0: 59 a1 00 04 sw (r13+4),r1
80033b4: 29 61 00 5c lw r1,(r11+92)
80033b8: 59 a1 00 08 sw (r13+8),r1
80033bc: 29 61 00 60 lw r1,(r11+96)
80033c0: 59 a1 00 0c sw (r13+12),r1
ptimer->timer_data = normalize;
80033c4: 2b 82 00 1c lw r2,(sp+28)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
_TOD_Get( &ptimer->time );
80033c8: 35 61 00 6c addi r1,r11,108
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
*ovalue = ptimer->timer_data;
ptimer->timer_data = normalize;
80033cc: 59 62 00 54 sw (r11+84),r2
80033d0: 2b 82 00 20 lw r2,(sp+32)
80033d4: 59 62 00 58 sw (r11+88),r2
80033d8: 2b 82 00 24 lw r2,(sp+36)
80033dc: 59 62 00 5c sw (r11+92),r2
80033e0: 2b 82 00 28 lw r2,(sp+40)
80033e4: 59 62 00 60 sw (r11+96),r2
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
80033e8: 34 02 00 03 mvi r2,3
80033ec: 31 62 00 3c sb (r11+60),r2
_TOD_Get( &ptimer->time );
80033f0: f8 00 05 04 calli 8004800 <_TOD_Get>
_Thread_Enable_dispatch();
80033f4: f8 00 0b 48 calli 8006114 <_Thread_Enable_dispatch>
return 0;
80033f8: 34 01 00 00 mvi r1,0
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
80033fc: 2b 9d 00 04 lw ra,(sp+4)
8003400: 2b 8b 00 18 lw r11,(sp+24)
8003404: 2b 8c 00 14 lw r12,(sp+20)
8003408: 2b 8d 00 10 lw r13,(sp+16)
800340c: 2b 8e 00 0c lw r14,(sp+12)
8003410: 2b 8f 00 08 lw r15,(sp+8)
8003414: 37 9c 00 34 addi sp,sp,52
8003418: c3 a0 00 00 ret
normalize = *value;
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
800341c: 37 8b 00 2c addi r11,sp,44
8003420: b9 60 08 00 mv r1,r11
8003424: f8 00 04 f7 calli 8004800 <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
8003428: 37 8f 00 24 addi r15,sp,36
800342c: b9 60 08 00 mv r1,r11
8003430: b9 e0 10 00 mv r2,r15
8003434: f8 00 0e ae calli 8006eec <_Timespec_Greater_than>
8003438: 5c 20 ff bd bne r1,r0,800332c <timer_settime+0xa4>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
800343c: b9 e0 10 00 mv r2,r15
8003440: b9 60 08 00 mv r1,r11
8003444: b9 e0 18 00 mv r3,r15
8003448: f8 00 0e c0 calli 8006f48 <_Timespec_Subtract>
800344c: e3 ff ff af bi 8003308 <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 );
8003450: 35 61 00 10 addi r1,r11,16
8003454: f8 00 10 5b calli 80075c0 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
8003458: 45 ae 00 09 be r13,r14,800347c <timer_settime+0x1f4>
*ovalue = ptimer->timer_data;
800345c: 29 61 00 54 lw r1,(r11+84)
8003460: 59 a1 00 00 sw (r13+0),r1
8003464: 29 61 00 58 lw r1,(r11+88)
8003468: 59 a1 00 04 sw (r13+4),r1
800346c: 29 61 00 5c lw r1,(r11+92)
8003470: 59 a1 00 08 sw (r13+8),r1
8003474: 29 61 00 60 lw r1,(r11+96)
8003478: 59 a1 00 0c sw (r13+12),r1
/* The new data are set */
ptimer->timer_data = normalize;
800347c: 2b 81 00 1c lw r1,(sp+28)
8003480: 59 61 00 54 sw (r11+84),r1
8003484: 2b 81 00 20 lw r1,(sp+32)
8003488: 59 61 00 58 sw (r11+88),r1
800348c: 2b 81 00 24 lw r1,(sp+36)
8003490: 59 61 00 5c sw (r11+92),r1
8003494: 2b 81 00 28 lw r1,(sp+40)
8003498: 59 61 00 60 sw (r11+96),r1
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
800349c: 34 01 00 04 mvi r1,4
80034a0: 31 61 00 3c sb (r11+60),r1
/* Returns with success */
_Thread_Enable_dispatch();
80034a4: f8 00 0b 1c calli 8006114 <_Thread_Enable_dispatch>
return 0;
80034a8: 34 01 00 00 mvi r1,0
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
80034ac: 2b 9d 00 04 lw ra,(sp+4)
80034b0: 2b 8b 00 18 lw r11,(sp+24)
80034b4: 2b 8c 00 14 lw r12,(sp+20)
80034b8: 2b 8d 00 10 lw r13,(sp+16)
80034bc: 2b 8e 00 0c lw r14,(sp+12)
80034c0: 2b 8f 00 08 lw r15,(sp+8)
80034c4: 37 9c 00 34 addi sp,sp,52
80034c8: c3 a0 00 00 ret
08003054 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
8003054: 37 9c ff e4 addi sp,sp,-28
8003058: 5b 8b 00 14 sw (sp+20),r11
800305c: 5b 8c 00 10 sw (sp+16),r12
8003060: 5b 8d 00 0c sw (sp+12),r13
8003064: 5b 8e 00 08 sw (sp+8),r14
8003068: 5b 9d 00 04 sw (sp+4),ra
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
800306c: 78 0b 08 01 mvhi r11,0x801
8003070: 39 6b 81 58 ori r11,r11,0x8158
8003074: 29 62 00 1c lw r2,(r11+28)
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
8003078: b8 20 60 00 mv r12,r1
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
800307c: 44 40 00 55 be r2,r0,80031d0 <ualarm+0x17c>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
8003080: b9 60 08 00 mv r1,r11
8003084: f8 00 0f bf calli 8006f80 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
8003088: 34 21 ff fe addi r1,r1,-2
800308c: 34 02 00 01 mvi r2,1
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
8003090: 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) ) {
8003094: 54 22 00 24 bgu r1,r2,8003124 <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);
8003098: 29 64 00 14 lw r4,(r11+20)
800309c: 29 61 00 0c lw r1,(r11+12)
80030a0: 29 63 00 18 lw r3,(r11+24)
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
80030a4: 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);
80030a8: b4 81 08 00 add r1,r4,r1
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
80030ac: c8 23 08 00 sub r1,r1,r3
80030b0: f8 00 0d b2 calli 8006778 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
80030b4: 2b 85 00 18 lw r5,(sp+24)
remaining += tp.tv_nsec / 1000;
80030b8: 2b 81 00 1c lw r1,(sp+28)
80030bc: 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;
80030c0: b4 a5 18 00 add r3,r5,r5
80030c4: b4 63 18 00 add r3,r3,r3
80030c8: b4 63 18 00 add r3,r3,r3
80030cc: b4 63 20 00 add r4,r3,r3
80030d0: b4 84 20 00 add r4,r4,r4
80030d4: b4 84 20 00 add r4,r4,r4
80030d8: b4 84 20 00 add r4,r4,r4
80030dc: b4 84 20 00 add r4,r4,r4
80030e0: c8 83 20 00 sub r4,r4,r3
80030e4: b4 84 18 00 add r3,r4,r4
80030e8: b4 63 18 00 add r3,r3,r3
80030ec: b4 63 18 00 add r3,r3,r3
80030f0: b4 63 18 00 add r3,r3,r3
80030f4: b4 63 18 00 add r3,r3,r3
80030f8: b4 63 18 00 add r3,r3,r3
80030fc: c8 64 18 00 sub r3,r3,r4
8003100: b4 65 68 00 add r13,r3,r5
8003104: b5 ad 68 00 add r13,r13,r13
8003108: b5 ad 68 00 add r13,r13,r13
800310c: b5 ad 68 00 add r13,r13,r13
8003110: b5 ad 68 00 add r13,r13,r13
8003114: b5 ad 68 00 add r13,r13,r13
8003118: b5 ad 68 00 add r13,r13,r13
remaining += tp.tv_nsec / 1000;
800311c: f8 00 44 83 calli 8014328 <__divsi3>
8003120: 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 ) {
8003124: 45 80 00 23 be r12,r0,80031b0 <ualarm+0x15c>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
8003128: 78 01 08 01 mvhi r1,0x801
800312c: 38 21 56 2c ori r1,r1,0x562c
8003130: 28 22 00 00 lw r2,(r1+0)
8003134: b9 80 08 00 mv r1,r12
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ticks = _Timespec_To_ticks( &tp );
8003138: 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;
800313c: f8 00 44 d4 calli 801448c <__udivsi3>
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
8003140: 78 03 08 01 mvhi r3,0x801
8003144: 38 63 56 2c ori r3,r3,0x562c
8003148: 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;
800314c: 5b 81 00 18 sw (sp+24),r1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
8003150: b9 80 08 00 mv r1,r12
8003154: f8 00 44 de calli 80144cc <__umodsi3>
8003158: b4 21 10 00 add r2,r1,r1
800315c: b4 42 10 00 add r2,r2,r2
8003160: b4 42 10 00 add r2,r2,r2
8003164: b4 42 18 00 add r3,r2,r2
8003168: b4 63 18 00 add r3,r3,r3
800316c: b4 43 10 00 add r2,r2,r3
8003170: b4 42 18 00 add r3,r2,r2
8003174: b4 63 18 00 add r3,r3,r3
8003178: b4 43 10 00 add r2,r2,r3
800317c: b4 42 18 00 add r3,r2,r2
8003180: b4 63 18 00 add r3,r3,r3
8003184: b4 43 18 00 add r3,r2,r3
ticks = _Timespec_To_ticks( &tp );
8003188: 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;
800318c: 5b 83 00 1c sw (sp+28),r3
ticks = _Timespec_To_ticks( &tp );
8003190: f8 00 0d b6 calli 8006868 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
8003194: b9 c0 08 00 mv r1,r14
8003198: f8 00 0d b4 calli 8006868 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
800319c: 59 61 00 0c sw (r11+12),r1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
80031a0: 78 01 08 01 mvhi r1,0x801
80031a4: b9 60 10 00 mv r2,r11
80031a8: 38 21 79 a8 ori r1,r1,0x79a8
80031ac: f8 00 0f 0a calli 8006dd4 <_Watchdog_Insert>
}
return remaining;
}
80031b0: b9 a0 08 00 mv r1,r13
80031b4: 2b 9d 00 04 lw ra,(sp+4)
80031b8: 2b 8b 00 14 lw r11,(sp+20)
80031bc: 2b 8c 00 10 lw r12,(sp+16)
80031c0: 2b 8d 00 0c lw r13,(sp+12)
80031c4: 2b 8e 00 08 lw r14,(sp+8)
80031c8: 37 9c 00 1c addi sp,sp,28
80031cc: c3 a0 00 00 ret
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
80031d0: 78 01 08 00 mvhi r1,0x800
80031d4: 38 21 30 0c ori r1,r1,0x300c
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
80031d8: 59 60 00 08 sw (r11+8),r0
the_watchdog->routine = routine;
80031dc: 59 61 00 1c sw (r11+28),r1
the_watchdog->id = id;
80031e0: 59 60 00 20 sw (r11+32),r0
the_watchdog->user_data = user_data;
80031e4: 59 60 00 24 sw (r11+36),r0
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
80031e8: 34 0d 00 00 mvi r13,0
80031ec: e3 ff ff ce bi 8003124 <ualarm+0xd0>