40005ff8 <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
40005ff8: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
40005ffc: 03 10 00 49 sethi %hi(0x40012400), %g1
40006000: 84 10 20 01 mov 1, %g2
40006004: c4 28 60 e0 stb %g2, [ %g1 + 0xe0 ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40006008: 03 10 00 3c sethi %hi(0x4000f000), %g1
4000600c: f8 00 62 94 ld [ %g1 + 0x294 ], %i4 ! 4000f294 <_IO_Number_of_drivers>
40006010: 80 a7 20 00 cmp %i4, 0
40006014: 02 80 00 0a be 4000603c <_IO_Initialize_all_drivers+0x44> <== NEVER TAKEN
40006018: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
4000601c: 90 10 00 1d mov %i5, %o0
40006020: 94 10 20 00 clr %o2
40006024: 40 00 1a 4d call 4000c958 <rtems_io_initialize>
40006028: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
4000602c: ba 07 60 01 inc %i5
40006030: 80 a7 40 1c cmp %i5, %i4
40006034: 12 bf ff fb bne 40006020 <_IO_Initialize_all_drivers+0x28> <== NEVER TAKEN
40006038: 90 10 00 1d mov %i5, %o0
}
4000603c: 81 c7 e0 08 ret
40006040: 81 e8 00 00 restore
4000f780 <_Objects_Information_table>:
4000f780: 00 00 00 00 40 01 1f 28 40 01 1e fc 40 01 1e c8 ....@..(@...@...
4000f790: 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 00 00 00 00 _Allocator......
4000f7a0: 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 00 00 00 00 (fmt null)......
4000f7b0: 28 6e 75 6c 6c 29 00 (null).
40005fd8 <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
40005fd8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
40005fdc: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
40005fe0: 40 00 02 18 call 40006840 <_Terminate>
<== NOT EXECUTED
40005fe4: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40005fe8: 01 00 00 00 nop
<== NOT EXECUTED
40005fec <rtems_get_version_string>:
#include <rtems.h>
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
40005fec: 11 10 00 3f sethi %hi(0x4000fc00), %o0
<== NOT EXECUTED
}
40005ff0: 81 c3 e0 08 retl
<== NOT EXECUTED
40005ff4: 90 12 20 b0 or %o0, 0xb0, %o0 ! 4000fcb0 <_RTEMS_version>
<== NOT EXECUTED
40005f8c <rtems_initialize_executive>:
RTEMS_SYSINIT_DEVICE_DRIVERS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
40005f8c: 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;
40005f90: 3b 10 00 3f sethi %hi(0x4000fc00), %i5
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40005f94: 39 10 00 3f sethi %hi(0x4000fc00), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
40005f98: ba 17 61 10 or %i5, 0x110, %i5
40005f9c: b8 17 21 58 or %i4, 0x158, %i4
40005fa0: 80 a7 40 1c cmp %i5, %i4
40005fa4: 02 80 00 09 be 40005fc8 <rtems_initialize_executive+0x3c> <== NEVER TAKEN
40005fa8: 03 10 00 49 sethi %hi(0x40012400), %g1
( *item->handler )();
40005fac: c2 07 40 00 ld [ %i5 ], %g1
40005fb0: 9f c0 40 00 call %g1
40005fb4: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40005fb8: 80 a7 40 1c cmp %i5, %i4
40005fbc: 32 bf ff fd bne,a 40005fb0 <rtems_initialize_executive+0x24>
40005fc0: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
40005fc4: 03 10 00 49 sethi %hi(0x40012400), %g1
40005fc8: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
40005fcc: 40 00 11 9e call 4000a644 <_Thread_Start_multitasking>
40005fd0: c4 20 60 ec st %g2, [ %g1 + 0xec ]
40005fd4: 01 00 00 00 nop
<== NOT EXECUTED
4000c898 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000c898: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000c89c: 03 10 00 3c sethi %hi(0x4000f000), %g1
<== NOT EXECUTED
4000c8a0: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 4000f294 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000c8a4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000c8a8: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000c8ac: 08 80 00 11 bleu 4000c8f0 <rtems_io_close+0x58>
<== NOT EXECUTED
4000c8b0: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
4000c8b4: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000c8b8: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000c8bc: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000c8c0: 03 10 00 44 sethi %hi(0x40011000), %g1
<== NOT EXECUTED
4000c8c4: 82 10 62 0c or %g1, 0x20c, %g1 ! 4001120c <_IO_Driver_address_table>
<== NOT EXECUTED
4000c8c8: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000c8cc: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000c8d0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000c8d4: 02 80 00 06 be 4000c8ec <rtems_io_close+0x54>
<== NOT EXECUTED
4000c8d8: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000c8dc: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000c8e0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000c8e4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c8e8: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000c8ec: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000c8f0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c8f4: 81 e8 00 00 restore
<== NOT EXECUTED
4000c8f8 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000c8f8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000c8fc: 03 10 00 3c sethi %hi(0x4000f000), %g1
<== NOT EXECUTED
4000c900: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 4000f294 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000c904: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000c908: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000c90c: 08 80 00 11 bleu 4000c950 <rtems_io_control+0x58>
<== NOT EXECUTED
4000c910: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
4000c914: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000c918: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000c91c: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000c920: 03 10 00 44 sethi %hi(0x40011000), %g1
<== NOT EXECUTED
4000c924: 82 10 62 0c or %g1, 0x20c, %g1 ! 4001120c <_IO_Driver_address_table>
<== NOT EXECUTED
4000c928: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000c92c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000c930: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000c934: 02 80 00 06 be 4000c94c <rtems_io_control+0x54>
<== NOT EXECUTED
4000c938: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000c93c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000c940: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000c944: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c948: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000c94c: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000c950: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c954: 81 e8 00 00 restore
<== NOT EXECUTED
4000c958 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000c958: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000c95c: 03 10 00 3c sethi %hi(0x4000f000), %g1
4000c960: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 4000f294 <_IO_Number_of_drivers>
{
4000c964: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000c968: 80 a0 40 08 cmp %g1, %o0
4000c96c: 08 80 00 10 bleu 4000c9ac <rtems_io_initialize+0x54>
<== NEVER TAKEN
4000c970: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
4000c974: 83 2a 20 01 sll %o0, 1, %g1
4000c978: 07 10 00 44 sethi %hi(0x40011000), %g3
4000c97c: 82 00 40 08 add %g1, %o0, %g1
4000c980: 86 10 e2 0c or %g3, 0x20c, %g3
4000c984: 83 28 60 03 sll %g1, 3, %g1
4000c988: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000c98c: 80 a0 60 00 cmp %g1, 0
4000c990: 02 80 00 06 be 4000c9a8 <rtems_io_initialize+0x50>
<== ALWAYS TAKEN
4000c994: 94 10 00 1a mov %i2, %o2
4000c998: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000c99c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000c9a0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c9a4: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000c9a8: b0 10 20 00 clr %i0
}
4000c9ac: 81 c7 e0 08 ret
4000c9b0: 81 e8 00 00 restore
4000c9b4 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000c9b4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000c9b8: 03 10 00 3c sethi %hi(0x4000f000), %g1
<== NOT EXECUTED
4000c9bc: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 4000f294 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000c9c0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000c9c4: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000c9c8: 08 80 00 11 bleu 4000ca0c <rtems_io_open+0x58>
<== NOT EXECUTED
4000c9cc: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
4000c9d0: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000c9d4: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000c9d8: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000c9dc: 03 10 00 44 sethi %hi(0x40011000), %g1
<== NOT EXECUTED
4000c9e0: 82 10 62 0c or %g1, 0x20c, %g1 ! 4001120c <_IO_Driver_address_table>
<== NOT EXECUTED
4000c9e4: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000c9e8: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000c9ec: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000c9f0: 02 80 00 06 be 4000ca08 <rtems_io_open+0x54>
<== NOT EXECUTED
4000c9f4: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000c9f8: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000c9fc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000ca00: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ca04: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000ca08: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000ca0c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ca10: 81 e8 00 00 restore
<== NOT EXECUTED
4000ca14 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000ca14: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000ca18: 03 10 00 3c sethi %hi(0x4000f000), %g1
<== NOT EXECUTED
4000ca1c: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 4000f294 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000ca20: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000ca24: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000ca28: 08 80 00 11 bleu 4000ca6c <rtems_io_read+0x58>
<== NOT EXECUTED
4000ca2c: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
4000ca30: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000ca34: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000ca38: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000ca3c: 03 10 00 44 sethi %hi(0x40011000), %g1
<== NOT EXECUTED
4000ca40: 82 10 62 0c or %g1, 0x20c, %g1 ! 4001120c <_IO_Driver_address_table>
<== NOT EXECUTED
4000ca44: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000ca48: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000ca4c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000ca50: 02 80 00 06 be 4000ca68 <rtems_io_read+0x54>
<== NOT EXECUTED
4000ca54: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000ca58: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000ca5c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000ca60: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ca64: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000ca68: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000ca6c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ca70: 81 e8 00 00 restore
<== NOT EXECUTED
4000ca74 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000ca74: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000ca78: 03 10 00 3c sethi %hi(0x4000f000), %g1
<== NOT EXECUTED
4000ca7c: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 4000f294 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000ca80: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000ca84: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000ca88: 08 80 00 11 bleu 4000cacc <rtems_io_write+0x58>
<== NOT EXECUTED
4000ca8c: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
4000ca90: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000ca94: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000ca98: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000ca9c: 03 10 00 44 sethi %hi(0x40011000), %g1
<== NOT EXECUTED
4000caa0: 82 10 62 0c or %g1, 0x20c, %g1 ! 4001120c <_IO_Driver_address_table>
<== NOT EXECUTED
4000caa4: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000caa8: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000caac: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000cab0: 02 80 00 06 be 4000cac8 <rtems_io_write+0x54>
<== NOT EXECUTED
4000cab4: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000cab8: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000cabc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000cac0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000cac4: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000cac8: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000cacc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000cad0: 81 e8 00 00 restore
<== NOT EXECUTED
4000c884 <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
4000c884: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
4000c888: 90 10 20 05 mov 5, %o0
4000c88c: 7f ff e7 ed call 40006840 <_Terminate>
4000c890: 92 10 00 18 mov %i0, %o1
4000c894: 01 00 00 00 nop
<== NOT EXECUTED