RTEMS-5
Annotated Report
Fri Aug 10 13:39:30 2018
40009a24 <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
40009a24: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
40009a28: 03 10 00 9b sethi %hi(0x40026c00), %g1
40009a2c: 84 10 20 01 mov 1, %g2
40009a30: c4 28 60 70 stb %g2, [ %g1 + 0x70 ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40009a34: 03 10 00 8a sethi %hi(0x40022800), %g1
40009a38: f8 00 63 98 ld [ %g1 + 0x398 ], %i4 ! 40022b98 <_IO_Number_of_drivers>
40009a3c: 80 a7 20 00 cmp %i4, 0
40009a40: 02 80 00 0a be 40009a68 <_IO_Initialize_all_drivers+0x44>
<== NEVER TAKEN
40009a44: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
40009a48: 90 10 00 1d mov %i5, %o0
40009a4c: 94 10 20 00 clr %o2
40009a50: 40 00 29 2b call 40013efc <rtems_io_initialize>
40009a54: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40009a58: ba 07 60 01 inc %i5
40009a5c: 80 a7 40 1c cmp %i5, %i4
40009a60: 12 bf ff fb bne 40009a4c <_IO_Initialize_all_drivers+0x28>
40009a64: 90 10 00 1d mov %i5, %o0
}
40009a68: 81 c7 e0 08 ret
40009a6c: 81 e8 00 00 restore
40023530 <_Objects_Information_table>:
40023530: 00 00 00 00 40 02 63 d0 40 02 63 a4 40 02 63 70 ....@.c.@.c.@.cp
40023540: 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 00 00 00 00 _Allocator......
40023550: 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 00 00 00 00 (fmt null)......
40023560: 28 6e 75 6c 6c 29 00 (null).
40009a04 <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
40009a04: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
40009a08: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
40009a0c: 40 00 02 d2 call 4000a554 <_Terminate>
<== NOT EXECUTED
40009a10: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40009a14: 01 00 00 00 nop
<== NOT EXECUTED
40009a18 <rtems_get_version_string>:
#include <rtems.h>
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
40009a18: 11 10 00 8f sethi %hi(0x40023c00), %o0
<== NOT EXECUTED
}
40009a1c: 81 c3 e0 08 retl
<== NOT EXECUTED
40009a20: 90 12 23 38 or %o0, 0x338, %o0 ! 40023f38 <_RTEMS_version>
<== NOT EXECUTED
400099b8 <rtems_initialize_executive>:
RTEMS_SYSINIT_DEVICE_DRIVERS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
400099b8: 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;
400099bc: 3b 10 00 8f sethi %hi(0x40023c00), %i5
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
400099c0: 39 10 00 8f sethi %hi(0x40023c00), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
400099c4: ba 17 63 90 or %i5, 0x390, %i5
400099c8: b8 17 23 d4 or %i4, 0x3d4, %i4
400099cc: 80 a7 40 1c cmp %i5, %i4
400099d0: 02 80 00 09 be 400099f4 <rtems_initialize_executive+0x3c>
<== NEVER TAKEN
400099d4: 03 10 00 9b sethi %hi(0x40026c00), %g1
( *item->handler )();
400099d8: c2 07 40 00 ld [ %i5 ], %g1
400099dc: 9f c0 40 00 call %g1
400099e0: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
400099e4: 80 a7 40 1c cmp %i5, %i4
400099e8: 32 bf ff fd bne,a 400099dc <rtems_initialize_executive+0x24>
400099ec: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
400099f0: 03 10 00 9b sethi %hi(0x40026c00), %g1
400099f4: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
400099f8: 40 00 14 dd call 4000ed6c <_Thread_Start_multitasking>
400099fc: c4 20 60 7c st %g2, [ %g1 + 0x7c ]
40009a00: 01 00 00 00 nop
<== NOT EXECUTED
40013e3c <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
40013e3c: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
40013e40: 03 10 00 8a sethi %hi(0x40022800), %g1
40013e44: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 40022b98 <_IO_Number_of_drivers>
{
40013e48: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
40013e4c: 80 a0 40 08 cmp %g1, %o0
40013e50: 08 80 00 11 bleu 40013e94 <rtems_io_close+0x58>
<== NEVER TAKEN
40013e54: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
40013e58: 83 2a 20 01 sll %o0, 1, %g1
40013e5c: 82 00 40 08 add %g1, %o0, %g1
40013e60: 85 28 60 03 sll %g1, 3, %g2
40013e64: 03 10 00 94 sethi %hi(0x40025000), %g1
40013e68: 82 10 60 30 or %g1, 0x30, %g1 ! 40025030 <_IO_Driver_address_table>
40013e6c: 82 00 40 02 add %g1, %g2, %g1
40013e70: c2 00 60 08 ld [ %g1 + 8 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40013e74: 80 a0 60 00 cmp %g1, 0
40013e78: 02 80 00 06 be 40013e90 <rtems_io_close+0x54>
<== NEVER TAKEN
40013e7c: 94 10 00 1a mov %i2, %o2
40013e80: 9f c0 40 00 call %g1
40013e84: 92 10 00 19 mov %i1, %o1
40013e88: 81 c7 e0 08 ret
40013e8c: 91 e8 00 08 restore %g0, %o0, %o0
40013e90: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
40013e94: 81 c7 e0 08 ret
<== NOT EXECUTED
40013e98: 81 e8 00 00 restore
<== NOT EXECUTED
40013e9c <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
40013e9c: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
40013ea0: 03 10 00 8a sethi %hi(0x40022800), %g1
40013ea4: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 40022b98 <_IO_Number_of_drivers>
{
40013ea8: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
40013eac: 80 a0 40 08 cmp %g1, %o0
40013eb0: 08 80 00 11 bleu 40013ef4 <rtems_io_control+0x58>
<== NEVER TAKEN
40013eb4: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
40013eb8: 83 2a 20 01 sll %o0, 1, %g1
40013ebc: 82 00 40 08 add %g1, %o0, %g1
40013ec0: 85 28 60 03 sll %g1, 3, %g2
40013ec4: 03 10 00 94 sethi %hi(0x40025000), %g1
40013ec8: 82 10 60 30 or %g1, 0x30, %g1 ! 40025030 <_IO_Driver_address_table>
40013ecc: 82 00 40 02 add %g1, %g2, %g1
40013ed0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40013ed4: 80 a0 60 00 cmp %g1, 0
40013ed8: 02 80 00 06 be 40013ef0 <rtems_io_control+0x54>
<== NEVER TAKEN
40013edc: 94 10 00 1a mov %i2, %o2
40013ee0: 9f c0 40 00 call %g1
40013ee4: 92 10 00 19 mov %i1, %o1
40013ee8: 81 c7 e0 08 ret
40013eec: 91 e8 00 08 restore %g0, %o0, %o0
40013ef0: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
40013ef4: 81 c7 e0 08 ret
<== NOT EXECUTED
40013ef8: 81 e8 00 00 restore
<== NOT EXECUTED
40013efc <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
40013efc: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
40013f00: 03 10 00 8a sethi %hi(0x40022800), %g1
40013f04: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 40022b98 <_IO_Number_of_drivers>
{
40013f08: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
40013f0c: 80 a0 40 08 cmp %g1, %o0
40013f10: 08 80 00 10 bleu 40013f50 <rtems_io_initialize+0x54>
<== NEVER TAKEN
40013f14: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
40013f18: 83 2a 20 01 sll %o0, 1, %g1
40013f1c: 07 10 00 94 sethi %hi(0x40025000), %g3
40013f20: 82 00 40 08 add %g1, %o0, %g1
40013f24: 86 10 e0 30 or %g3, 0x30, %g3
40013f28: 83 28 60 03 sll %g1, 3, %g1
40013f2c: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40013f30: 80 a0 60 00 cmp %g1, 0
40013f34: 02 80 00 06 be 40013f4c <rtems_io_initialize+0x50>
40013f38: 94 10 00 1a mov %i2, %o2
40013f3c: 9f c0 40 00 call %g1
40013f40: 92 10 00 19 mov %i1, %o1
40013f44: 81 c7 e0 08 ret
40013f48: 91 e8 00 08 restore %g0, %o0, %o0
40013f4c: b0 10 20 00 clr %i0
}
40013f50: 81 c7 e0 08 ret
40013f54: 81 e8 00 00 restore
40013f58 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
40013f58: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
40013f5c: 03 10 00 8a sethi %hi(0x40022800), %g1
40013f60: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 40022b98 <_IO_Number_of_drivers>
{
40013f64: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
40013f68: 80 a0 40 08 cmp %g1, %o0
40013f6c: 08 80 00 11 bleu 40013fb0 <rtems_io_open+0x58>
<== NEVER TAKEN
40013f70: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
40013f74: 83 2a 20 01 sll %o0, 1, %g1
40013f78: 82 00 40 08 add %g1, %o0, %g1
40013f7c: 85 28 60 03 sll %g1, 3, %g2
40013f80: 03 10 00 94 sethi %hi(0x40025000), %g1
40013f84: 82 10 60 30 or %g1, 0x30, %g1 ! 40025030 <_IO_Driver_address_table>
40013f88: 82 00 40 02 add %g1, %g2, %g1
40013f8c: c2 00 60 04 ld [ %g1 + 4 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40013f90: 80 a0 60 00 cmp %g1, 0
40013f94: 02 80 00 06 be 40013fac <rtems_io_open+0x54>
<== NEVER TAKEN
40013f98: 94 10 00 1a mov %i2, %o2
40013f9c: 9f c0 40 00 call %g1
40013fa0: 92 10 00 19 mov %i1, %o1
40013fa4: 81 c7 e0 08 ret
40013fa8: 91 e8 00 08 restore %g0, %o0, %o0
40013fac: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
40013fb0: 81 c7 e0 08 ret
<== NOT EXECUTED
40013fb4: 81 e8 00 00 restore
<== NOT EXECUTED
40013fb8 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
40013fb8: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
40013fbc: 03 10 00 8a sethi %hi(0x40022800), %g1
40013fc0: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 40022b98 <_IO_Number_of_drivers>
{
40013fc4: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
40013fc8: 80 a0 40 08 cmp %g1, %o0
40013fcc: 08 80 00 11 bleu 40014010 <rtems_io_read+0x58>
<== NEVER TAKEN
40013fd0: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
40013fd4: 83 2a 20 01 sll %o0, 1, %g1
40013fd8: 82 00 40 08 add %g1, %o0, %g1
40013fdc: 85 28 60 03 sll %g1, 3, %g2
40013fe0: 03 10 00 94 sethi %hi(0x40025000), %g1
40013fe4: 82 10 60 30 or %g1, 0x30, %g1 ! 40025030 <_IO_Driver_address_table>
40013fe8: 82 00 40 02 add %g1, %g2, %g1
40013fec: c2 00 60 0c ld [ %g1 + 0xc ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40013ff0: 80 a0 60 00 cmp %g1, 0
40013ff4: 02 80 00 06 be 4001400c <rtems_io_read+0x54>
<== NEVER TAKEN
40013ff8: 94 10 00 1a mov %i2, %o2
40013ffc: 9f c0 40 00 call %g1
40014000: 92 10 00 19 mov %i1, %o1
40014004: 81 c7 e0 08 ret
40014008: 91 e8 00 08 restore %g0, %o0, %o0
4001400c: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
40014010: 81 c7 e0 08 ret
<== NOT EXECUTED
40014014: 81 e8 00 00 restore
<== NOT EXECUTED
4000902c <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
)
{
4000902c: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major_limit = _IO_Number_of_drivers;
40009030: 3b 10 00 bf sethi %hi(0x4002fc00), %i5
ISR_lock_Context lock_context;
if ( rtems_interrupt_is_in_progress() )
40009034: 40 00 06 33 call 4000a900 <_ISR_Is_in_progress>
40009038: f8 07 61 10 ld [ %i5 + 0x110 ], %i4 ! 4002fd10 <_IO_Number_of_drivers>
4000903c: 80 a2 20 00 cmp %o0, 0
40009040: 12 80 00 45 bne 40009154 <rtems_io_register_driver+0x128>
<== NEVER TAKEN
40009044: 80 a6 a0 00 cmp %i2, 0
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
40009048: 02 80 00 40 be 40009148 <rtems_io_register_driver+0x11c>
<== NEVER TAKEN
4000904c: 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 )
40009050: 02 80 00 3e be 40009148 <rtems_io_register_driver+0x11c>
<== NEVER TAKEN
40009054: f8 26 80 00 st %i4, [ %i2 ]
return table->initialization_entry == NULL && table->open_entry == NULL;
40009058: c2 06 40 00 ld [ %i1 ], %g1
4000905c: 80 a0 60 00 cmp %g1, 0
40009060: 22 80 00 37 be,a 4000913c <rtems_io_register_driver+0x110>
<== ALWAYS TAKEN
40009064: 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 )
40009068: 80 a7 00 18 cmp %i4, %i0
<== NOT EXECUTED
4000906c: 08 80 00 4a bleu 40009194 <rtems_io_register_driver+0x168>
<== NEVER TAKEN
40009070: 82 10 20 0a mov 0xa, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009074: 91 d0 20 09 ta 9
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
_IO_Driver_registration_acquire( &lock_context );
if ( major == 0 ) {
40009078: 80 a6 20 00 cmp %i0, 0
4000907c: 12 80 00 39 bne 40009160 <rtems_io_register_driver+0x134>
<== NEVER TAKEN
40009080: 85 2e 20 01 sll %i0, 1, %g2
rtems_device_major_number n = _IO_Number_of_drivers;
40009084: fa 07 61 10 ld [ %i5 + 0x110 ], %i5
for ( m = 0; m < n; ++m ) {
40009088: 80 a7 60 00 cmp %i5, 0
4000908c: 02 80 00 4f be 400091c8 <rtems_io_register_driver+0x19c>
<== NEVER TAKEN
40009090: 07 10 05 43 sethi %hi(0x40150c00), %g3
40009094: 86 10 e1 30 or %g3, 0x130, %g3 ! 40150d30 <_IO_Driver_address_table>
40009098: 10 80 00 05 b 400090ac <rtems_io_register_driver+0x80>
4000909c: 84 10 00 03 mov %g3, %g2
400090a0: 80 a7 40 18 cmp %i5, %i0
400090a4: 02 80 00 3e be 4000919c <rtems_io_register_driver+0x170>
<== NEVER TAKEN
400090a8: 84 00 a0 18 add %g2, 0x18, %g2
return table->initialization_entry == NULL && table->open_entry == NULL;
400090ac: c8 00 80 00 ld [ %g2 ], %g4
400090b0: 80 a1 20 00 cmp %g4, 0
400090b4: 32 bf ff fb bne,a 400090a0 <rtems_io_register_driver+0x74>
400090b8: b0 06 20 01 inc %i0
400090bc: c8 00 a0 04 ld [ %g2 + 4 ], %g4
400090c0: 80 a1 20 00 cmp %g4, 0
400090c4: 32 bf ff f7 bne,a 400090a0 <rtems_io_register_driver+0x74>
<== NEVER TAKEN
400090c8: b0 06 20 01 inc %i0
<== NOT EXECUTED
if ( m != n )
400090cc: 80 a7 40 18 cmp %i5, %i0
400090d0: 02 80 00 34 be 400091a0 <rtems_io_register_driver+0x174>
<== NEVER TAKEN
400090d4: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
400090d8: 84 5e 20 03 smul %i0, 3, %g2
<== NOT EXECUTED
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
400090dc: c8 06 40 00 ld [ %i1 ], %g4
<== NOT EXECUTED
400090e0: 85 28 a0 03 sll %g2, 3, %g2
<== NOT EXECUTED
400090e4: c8 20 c0 02 st %g4, [ %g3 + %g2 ]
<== NOT EXECUTED
400090e8: 84 00 c0 02 add %g3, %g2, %g2
<== NOT EXECUTED
400090ec: c6 06 60 04 ld [ %i1 + 4 ], %g3
<== NOT EXECUTED
400090f0: c6 20 a0 04 st %g3, [ %g2 + 4 ]
<== NOT EXECUTED
400090f4: c6 06 60 08 ld [ %i1 + 8 ], %g3
<== NOT EXECUTED
400090f8: c6 20 a0 08 st %g3, [ %g2 + 8 ]
<== NOT EXECUTED
400090fc: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
40009100: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
40009104: c6 06 60 10 ld [ %i1 + 0x10 ], %g3
<== NOT EXECUTED
40009108: c6 20 a0 10 st %g3, [ %g2 + 0x10 ]
<== NOT EXECUTED
4000910c: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
<== NOT EXECUTED
40009110: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009114: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009118: 01 00 00 00 nop
_IO_Driver_registration_release( &lock_context );
if ( _IO_All_drivers_initialized ) {
4000911c: 03 10 05 fa sethi %hi(0x4017e800), %g1
40009120: c4 08 62 34 ldub [ %g1 + 0x234 ], %g2 ! 4017ea34 <_IO_All_drivers_initialized>
40009124: 80 a0 a0 00 cmp %g2, 0
40009128: 02 80 00 09 be 4000914c <rtems_io_register_driver+0x120>
<== NEVER TAKEN
4000912c: 82 10 20 00 clr %g1
/* Other drivers have already been initialized, we initialize
* the driver directly.
*/
return rtems_io_initialize( major, 0, NULL );
40009130: b4 10 20 00 clr %i2
40009134: 40 00 3e 57 call 40018a90 <rtems_io_initialize>
40009138: 93 e8 20 00 restore %g0, 0, %o1
return table->initialization_entry == NULL && table->open_entry == NULL;
4000913c: 80 a0 60 00 cmp %g1, 0
40009140: 12 bf ff cb bne 4000906c <rtems_io_register_driver+0x40>
<== ALWAYS TAKEN
40009144: 80 a7 00 18 cmp %i4, %i0
return RTEMS_INVALID_ADDRESS;
40009148: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
/* The driver will be initialized together with all other drivers
* in a later stage by _IO_Initialize_all_drivers().
*/
return RTEMS_SUCCESSFUL;
}
}
4000914c: 81 c7 e0 08 ret
<== NOT EXECUTED
40009150: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
return RTEMS_CALLED_FROM_ISR;
40009154: 82 10 20 12 mov 0x12, %g1
<== NOT EXECUTED
}
40009158: 81 c7 e0 08 ret
<== NOT EXECUTED
4000915c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
40009160: 07 10 05 43 sethi %hi(0x40150c00), %g3
<== NOT EXECUTED
40009164: 84 00 80 18 add %g2, %i0, %g2
<== NOT EXECUTED
40009168: 86 10 e1 30 or %g3, 0x130, %g3
<== NOT EXECUTED
4000916c: 89 28 a0 03 sll %g2, 3, %g4
<== NOT EXECUTED
return table->initialization_entry == NULL && table->open_entry == NULL;
40009170: fa 00 c0 04 ld [ %g3 + %g4 ], %i5
<== NOT EXECUTED
40009174: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
40009178: 02 80 00 0e be 400091b0 <rtems_io_register_driver+0x184>
<== NOT EXECUTED
4000917c: 88 00 c0 04 add %g3, %g4, %g4
<== NOT EXECUTED
40009180: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009184: 01 00 00 00 nop
<== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
40009188: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
}
4000918c: 81 c7 e0 08 ret
<== NOT EXECUTED
40009190: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
40009194: 81 c7 e0 08 ret
<== NOT EXECUTED
40009198: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
*major = m;
4000919c: fa 26 80 00 st %i5, [ %i2 ]
<== NOT EXECUTED
400091a0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400091a4: 01 00 00 00 nop
<== NOT EXECUTED
return sc;
400091a8: 10 bf ff e9 b 4000914c <rtems_io_register_driver+0x120>
<== NOT EXECUTED
400091ac: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
return table->initialization_entry == NULL && table->open_entry == NULL;
400091b0: c8 01 20 04 ld [ %g4 + 4 ], %g4
<== NOT EXECUTED
400091b4: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
400091b8: 12 bf ff f2 bne 40009180 <rtems_io_register_driver+0x154>
<== NOT EXECUTED
400091bc: 01 00 00 00 nop
<== NOT EXECUTED
*registered_major = major;
400091c0: 10 bf ff c7 b 400090dc <rtems_io_register_driver+0xb0>
<== NOT EXECUTED
400091c4: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
*major = m;
400091c8: 10 bf ff f6 b 400091a0 <rtems_io_register_driver+0x174>
<== NOT EXECUTED
400091cc: c0 26 80 00 clr [ %i2 ]
<== NOT EXECUTED
40008ebc <rtems_io_unregister_driver>:
#include <string.h>
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
40008ebc: 9d e3 bf a0 save %sp, -96, %sp
if ( rtems_interrupt_is_in_progress() )
40008ec0: 40 00 06 23 call 4000a74c <_ISR_Is_in_progress>
40008ec4: 01 00 00 00 nop
40008ec8: 80 a2 20 00 cmp %o0, 0
40008ecc: 12 80 00 17 bne 40008f28 <rtems_io_unregister_driver+0x6c>
<== NEVER TAKEN
40008ed0: 82 10 20 12 mov 0x12, %g1
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
40008ed4: 05 10 00 85 sethi %hi(0x40021400), %g2
40008ed8: c4 00 a3 74 ld [ %g2 + 0x374 ], %g2 ! 40021774 <_IO_Number_of_drivers>
40008edc: 80 a0 80 18 cmp %g2, %i0
40008ee0: 08 80 00 12 bleu 40008f28 <rtems_io_unregister_driver+0x6c>
<== NEVER TAKEN
40008ee4: 82 10 20 0d mov 0xd, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008ee8: 91 d0 20 09 ta 9
<== NOT EXECUTED
ISR_lock_Context lock_context;
_IO_Driver_registration_acquire( &lock_context );
memset(
&_IO_Driver_address_table[major],
40008eec: 07 10 00 99 sethi %hi(0x40026400), %g3
<== NOT EXECUTED
40008ef0: 85 2e 20 01 sll %i0, 1, %g2
<== NOT EXECUTED
40008ef4: 86 10 e0 30 or %g3, 0x30, %g3
<== NOT EXECUTED
40008ef8: b0 00 80 18 add %g2, %i0, %i0
<== NOT EXECUTED
40008efc: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
memset(
40008f00: c0 26 00 03 clr [ %i0 + %g3 ]
<== NOT EXECUTED
&_IO_Driver_address_table[major],
40008f04: b0 06 00 03 add %i0, %g3, %i0
<== NOT EXECUTED
memset(
40008f08: c0 26 20 04 clr [ %i0 + 4 ]
<== NOT EXECUTED
40008f0c: c0 26 20 08 clr [ %i0 + 8 ]
<== NOT EXECUTED
40008f10: c0 26 20 0c clr [ %i0 + 0xc ]
<== NOT EXECUTED
40008f14: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
40008f18: c0 26 20 14 clr [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008f1c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008f20: 01 00 00 00 nop
0,
sizeof( rtems_driver_address_table )
);
_IO_Driver_registration_release( &lock_context );
return RTEMS_SUCCESSFUL;
40008f24: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
return RTEMS_UNSATISFIED;
}
40008f28: 81 c7 e0 08 ret
40008f2c: 91 e8 00 01 restore %g0, %g1, %o0
40014018 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
40014018: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4001401c: 03 10 00 8a sethi %hi(0x40022800), %g1
40014020: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 40022b98 <_IO_Number_of_drivers>
{
40014024: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
40014028: 80 a0 40 08 cmp %g1, %o0
4001402c: 08 80 00 11 bleu 40014070 <rtems_io_write+0x58>
<== NEVER TAKEN
40014030: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
40014034: 83 2a 20 01 sll %o0, 1, %g1
40014038: 82 00 40 08 add %g1, %o0, %g1
4001403c: 85 28 60 03 sll %g1, 3, %g2
40014040: 03 10 00 94 sethi %hi(0x40025000), %g1
40014044: 82 10 60 30 or %g1, 0x30, %g1 ! 40025030 <_IO_Driver_address_table>
40014048: 82 00 40 02 add %g1, %g2, %g1
4001404c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40014050: 80 a0 60 00 cmp %g1, 0
40014054: 02 80 00 06 be 4001406c <rtems_io_write+0x54>
<== NEVER TAKEN
40014058: 94 10 00 1a mov %i2, %o2
4001405c: 9f c0 40 00 call %g1
40014060: 92 10 00 19 mov %i1, %o1
40014064: 81 c7 e0 08 ret
40014068: 91 e8 00 08 restore %g0, %o0, %o0
4001406c: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
40014070: 81 c7 e0 08 ret
<== NOT EXECUTED
40014074: 81 e8 00 00 restore
<== NOT EXECUTED
40013e28 <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
40013e28: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
40013e2c: 90 10 20 05 mov 5, %o0
40013e30: 7f ff d9 c9 call 4000a554 <_Terminate>
40013e34: 92 10 00 18 mov %i0, %o1
40013e38: 01 00 00 00 nop
<== NOT EXECUTED
40009a70 <rtems_timecounter_simple_install>:
rtems_timecounter_simple *tc,
uint32_t frequency_in_hz,
uint32_t counter_ticks_per_clock_tick,
timecounter_get_t *get_timecount
)
{
40009a70: 9d e3 bf a0 save %sp, -96, %sp
uint32_t mask;
uint64_t scaler;
int i;
for ( i = 0; i < 32; ++i ) {
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40009a74: 80 a6 a0 01 cmp %i2, 1
40009a78: 08 80 00 28 bleu 40009b18 <rtems_timecounter_simple_install+0xa8>
<== NEVER TAKEN
40009a7c: b8 10 00 18 mov %i0, %i4
40009a80: 82 10 20 1f mov 0x1f, %g1
break;
}
power_of_two *= 2;
40009a84: 10 80 00 05 b 40009a98 <rtems_timecounter_simple_install+0x28>
40009a88: 90 10 20 02 mov 2, %o0
for ( i = 0; i < 32; ++i ) {
40009a8c: 82 80 7f ff addcc %g1, -1, %g1
40009a90: 02 80 00 1c be 40009b00 <rtems_timecounter_simple_install+0x90>
<== NEVER TAKEN
40009a94: 90 10 00 02 mov %g2, %o0
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40009a98: 80 a6 80 08 cmp %i2, %o0
40009a9c: 18 bf ff fc bgu 40009a8c <rtems_timecounter_simple_install+0x1c>
40009aa0: 85 2a 20 01 sll %o0, 1, %g2
40009aa4: 21 20 00 00 sethi %hi(0x80000000), %l0
40009aa8: ba 00 bf ff add %g2, -1, %i5
40009aac: a0 2a 00 10 andn %o0, %l0, %l0
}
mask = ( 2 * power_of_two ) - 1;
scaler = ( (uint64_t) power_of_two << 32 ) / counter_ticks_per_clock_tick;
40009ab0: 94 10 20 00 clr %o2
40009ab4: 96 10 00 1a mov %i2, %o3
40009ab8: 40 00 61 6d call 4002206c <__udivdi3>
40009abc: 92 10 20 00 clr %o1
tc->scaler = scaler;
tc->real_interval = counter_ticks_per_clock_tick;
tc->binary_interval = ( mask + 1 ) / 2;
tc->tc.tc_get_timecount = get_timecount;
tc->tc.tc_counter_mask = mask;
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40009ac0: 82 5e 40 08 smul %i1, %o0, %g1
40009ac4: 86 56 40 09 umul %i1, %o1, %g3
40009ac8: 85 40 00 00 rd %y, %g2
tc->scaler = scaler;
40009acc: d0 27 20 30 st %o0, [ %i4 + 0x30 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40009ad0: 84 00 40 02 add %g1, %g2, %g2
tc->scaler = scaler;
40009ad4: d2 27 20 34 st %o1, [ %i4 + 0x34 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40009ad8: 82 10 20 64 mov 0x64, %g1
tc->real_interval = counter_ticks_per_clock_tick;
40009adc: f4 27 20 38 st %i2, [ %i4 + 0x38 ]
tc->binary_interval = ( mask + 1 ) / 2;
40009ae0: e0 27 20 3c st %l0, [ %i4 + 0x3c ]
tc->tc.tc_get_timecount = get_timecount;
40009ae4: f6 27 00 00 st %i3, [ %i4 ]
tc->tc.tc_counter_mask = mask;
40009ae8: fa 27 20 08 st %i5, [ %i4 + 8 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40009aec: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
40009af0: c0 27 20 10 clr [ %i4 + 0x10 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40009af4: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
_Timecounter_Install( &tc->tc );
40009af8: 40 00 07 3c call 4000b7e8 <_Timecounter_Install>
40009afc: 91 e8 00 1c restore %g0, %i4, %o0
40009b00: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
40009b04: 21 1f ff ff sethi %hi(0x7ffffc00), %l0
<== NOT EXECUTED
40009b08: ba 00 bf ff add %g2, -1, %i5
<== NOT EXECUTED
40009b0c: a0 14 23 ff or %l0, 0x3ff, %l0
<== NOT EXECUTED
40009b10: 10 bf ff e8 b 40009ab0 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40009b14: a0 0a 00 10 and %o0, %l0, %l0
<== NOT EXECUTED
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40009b18: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
40009b1c: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
40009b20: 10 bf ff e4 b 40009ab0 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40009b24: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED