RTEMS-6
Annotated Report
sapi
Sun Feb 28 22:21:15 2021
40007b0c <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
40007b0c: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
40007b10: 03 10 00 93 sethi %hi(0x40024c00), %g1
40007b14: 84 10 20 01 mov 1, %g2
40007b18: c4 28 61 58 stb %g2, [ %g1 + 0x158 ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40007b1c: 03 10 00 7c sethi %hi(0x4001f000), %g1
40007b20: f8 00 62 c4 ld [ %g1 + 0x2c4 ], %i4 ! 4001f2c4 <_IO_Number_of_drivers>
40007b24: 80 a7 20 00 cmp %i4, 0
40007b28: 02 80 00 0a be 40007b50 <_IO_Initialize_all_drivers+0x44> <== NEVER TAKEN
40007b2c: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
40007b30: 90 10 00 1d mov %i5, %o0
40007b34: 94 10 20 00 clr %o2
40007b38: 40 00 00 08 call 40007b58 <rtems_io_initialize>
40007b3c: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40007b40: ba 07 60 01 inc %i5
40007b44: 80 a7 40 1c cmp %i5, %i4
40007b48: 12 bf ff fb bne 40007b34 <_IO_Initialize_all_drivers+0x28>
40007b4c: 90 10 00 1d mov %i5, %o0
}
40007b50: 81 c7 e0 08 ret
40007b54: 81 e8 00 00 restore
40005634 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
40005634: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
40005638: 40 00 00 21 call 400056bc <rtems_chain_get>
4000563c: 90 10 00 18 mov %i0, %o0
) {
rtems_event_set out;
sc = rtems_event_receive(
40005640: 96 07 bf fc add %fp, -4, %o3
&& (node = rtems_chain_get( chain )) == NULL
40005644: ba 10 00 08 mov %o0, %i5
sc = rtems_event_receive(
40005648: 94 10 00 1a mov %i2, %o2
4000564c: 92 10 20 00 clr %o1
&& (node = rtems_chain_get( chain )) == NULL
40005650: 80 a7 60 00 cmp %i5, 0
40005654: 12 80 00 0a bne 4000567c <rtems_chain_get_with_wait+0x48>
40005658: 90 10 00 19 mov %i1, %o0
sc = rtems_event_receive(
4000565c: 7f ff fe e3 call 400051e8 <rtems_event_receive>
40005660: 01 00 00 00 nop
while (
40005664: 80 a2 20 00 cmp %o0, 0
40005668: 02 bf ff f4 be 40005638 <rtems_chain_get_with_wait+0x4> <== NEVER TAKEN
4000566c: 01 00 00 00 nop
timeout,
&out
);
}
*node_ptr = node;
40005670: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
40005674: 81 c7 e0 08 ret
40005678: 91 e8 00 08 restore %g0, %o0, %o0
4000567c: 90 10 20 00 clr %o0
*node_ptr = node;
40005680: fa 26 c0 00 st %i5, [ %i3 ]
}
40005684: 81 c7 e0 08 ret
40005688: 91 e8 00 08 restore %g0, %o0, %o0
40005bcc <rtems_configuration_get_maximum_barriers>:
return information->objects_per_block != 0;
40005bcc: 03 10 00 58 sethi %hi(0x40016000), %g1
40005bd0: 84 10 60 8c or %g1, 0x8c, %g2 ! 4001608c <_Barrier_Information>
#include <rtems/rtems/timerimpl.h>
#include <rtems/score/objectimpl.h>
static uint32_t get_config_max( const Objects_Information *info )
{
if ( _Objects_Is_auto_extend( info ) ) {
40005bd4: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2
40005bd8: 80 a0 a0 00 cmp %g2, 0
40005bdc: 12 80 00 04 bne 40005bec <rtems_configuration_get_maximum_barriers+0x20> <== NEVER TAKEN
40005be0: d0 10 60 8e lduh [ %g1 + 0x8e ], %o0
}
uint32_t rtems_configuration_get_maximum_barriers( void )
{
return get_config_max( &_Barrier_Information );
}
40005be4: 81 c3 e0 08 retl
40005be8: 01 00 00 00 nop
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40005bec: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40005bf0: 81 c3 e0 08 retl <== NOT EXECUTED
40005bf4: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
400139e8 <rtems_configuration_get_maximum_extensions>:
400139e8: 03 10 02 4d sethi %hi(0x40093400), %g1 <== NOT EXECUTED
400139ec: 84 10 63 38 or %g1, 0x338, %g2 ! 40093738 <_Extension_Information> <== NOT EXECUTED
if ( _Objects_Is_auto_extend( info ) ) {
400139f0: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2 <== NOT EXECUTED
400139f4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
400139f8: 12 80 00 04 bne 40013a08 <rtems_configuration_get_maximum_extensions+0x20><== NOT EXECUTED
400139fc: d0 10 63 3a lduh [ %g1 + 0x33a ], %o0 <== NOT EXECUTED
uint32_t rtems_configuration_get_maximum_extensions( void )
{
return get_config_max( &_Extension_Information );
}
40013a00: 81 c3 e0 08 retl <== NOT EXECUTED
40013a04: 01 00 00 00 nop <== NOT EXECUTED
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40013a08: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40013a0c: 81 c3 e0 08 retl <== NOT EXECUTED
40013a10: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
40005bf8 <rtems_configuration_get_maximum_message_queues>:
40005bf8: 03 10 00 58 sethi %hi(0x40016000), %g1
40005bfc: 84 10 60 ec or %g1, 0xec, %g2 ! 400160ec <_Message_queue_Information>
if ( _Objects_Is_auto_extend( info ) ) {
40005c00: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2
40005c04: 80 a0 a0 00 cmp %g2, 0
40005c08: 12 80 00 04 bne 40005c18 <rtems_configuration_get_maximum_message_queues+0x20><== NEVER TAKEN
40005c0c: d0 10 60 ee lduh [ %g1 + 0xee ], %o0
}
uint32_t rtems_configuration_get_maximum_message_queues( void )
{
return get_config_max( &_Message_queue_Information );
}
40005c10: 81 c3 e0 08 retl
40005c14: 01 00 00 00 nop
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40005c18: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40005c1c: 81 c3 e0 08 retl <== NOT EXECUTED
40005c20: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
40005c24 <rtems_configuration_get_maximum_partitions>:
40005c24: 03 10 00 58 sethi %hi(0x40016000), %g1
40005c28: 84 10 61 1c or %g1, 0x11c, %g2 ! 4001611c <_Partition_Information>
if ( _Objects_Is_auto_extend( info ) ) {
40005c2c: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2
40005c30: 80 a0 a0 00 cmp %g2, 0
40005c34: 12 80 00 04 bne 40005c44 <rtems_configuration_get_maximum_partitions+0x20><== NEVER TAKEN
40005c38: d0 10 61 1e lduh [ %g1 + 0x11e ], %o0
uint32_t rtems_configuration_get_maximum_partitions( void )
{
return get_config_max( &_Partition_Information );
}
40005c3c: 81 c3 e0 08 retl
40005c40: 01 00 00 00 nop
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40005c44: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40005c48: 81 c3 e0 08 retl <== NOT EXECUTED
40005c4c: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
40005c50 <rtems_configuration_get_maximum_periods>:
40005c50: 03 10 00 58 sethi %hi(0x40016000), %g1
40005c54: 84 10 61 4c or %g1, 0x14c, %g2 ! 4001614c <_Rate_monotonic_Information>
if ( _Objects_Is_auto_extend( info ) ) {
40005c58: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2
40005c5c: 80 a0 a0 00 cmp %g2, 0
40005c60: 12 80 00 04 bne 40005c70 <rtems_configuration_get_maximum_periods+0x20> <== NEVER TAKEN
40005c64: d0 10 61 4e lduh [ %g1 + 0x14e ], %o0
uint32_t rtems_configuration_get_maximum_periods( void )
{
return get_config_max( &_Rate_monotonic_Information );
}
40005c68: 81 c3 e0 08 retl
40005c6c: 01 00 00 00 nop
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40005c70: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40005c74: 81 c3 e0 08 retl <== NOT EXECUTED
40005c78: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
40005c7c <rtems_configuration_get_maximum_ports>:
40005c7c: 03 10 00 58 sethi %hi(0x40016000), %g1
40005c80: 84 10 60 bc or %g1, 0xbc, %g2 ! 400160bc <_Dual_ported_memory_Information>
if ( _Objects_Is_auto_extend( info ) ) {
40005c84: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2
40005c88: 80 a0 a0 00 cmp %g2, 0
40005c8c: 12 80 00 04 bne 40005c9c <rtems_configuration_get_maximum_ports+0x20> <== NEVER TAKEN
40005c90: d0 10 60 be lduh [ %g1 + 0xbe ], %o0
uint32_t rtems_configuration_get_maximum_ports( void )
{
return get_config_max( &_Dual_ported_memory_Information );
}
40005c94: 81 c3 e0 08 retl
40005c98: 01 00 00 00 nop
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40005c9c: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40005ca0: 81 c3 e0 08 retl <== NOT EXECUTED
40005ca4: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
40005ca8 <rtems_configuration_get_maximum_regions>:
40005ca8: 03 10 00 58 sethi %hi(0x40016000), %g1
40005cac: 84 10 61 7c or %g1, 0x17c, %g2 ! 4001617c <_Region_Information>
if ( _Objects_Is_auto_extend( info ) ) {
40005cb0: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2
40005cb4: 80 a0 a0 00 cmp %g2, 0
40005cb8: 12 80 00 04 bne 40005cc8 <rtems_configuration_get_maximum_regions+0x20> <== NEVER TAKEN
40005cbc: d0 10 61 7e lduh [ %g1 + 0x17e ], %o0
uint32_t rtems_configuration_get_maximum_regions( void )
{
return get_config_max( &_Region_Information );
}
40005cc0: 81 c3 e0 08 retl
40005cc4: 01 00 00 00 nop
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40005cc8: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40005ccc: 81 c3 e0 08 retl <== NOT EXECUTED
40005cd0: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
40005cd4 <rtems_configuration_get_maximum_semaphores>:
40005cd4: 03 10 00 58 sethi %hi(0x40016000), %g1
40005cd8: 84 10 61 dc or %g1, 0x1dc, %g2 ! 400161dc <_Semaphore_Information>
if ( _Objects_Is_auto_extend( info ) ) {
40005cdc: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2
40005ce0: 80 a0 a0 00 cmp %g2, 0
40005ce4: 12 80 00 04 bne 40005cf4 <rtems_configuration_get_maximum_semaphores+0x20><== NEVER TAKEN
40005ce8: d0 10 61 de lduh [ %g1 + 0x1de ], %o0
uint32_t rtems_configuration_get_maximum_semaphores( void )
{
return get_config_max( &_Semaphore_Information );
}
40005cec: 81 c3 e0 08 retl
40005cf0: 01 00 00 00 nop
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40005cf4: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40005cf8: 81 c3 e0 08 retl <== NOT EXECUTED
40005cfc: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
40005d2c <rtems_configuration_get_maximum_tasks>:
40005d2c: 03 10 00 57 sethi %hi(0x40015c00), %g1
40005d30: 84 10 61 a8 or %g1, 0x1a8, %g2 ! 40015da8 <_RTEMS_tasks_Information>
if ( _Objects_Is_auto_extend( info ) ) {
40005d34: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2
40005d38: 80 a0 a0 00 cmp %g2, 0
40005d3c: 12 80 00 04 bne 40005d4c <rtems_configuration_get_maximum_tasks+0x20> <== NEVER TAKEN
40005d40: d0 10 61 aa lduh [ %g1 + 0x1aa ], %o0
uint32_t rtems_configuration_get_maximum_tasks( void )
{
return get_config_max( &_RTEMS_tasks_Information.Objects );
}
40005d44: 81 c3 e0 08 retl
40005d48: 01 00 00 00 nop
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40005d4c: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40005d50: 81 c3 e0 08 retl <== NOT EXECUTED
40005d54: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
40005d00 <rtems_configuration_get_maximum_timers>:
40005d00: 03 10 00 58 sethi %hi(0x40016000), %g1
40005d04: 84 10 61 ac or %g1, 0x1ac, %g2 ! 400161ac <_Timer_Information>
if ( _Objects_Is_auto_extend( info ) ) {
40005d08: c4 10 a0 12 lduh [ %g2 + 0x12 ], %g2
40005d0c: 80 a0 a0 00 cmp %g2, 0
40005d10: 12 80 00 04 bne 40005d20 <rtems_configuration_get_maximum_timers+0x20> <== NEVER TAKEN
40005d14: d0 10 61 ae lduh [ %g1 + 0x1ae ], %o0
uint32_t rtems_configuration_get_maximum_timers( void )
{
return get_config_max( &_Timer_Information );
}
40005d18: 81 c3 e0 08 retl
40005d1c: 01 00 00 00 nop
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
40005d20: 11 20 00 00 sethi %hi(0x80000000), %o0 <== NOT EXECUTED
}
40005d24: 81 c3 e0 08 retl <== NOT EXECUTED
40005d28: 90 10 80 08 or %g2, %o0, %o0 <== NOT EXECUTED
40004900 <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
40004900: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
40004904: 90 10 20 01 mov 1, %o0
40004908: 40 00 00 1a call 40004970 <_Terminate>
4000490c: 92 10 00 18 mov %i0, %o1
40004910: 01 00 00 00 nop <== NOT EXECUTED
40007c94 <rtems_initialize_executive>:
RTEMS_SYSINIT_IDLE_THREADS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
40007c94: 9d e3 bf a0 save %sp, -96, %sp
RTEMS_INLINE_ROUTINE uintptr_t _Linker_set_Obfuscate( const void *ptr )
{
uintptr_t addr;
addr = (uintptr_t) ptr;
40007c98: 3b 10 00 62 sethi %hi(0x40018800), %i5
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40007c9c: 39 10 00 62 sethi %hi(0x40018800), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
40007ca0: ba 17 62 70 or %i5, 0x270, %i5
40007ca4: b8 17 22 bc or %i4, 0x2bc, %i4
40007ca8: 80 a7 40 1c cmp %i5, %i4
40007cac: 02 80 00 09 be 40007cd0 <rtems_initialize_executive+0x3c> <== NEVER TAKEN
40007cb0: 03 10 00 71 sethi %hi(0x4001c400), %g1
( *item->handler )();
40007cb4: c2 07 40 00 ld [ %i5 ], %g1
40007cb8: 9f c0 40 00 call %g1
40007cbc: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40007cc0: 80 a7 40 1c cmp %i5, %i4
40007cc4: 32 bf ff fd bne,a 40007cb8 <rtems_initialize_executive+0x24>
40007cc8: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
40007ccc: 03 10 00 71 sethi %hi(0x4001c400), %g1
40007cd0: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
40007cd4: 40 00 0a c4 call 4000a7e4 <_Thread_Start_multitasking>
40007cd8: c4 20 63 bc st %g2, [ %g1 + 0x3bc ]
40007cdc: 01 00 00 00 nop <== NOT EXECUTED
400064a4 <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
)
{
400064a4: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major_limit = _IO_Number_of_drivers;
400064a8: 39 10 00 4f sethi %hi(0x40013c00), %i4
ISR_lock_Context lock_context;
if ( rtems_interrupt_is_in_progress() )
400064ac: 40 00 02 f8 call 4000708c <_ISR_Is_in_progress>
400064b0: fa 07 20 14 ld [ %i4 + 0x14 ], %i5 ! 40013c14 <_IO_Number_of_drivers>
400064b4: 80 a2 20 00 cmp %o0, 0
400064b8: 12 80 00 1d bne 4000652c <rtems_io_register_driver+0x88>
400064bc: 80 a6 a0 00 cmp %i2, 0
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
400064c0: 02 80 00 21 be 40006544 <rtems_io_register_driver+0xa0>
400064c4: 80 a6 60 00 cmp %i1, 0
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
400064c8: 02 80 00 1f be 40006544 <rtems_io_register_driver+0xa0>
400064cc: fa 26 80 00 st %i5, [ %i2 ]
return table->initialization_entry == NULL && table->open_entry == NULL;
400064d0: c2 06 40 00 ld [ %i1 ], %g1
400064d4: 80 a0 60 00 cmp %g1, 0
400064d8: 22 80 00 18 be,a 40006538 <rtems_io_register_driver+0x94>
400064dc: c2 06 60 04 ld [ %i1 + 4 ], %g1
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
400064e0: 80 a7 40 18 cmp %i5, %i0
400064e4: 08 80 00 4d bleu 40006618 <rtems_io_register_driver+0x174>
400064e8: 82 10 20 0a mov 0xa, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400064ec: 91 d0 20 09 ta 9
return RTEMS_INVALID_NUMBER;
_IO_Driver_registration_acquire( &lock_context );
if ( major == 0 ) {
400064f0: 80 a6 20 00 cmp %i0, 0
400064f4: 02 80 00 34 be 400065c4 <rtems_io_register_driver+0x120>
400064f8: 87 2e 20 01 sll %i0, 1, %g3
_IO_Driver_registration_release( &lock_context );
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
400064fc: 05 10 00 5b sethi %hi(0x40016c00), %g2
40006500: 86 00 c0 18 add %g3, %i0, %g3
40006504: 84 10 a1 38 or %g2, 0x138, %g2
40006508: 89 28 e0 03 sll %g3, 3, %g4
return table->initialization_entry == NULL && table->open_entry == NULL;
4000650c: fa 00 80 04 ld [ %g2 + %g4 ], %i5
40006510: 80 a7 60 00 cmp %i5, 0
40006514: 02 80 00 0f be 40006550 <rtems_io_register_driver+0xac>
40006518: 88 00 80 04 add %g2, %g4, %g4
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000651c: 91 d0 20 0a ta 0xa
40006520: 01 00 00 00 nop
if ( !rtems_io_is_empty_table( table ) ) {
_IO_Driver_registration_release( &lock_context );
return RTEMS_RESOURCE_IN_USE;
40006524: 10 80 00 03 b 40006530 <rtems_io_register_driver+0x8c>
40006528: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
return RTEMS_CALLED_FROM_ISR;
4000652c: 82 10 20 12 mov 0x12, %g1
/* The driver will be initialized together with all other drivers
* in a later stage by _IO_Initialize_all_drivers().
*/
return RTEMS_SUCCESSFUL;
}
}
40006530: 81 c7 e0 08 ret
40006534: 91 e8 00 01 restore %g0, %g1, %o0
return table->initialization_entry == NULL && table->open_entry == NULL;
40006538: 80 a0 60 00 cmp %g1, 0
4000653c: 12 bf ff ea bne 400064e4 <rtems_io_register_driver+0x40>
40006540: 80 a7 40 18 cmp %i5, %i0
return RTEMS_INVALID_ADDRESS;
40006544: 82 10 20 09 mov 9, %g1
}
40006548: 81 c7 e0 08 ret
4000654c: 91 e8 00 01 restore %g0, %g1, %o0
return table->initialization_entry == NULL && table->open_entry == NULL;
40006550: c8 01 20 04 ld [ %g4 + 4 ], %g4
40006554: 80 a1 20 00 cmp %g4, 0
40006558: 12 bf ff f1 bne 4000651c <rtems_io_register_driver+0x78>
4000655c: 01 00 00 00 nop
*registered_major = major;
40006560: f0 26 80 00 st %i0, [ %i2 ]
_IO_Driver_address_table [major] = *driver_table;
40006564: 87 28 e0 03 sll %g3, 3, %g3
40006568: c8 06 40 00 ld [ %i1 ], %g4
4000656c: c8 20 80 03 st %g4, [ %g2 + %g3 ]
40006570: 84 00 80 03 add %g2, %g3, %g2
40006574: c6 06 60 04 ld [ %i1 + 4 ], %g3
40006578: c6 20 a0 04 st %g3, [ %g2 + 4 ]
4000657c: c6 06 60 08 ld [ %i1 + 8 ], %g3
40006580: c6 20 a0 08 st %g3, [ %g2 + 8 ]
40006584: c6 06 60 0c ld [ %i1 + 0xc ], %g3
40006588: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
4000658c: c6 06 60 10 ld [ %i1 + 0x10 ], %g3
40006590: c6 20 a0 10 st %g3, [ %g2 + 0x10 ]
40006594: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
40006598: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
4000659c: 91 d0 20 0a ta 0xa
400065a0: 01 00 00 00 nop
if ( _IO_All_drivers_initialized ) {
400065a4: 03 10 00 61 sethi %hi(0x40018400), %g1
400065a8: c4 08 62 9c ldub [ %g1 + 0x29c ], %g2 ! 4001869c <_IO_All_drivers_initialized>
400065ac: 80 a0 a0 00 cmp %g2, 0
400065b0: 02 bf ff e0 be 40006530 <rtems_io_register_driver+0x8c> <== NEVER TAKEN
400065b4: 82 10 20 00 clr %g1
return rtems_io_initialize( major, 0, NULL );
400065b8: b4 10 20 00 clr %i2
400065bc: 7f ff ff a4 call 4000644c <rtems_io_initialize>
400065c0: 93 e8 20 00 restore %g0, 0, %o1
rtems_device_major_number n = _IO_Number_of_drivers;
400065c4: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
for ( m = 0; m < n; ++m ) {
400065c8: 80 a7 60 00 cmp %i5, 0
400065cc: 02 80 00 1a be 40006634 <rtems_io_register_driver+0x190> <== NEVER TAKEN
400065d0: 05 10 00 5b sethi %hi(0x40016c00), %g2
400065d4: 84 10 a1 38 or %g2, 0x138, %g2 ! 40016d38 <_IO_Driver_address_table>
400065d8: 10 80 00 05 b 400065ec <rtems_io_register_driver+0x148>
400065dc: 86 10 00 02 mov %g2, %g3
400065e0: 80 a7 40 18 cmp %i5, %i0
400065e4: 02 80 00 0f be 40006620 <rtems_io_register_driver+0x17c>
400065e8: 86 00 e0 18 add %g3, 0x18, %g3
return table->initialization_entry == NULL && table->open_entry == NULL;
400065ec: c8 00 c0 00 ld [ %g3 ], %g4
400065f0: 80 a1 20 00 cmp %g4, 0
400065f4: 32 bf ff fb bne,a 400065e0 <rtems_io_register_driver+0x13c>
400065f8: b0 06 20 01 inc %i0
400065fc: c8 00 e0 04 ld [ %g3 + 4 ], %g4
40006600: 80 a1 20 00 cmp %g4, 0
40006604: 32 bf ff f7 bne,a 400065e0 <rtems_io_register_driver+0x13c>
40006608: b0 06 20 01 inc %i0
*major = m;
4000660c: f0 26 80 00 st %i0, [ %i2 ]
if ( m != n )
40006610: 10 bf ff d5 b 40006564 <rtems_io_register_driver+0xc0>
40006614: 86 5e 20 03 smul %i0, 3, %g3
}
40006618: 81 c7 e0 08 ret
4000661c: 91 e8 00 01 restore %g0, %g1, %o0
*major = m;
40006620: fa 26 80 00 st %i5, [ %i2 ]
40006624: 91 d0 20 0a ta 0xa
40006628: 01 00 00 00 nop
return sc;
4000662c: 10 bf ff c1 b 40006530 <rtems_io_register_driver+0x8c>
40006630: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
*major = m;
40006634: 10 bf ff fc b 40006624 <rtems_io_register_driver+0x180> <== NOT EXECUTED
40006638: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
40004200 <rtems_panic>:
#include <rtems/bspIo.h>
#include <stdarg.h>
void rtems_panic( const char *fmt, ... )
{
40004200: 9d e3 bf 98 save %sp, -104, %sp
va_list ap;
va_start( ap, fmt );
40004204: 92 07 a0 48 add %fp, 0x48, %o1
40004208: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
vprintk( fmt, ap );
4000420c: 90 10 00 18 mov %i0, %o0
va_start( ap, fmt );
40004210: d2 27 bf fc st %o1, [ %fp + -4 ]
40004214: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40004218: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4000421c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
vprintk( fmt, ap );
40004220: 40 00 0a 3d call 40006b14 <vprintk>
40004224: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
va_end( ap);
_Terminate( RTEMS_FATAL_SOURCE_PANIC, (Internal_errors_t) fmt );
40004228: 92 10 00 18 mov %i0, %o1
4000422c: 40 00 00 17 call 40004288 <_Terminate>
40004230: 90 10 20 0b mov 0xb, %o0
40004234: 01 00 00 00 nop <== NOT EXECUTED
40004b5c <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
40004b5c: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = NULL;
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
40004b60: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
uintptr_t excess = value % alignment;
40004b64: 81 80 20 00 wr %g0, %y
40004b68: 01 00 00 00 nop
40004b6c: 01 00 00 00 nop
40004b70: 01 00 00 00 nop
40004b74: b6 76 40 01 udiv %i1, %g1, %i3
40004b78: b6 5e c0 01 smul %i3, %g1, %i3
if (excess > 0) {
40004b7c: b6 a6 40 1b subcc %i1, %i3, %i3
40004b80: 22 80 00 23 be,a 40004c0c <rtems_rbheap_allocate+0xb0>
40004b84: b6 10 00 19 mov %i1, %i3
value += alignment - excess;
40004b88: 82 00 40 19 add %g1, %i1, %g1
40004b8c: b6 20 40 1b sub %g1, %i3, %i3
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
40004b90: 80 a6 c0 19 cmp %i3, %i1
40004b94: 82 60 3f ff subx %g0, -1, %g1
40004b98: 80 a6 60 00 cmp %i1, 0
40004b9c: 02 80 00 1a be 40004c04 <rtems_rbheap_allocate+0xa8>
40004ba0: 80 88 60 ff btst 0xff, %g1
40004ba4: 02 80 00 18 be 40004c04 <rtems_rbheap_allocate+0xa8> <== NEVER TAKEN
40004ba8: 82 06 20 04 add %i0, 4, %g1
return _Chain_Immutable_head( the_chain )->next;
40004bac: fa 06 00 00 ld [ %i0 ], %i5
while (current != tail && big_enough == NULL) {
40004bb0: 80 a7 40 01 cmp %i5, %g1
40004bb4: 02 80 00 14 be 40004c04 <rtems_rbheap_allocate+0xa8>
40004bb8: 01 00 00 00 nop
if (free_chunk->size >= size) {
40004bbc: f8 07 60 1c ld [ %i5 + 0x1c ], %i4
40004bc0: 80 a6 c0 1c cmp %i3, %i4
40004bc4: 38 80 00 0d bgu,a 40004bf8 <rtems_rbheap_allocate+0x9c>
40004bc8: fa 07 40 00 ld [ %i5 ], %i5
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
40004bcc: 80 a7 00 1b cmp %i4, %i3
40004bd0: 38 80 00 11 bgu,a 40004c14 <rtems_rbheap_allocate+0xb8>
40004bd4: f4 06 20 0c ld [ %i0 + 0xc ], %i2
next = the_node->next;
40004bd8: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40004bdc: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
40004be0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40004be4: c4 20 40 00 st %g2, [ %g1 ]
node->next = NULL;
40004be8: c0 27 40 00 clr [ %i5 ]
ptr = (void *) new_chunk->begin;
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
40004bec: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
}
}
}
return ptr;
40004bf0: 81 c7 e0 08 ret
40004bf4: 81 e8 00 00 restore
while (current != tail && big_enough == NULL) {
40004bf8: 80 a0 40 1d cmp %g1, %i5
40004bfc: 32 bf ff f1 bne,a 40004bc0 <rtems_rbheap_allocate+0x64> <== NEVER TAKEN
40004c00: f8 07 60 1c ld [ %i5 + 0x1c ], %i4 <== NOT EXECUTED
void *ptr = NULL;
40004c04: 81 c7 e0 08 ret
40004c08: 91 e8 20 00 restore %g0, 0, %o0
40004c0c: 10 bf ff e3 b 40004b98 <rtems_rbheap_allocate+0x3c>
40004c10: 82 10 20 01 mov 1, %g1
return &the_chain->Tail.Node;
40004c14: b2 06 20 10 add %i0, 0x10, %i1
if ( !_Chain_Is_empty(the_chain))
40004c18: 80 a6 80 19 cmp %i2, %i1
40004c1c: 02 80 00 15 be 40004c70 <rtems_rbheap_allocate+0x114>
40004c20: a0 06 20 0c add %i0, 0xc, %l0
new_first = old_first->next;
40004c24: c2 06 80 00 ld [ %i2 ], %g1
head->next = new_first;
40004c28: c2 26 20 0c st %g1, [ %i0 + 0xc ]
uintptr_t new_free_size = free_size - aligned_size;
40004c2c: b8 27 00 1b sub %i4, %i3, %i4
new_first->previous = head;
40004c30: e0 20 60 04 st %l0, [ %g1 + 4 ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40004c34: 96 10 20 01 mov 1, %o3
free_chunk->size = new_free_size;
40004c38: f8 27 60 1c st %i4, [ %i5 + 0x1c ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40004c3c: 92 06 a0 08 add %i2, 8, %o1
new_chunk->begin = free_chunk->begin + new_free_size;
40004c40: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40004c44: b8 00 40 1c add %g1, %i4, %i4
new_chunk->size = aligned_size;
40004c48: f6 26 a0 1c st %i3, [ %i2 + 0x1c ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40004c4c: 90 06 20 18 add %i0, 0x18, %o0
new_chunk->begin = free_chunk->begin + new_free_size;
40004c50: f8 26 a0 18 st %i4, [ %i2 + 0x18 ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40004c54: 15 10 00 12 sethi %hi(0x40004800), %o2
node->next = NULL;
40004c58: c0 26 80 00 clr [ %i2 ]
40004c5c: 40 00 00 8a call 40004e84 <rtems_rbtree_insert>
40004c60: 94 12 a2 18 or %o2, 0x218, %o2
ptr = (void *) new_chunk->begin;
40004c64: f0 06 a0 18 ld [ %i2 + 0x18 ], %i0
}
40004c68: 81 c7 e0 08 ret
40004c6c: 81 e8 00 00 restore
(*control->extend_descriptors)(control);
40004c70: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40004c74: 9f c0 40 00 call %g1
40004c78: 90 10 00 18 mov %i0, %o0
return _Chain_Immutable_head( the_chain )->next;
40004c7c: f4 06 20 0c ld [ %i0 + 0xc ], %i2
if ( !_Chain_Is_empty(the_chain))
40004c80: 80 a6 40 1a cmp %i1, %i2
40004c84: 32 bf ff e9 bne,a 40004c28 <rtems_rbheap_allocate+0xcc>
40004c88: c2 06 80 00 ld [ %i2 ], %g1
40004c8c: 30 bf ff de b,a 40004c04 <rtems_rbheap_allocate+0xa8>
40004a30 <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
40004a30: 9d e3 bf a0 save %sp, -96, %sp
/*
* Ensure that the alignment is at least two, so that we can keep
* chunk_compare() that simple.
*/
alignment = alignment < 2 ? 2 : alignment;
40004a34: 80 a6 e0 02 cmp %i3, 2
40004a38: 1a 80 00 03 bcc 40004a44 <rtems_rbheap_initialize+0x14> <== ALWAYS TAKEN
40004a3c: b4 06 40 1a add %i1, %i2, %i2
40004a40: b6 10 20 02 mov 2, %i3 <== NOT EXECUTED
uintptr_t excess = value % alignment;
40004a44: 81 80 20 00 wr %g0, %y
40004a48: 01 00 00 00 nop
40004a4c: 01 00 00 00 nop
40004a50: 01 00 00 00 nop
40004a54: 82 76 40 1b udiv %i1, %i3, %g1
40004a58: 82 58 40 1b smul %g1, %i3, %g1
if (excess > 0) {
40004a5c: 82 a6 40 01 subcc %i1, %g1, %g1
40004a60: 02 80 00 15 be 40004ab4 <rtems_rbheap_initialize+0x84>
40004a64: a0 10 00 19 mov %i1, %l0
value += alignment - excess;
40004a68: a0 06 40 1b add %i1, %i3, %l0
40004a6c: a0 24 00 01 sub %l0, %g1, %l0
aligned_begin = align_up(alignment, begin);
aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40004a70: 80 a4 00 19 cmp %l0, %i1
40004a74: 82 60 3f ff subx %g0, -1, %g1
40004a78: 80 a6 40 1a cmp %i1, %i2
uintptr_t excess = value % alignment;
40004a7c: 81 80 20 00 wr %g0, %y
40004a80: 01 00 00 00 nop
40004a84: 01 00 00 00 nop
40004a88: 01 00 00 00 nop
40004a8c: b4 76 80 1b udiv %i2, %i3, %i2
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40004a90: 84 40 20 00 addx %g0, 0, %g2
40004a94: 80 88 80 01 btst %g2, %g1
40004a98: 02 80 00 05 be 40004aac <rtems_rbheap_initialize+0x7c>
40004a9c: b4 5e 80 1b smul %i2, %i3, %i2
40004aa0: 80 a4 00 1a cmp %l0, %i2
40004aa4: 0a 80 00 06 bcs 40004abc <rtems_rbheap_initialize+0x8c>
40004aa8: 82 06 20 04 add %i0, 4, %g1
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
40004aac: 81 c7 e0 08 ret
40004ab0: 91 e8 20 09 restore %g0, 9, %o0
40004ab4: 10 bf ff f1 b 40004a78 <rtems_rbheap_initialize+0x48>
40004ab8: 82 10 20 01 mov 1, %g1
return &the_chain->Tail.Node;
40004abc: b2 06 20 10 add %i0, 0x10, %i1
head->next = tail;
40004ac0: c2 26 00 00 st %g1, [ %i0 ]
return &the_chain->Head.Node;
40004ac4: a2 06 20 0c add %i0, 0xc, %l1
head->previous = NULL;
40004ac8: c0 26 20 04 clr [ %i0 + 4 ]
(*control->extend_descriptors)(control);
40004acc: 90 10 00 18 mov %i0, %o0
tail->previous = head;
40004ad0: f0 26 20 08 st %i0, [ %i0 + 8 ]
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
40004ad4: a4 06 20 18 add %i0, 0x18, %l2
head->next = tail;
40004ad8: f2 26 20 0c st %i1, [ %i0 + 0xc ]
head->previous = NULL;
40004adc: c0 26 20 10 clr [ %i0 + 0x10 ]
tail->previous = head;
40004ae0: e2 26 20 14 st %l1, [ %i0 + 0x14 ]
*/
RTEMS_INLINE_ROUTINE void _RBTree_Initialize_empty(
RBTree_Control *the_rbtree
)
{
RB_INIT( the_rbtree );
40004ae4: c0 26 20 18 clr [ %i0 + 0x18 ]
control->alignment = alignment;
40004ae8: f6 26 20 1c st %i3, [ %i0 + 0x1c ]
control->handler_arg = handler_arg;
40004aec: fa 26 20 24 st %i5, [ %i0 + 0x24 ]
(*control->extend_descriptors)(control);
40004af0: 9f c7 00 00 call %i4
40004af4: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
return _Chain_Immutable_head( the_chain )->next;
40004af8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if ( !_Chain_Is_empty(the_chain))
40004afc: 80 a6 40 01 cmp %i1, %g1
40004b00: 02 80 00 15 be 40004b54 <rtems_rbheap_initialize+0x124>
40004b04: b4 26 80 10 sub %i2, %l0, %i2
new_first = old_first->next;
40004b08: c4 00 40 00 ld [ %g1 ], %g2
head->next = new_first;
40004b0c: c4 26 20 0c st %g2, [ %i0 + 0xc ]
new_first->previous = head;
40004b10: e2 20 a0 04 st %l1, [ %g2 + 4 ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40004b14: 96 10 20 01 mov 1, %o3
the_node->previous = after_node;
40004b18: f0 20 60 04 st %i0, [ %g1 + 4 ]
40004b1c: 92 00 60 08 add %g1, 8, %o1
first->begin = aligned_begin;
40004b20: e0 20 60 18 st %l0, [ %g1 + 0x18 ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40004b24: 90 10 00 12 mov %l2, %o0
first->size = aligned_end - aligned_begin;
40004b28: f4 20 60 1c st %i2, [ %g1 + 0x1c ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40004b2c: 15 10 00 12 sethi %hi(0x40004800), %o2
before_node = after_node->next;
40004b30: c4 06 00 00 ld [ %i0 ], %g2
after_node->next = the_node;
40004b34: c2 26 00 00 st %g1, [ %i0 ]
40004b38: 94 12 a2 18 or %o2, 0x218, %o2
the_node->next = before_node;
40004b3c: c4 20 40 00 st %g2, [ %g1 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
40004b40: b0 10 20 00 clr %i0
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40004b44: 40 00 00 d0 call 40004e84 <rtems_rbtree_insert>
40004b48: c2 20 a0 04 st %g1, [ %g2 + 4 ]
}
40004b4c: 81 c7 e0 08 ret
40004b50: 81 e8 00 00 restore
}
return sc;
}
40004b54: 81 c7 e0 08 ret
40004b58: 91 e8 20 1a restore %g0, 0x1a, %o0
40004e24 <rtems_rbtree_find>:
const rtems_rbtree_control *the_rbtree,
const rtems_rbtree_node *the_node,
rtems_rbtree_compare compare,
bool is_unique
)
{
40004e24: 9d e3 bf a0 save %sp, -96, %sp
return RB_ROOT( the_rbtree );
40004e28: fa 06 00 00 ld [ %i0 ], %i5
rtems_rbtree_node *iter_node = rtems_rbtree_root( the_rbtree );
rtems_rbtree_node *found = NULL;
while ( iter_node != NULL ) {
40004e2c: 80 a7 60 00 cmp %i5, 0
40004e30: 02 80 00 0f be 40004e6c <rtems_rbtree_find+0x48> <== NEVER TAKEN
40004e34: b0 10 20 00 clr %i0
rtems_rbtree_compare_result compare_result =
( *compare )( the_node, iter_node );
40004e38: 92 10 00 1d mov %i5, %o1
40004e3c: 9f c6 80 00 call %i2
40004e40: 90 10 00 19 mov %i1, %o0
if ( rtems_rbtree_is_equal( compare_result ) ) {
40004e44: 80 a2 20 00 cmp %o0, 0
40004e48: 12 80 00 0b bne 40004e74 <rtems_rbtree_find+0x50>
40004e4c: 01 00 00 00 nop
found = iter_node;
if ( is_unique )
40004e50: 80 a6 e0 00 cmp %i3, 0
40004e54: 12 80 00 06 bne 40004e6c <rtems_rbtree_find+0x48>
40004e58: b0 10 00 1d mov %i5, %i0
return RB_LEFT( the_node, Node );
40004e5c: fa 07 40 00 ld [ %i5 ], %i5
while ( iter_node != NULL ) {
40004e60: 80 a7 60 00 cmp %i5, 0
40004e64: 12 bf ff f6 bne 40004e3c <rtems_rbtree_find+0x18>
40004e68: 92 10 00 1d mov %i5, %o1
40004e6c: 81 c7 e0 08 ret
40004e70: 81 e8 00 00 restore
break;
}
if ( rtems_rbtree_is_greater( compare_result ) ) {
40004e74: 24 bf ff fb ble,a 40004e60 <rtems_rbtree_find+0x3c>
40004e78: fa 07 40 00 ld [ %i5 ], %i5
40004e7c: 10 bf ff f9 b 40004e60 <rtems_rbtree_find+0x3c>
40004e80: fa 07 60 04 ld [ %i5 + 4 ], %i5
40005e08 <rtems_rbtree_initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
40005e08: 9d e3 bf a0 save %sp, -96, %sp
40005e0c: c0 26 00 00 clr [ %i0 ]
rtems_rbtree_initialize_empty( the_rbtree );
count = number_nodes;
next = starting_address;
while ( count-- ) {
40005e10: 80 a6 e0 00 cmp %i3, 0
40005e14: 02 80 00 0b be 40005e40 <rtems_rbtree_initialize+0x38> <== NEVER TAKEN
40005e18: a0 06 ff ff add %i3, -1, %l0
rtems_rbtree_insert( the_rbtree, next, compare, is_unique );
40005e1c: 92 10 00 1a mov %i2, %o1
40005e20: 96 10 00 1d mov %i5, %o3
40005e24: 94 10 00 19 mov %i1, %o2
40005e28: 40 00 00 20 call 40005ea8 <rtems_rbtree_insert>
40005e2c: 90 10 00 18 mov %i0, %o0
while ( count-- ) {
40005e30: a0 04 3f ff add %l0, -1, %l0
40005e34: 80 a4 3f ff cmp %l0, -1
40005e38: 12 bf ff f9 bne 40005e1c <rtems_rbtree_initialize+0x14>
40005e3c: b4 06 80 1c add %i2, %i4, %i2
next = (rtems_rbtree_node *) _Addresses_Add_offset( next, node_size );
}
}
40005e40: 81 c7 e0 08 ret
40005e44: 81 e8 00 00 restore
4000eda0 <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
4000eda0: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
4000eda4: 90 10 20 05 mov 5, %o0
4000eda8: 7f ff d6 f2 call 40004970 <_Terminate>
4000edac: 92 10 00 18 mov %i0, %o1
4000edb0: 01 00 00 00 nop <== NOT EXECUTED