RTEMS-5
Annotated Report
Fri Aug 10 12:46:26 2018
40006f58 <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
40006f58: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
40006f5c: 03 10 00 7d sethi %hi(0x4001f400), %g1
40006f60: 84 10 20 01 mov 1, %g2
40006f64: c4 28 61 2c stb %g2, [ %g1 + 0x12c ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40006f68: 03 10 00 63 sethi %hi(0x40018c00), %g1
40006f6c: f8 00 61 c0 ld [ %g1 + 0x1c0 ], %i4 ! 40018dc0 <_IO_Number_of_drivers>
40006f70: 80 a7 20 00 cmp %i4, 0
40006f74: 02 80 00 0a be 40006f9c <_IO_Initialize_all_drivers+0x44>
<== NEVER TAKEN
40006f78: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
40006f7c: 90 10 00 1d mov %i5, %o0
40006f80: 94 10 20 00 clr %o2
40006f84: 40 00 1a f4 call 4000db54 <rtems_io_initialize>
40006f88: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40006f8c: ba 07 60 01 inc %i5
40006f90: 80 a7 40 1c cmp %i5, %i4
40006f94: 12 bf ff fb bne 40006f80 <_IO_Initialize_all_drivers+0x28>
<== NEVER TAKEN
40006f98: 90 10 00 1d mov %i5, %o0
}
40006f9c: 81 c7 e0 08 ret
40006fa0: 81 e8 00 00 restore
400198c0 <_Objects_Information_table>:
400198c0: 00 00 00 00 40 01 c7 50 40 01 c7 24 40 01 c6 f0 ....@..P@..$@...
400198d0: 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 00 00 00 00 _Allocator......
400198e0: 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 00 00 00 00 (fmt null)......
400198f0: 28 6e 75 6c 6c 29 00 (null).
40006f38 <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
40006f38: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
40006f3c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
40006f40: 40 00 02 46 call 40007858 <_Terminate>
<== NOT EXECUTED
40006f44: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40006f48: 01 00 00 00 nop
<== NOT EXECUTED
40006f4c <rtems_get_version_string>:
#include <rtems.h>
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
40006f4c: 11 10 00 68 sethi %hi(0x4001a000), %o0
<== NOT EXECUTED
}
40006f50: 81 c3 e0 08 retl
<== NOT EXECUTED
40006f54: 90 12 22 78 or %o0, 0x278, %o0 ! 4001a278 <_RTEMS_version>
<== NOT EXECUTED
40006eec <rtems_initialize_executive>:
RTEMS_SYSINIT_DEVICE_DRIVERS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
40006eec: 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;
40006ef0: 3b 10 00 68 sethi %hi(0x4001a000), %i5
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40006ef4: 39 10 00 68 sethi %hi(0x4001a000), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
40006ef8: ba 17 62 d0 or %i5, 0x2d0, %i5
40006efc: b8 17 23 14 or %i4, 0x314, %i4
40006f00: 80 a7 40 1c cmp %i5, %i4
40006f04: 02 80 00 09 be 40006f28 <rtems_initialize_executive+0x3c>
<== NEVER TAKEN
40006f08: 03 10 00 7d sethi %hi(0x4001f400), %g1
( *item->handler )();
40006f0c: c2 07 40 00 ld [ %i5 ], %g1
40006f10: 9f c0 40 00 call %g1
40006f14: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40006f18: 80 a7 40 1c cmp %i5, %i4
40006f1c: 32 bf ff fd bne,a 40006f10 <rtems_initialize_executive+0x24>
40006f20: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
40006f24: 03 10 00 7d sethi %hi(0x4001f400), %g1
40006f28: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
40006f2c: 40 00 12 e9 call 4000bad0 <_Thread_Start_multitasking>
40006f30: c4 20 61 38 st %g2, [ %g1 + 0x138 ]
40006f34: 01 00 00 00 nop
<== NOT EXECUTED
4000da94 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000da94: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000da98: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4000da9c: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 40018dc0 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000daa0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000daa4: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000daa8: 08 80 00 11 bleu 4000daec <rtems_io_close+0x58>
<== NOT EXECUTED
4000daac: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
4000dab0: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000dab4: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000dab8: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000dabc: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
4000dac0: 82 10 63 70 or %g1, 0x370, %g1 ! 4001b370 <_IO_Driver_address_table>
<== NOT EXECUTED
4000dac4: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000dac8: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000dacc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dad0: 02 80 00 06 be 4000dae8 <rtems_io_close+0x54>
<== NOT EXECUTED
4000dad4: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000dad8: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dadc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000dae0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dae4: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000dae8: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000daec: 81 c7 e0 08 ret
<== NOT EXECUTED
4000daf0: 81 e8 00 00 restore
<== NOT EXECUTED
4000daf4 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000daf4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000daf8: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4000dafc: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 40018dc0 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000db00: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000db04: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000db08: 08 80 00 11 bleu 4000db4c <rtems_io_control+0x58>
<== NOT EXECUTED
4000db0c: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
4000db10: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000db14: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000db18: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000db1c: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
4000db20: 82 10 63 70 or %g1, 0x370, %g1 ! 4001b370 <_IO_Driver_address_table>
<== NOT EXECUTED
4000db24: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000db28: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000db2c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000db30: 02 80 00 06 be 4000db48 <rtems_io_control+0x54>
<== NOT EXECUTED
4000db34: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000db38: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000db3c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000db40: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db44: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000db48: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000db4c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db50: 81 e8 00 00 restore
<== NOT EXECUTED
4000db54 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000db54: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000db58: 03 10 00 63 sethi %hi(0x40018c00), %g1
4000db5c: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 40018dc0 <_IO_Number_of_drivers>
{
4000db60: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000db64: 80 a0 40 08 cmp %g1, %o0
4000db68: 08 80 00 10 bleu 4000dba8 <rtems_io_initialize+0x54>
<== NEVER TAKEN
4000db6c: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
4000db70: 83 2a 20 01 sll %o0, 1, %g1
4000db74: 07 10 00 6c sethi %hi(0x4001b000), %g3
4000db78: 82 00 40 08 add %g1, %o0, %g1
4000db7c: 86 10 e3 70 or %g3, 0x370, %g3
4000db80: 83 28 60 03 sll %g1, 3, %g1
4000db84: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000db88: 80 a0 60 00 cmp %g1, 0
4000db8c: 02 80 00 06 be 4000dba4 <rtems_io_initialize+0x50>
<== NEVER TAKEN
4000db90: 94 10 00 1a mov %i2, %o2
4000db94: 9f c0 40 00 call %g1
4000db98: 92 10 00 19 mov %i1, %o1
4000db9c: 81 c7 e0 08 ret
4000dba0: 91 e8 00 08 restore %g0, %o0, %o0
4000dba4: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000dba8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dbac: 81 e8 00 00 restore
<== NOT EXECUTED
4000dbb0 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000dbb0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000dbb4: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4000dbb8: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 40018dc0 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000dbbc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000dbc0: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000dbc4: 08 80 00 11 bleu 4000dc08 <rtems_io_open+0x58>
<== NOT EXECUTED
4000dbc8: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
4000dbcc: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000dbd0: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000dbd4: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000dbd8: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
4000dbdc: 82 10 63 70 or %g1, 0x370, %g1 ! 4001b370 <_IO_Driver_address_table>
<== NOT EXECUTED
4000dbe0: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000dbe4: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000dbe8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dbec: 02 80 00 06 be 4000dc04 <rtems_io_open+0x54>
<== NOT EXECUTED
4000dbf0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000dbf4: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dbf8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000dbfc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc00: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000dc04: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000dc08: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc0c: 81 e8 00 00 restore
<== NOT EXECUTED
4000dc10 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000dc10: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000dc14: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4000dc18: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 40018dc0 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000dc1c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000dc20: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000dc24: 08 80 00 11 bleu 4000dc68 <rtems_io_read+0x58>
<== NOT EXECUTED
4000dc28: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
4000dc2c: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000dc30: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000dc34: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000dc38: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
4000dc3c: 82 10 63 70 or %g1, 0x370, %g1 ! 4001b370 <_IO_Driver_address_table>
<== NOT EXECUTED
4000dc40: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000dc44: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000dc48: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dc4c: 02 80 00 06 be 4000dc64 <rtems_io_read+0x54>
<== NOT EXECUTED
4000dc50: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000dc54: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dc58: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000dc5c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc60: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000dc64: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000dc68: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc6c: 81 e8 00 00 restore
<== NOT EXECUTED
4000dc70 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000dc70: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000dc74: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4000dc78: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 40018dc0 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000dc7c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000dc80: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000dc84: 08 80 00 11 bleu 4000dcc8 <rtems_io_write+0x58>
<== NOT EXECUTED
4000dc88: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
4000dc8c: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000dc90: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000dc94: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000dc98: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
4000dc9c: 82 10 63 70 or %g1, 0x370, %g1 ! 4001b370 <_IO_Driver_address_table>
<== NOT EXECUTED
4000dca0: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000dca4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000dca8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dcac: 02 80 00 06 be 4000dcc4 <rtems_io_write+0x54>
<== NOT EXECUTED
4000dcb0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000dcb4: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dcb8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000dcbc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dcc0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000dcc4: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000dcc8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dccc: 81 e8 00 00 restore
<== NOT EXECUTED
4000da80 <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
4000da80: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
4000da84: 90 10 20 05 mov 5, %o0
4000da88: 7f ff e7 74 call 40007858 <_Terminate>
4000da8c: 92 10 00 18 mov %i0, %o1
4000da90: 01 00 00 00 nop
<== NOT EXECUTED
40006fa4 <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
)
{
40006fa4: 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 ) {
40006fa8: 80 a6 a0 01 cmp %i2, 1
40006fac: 08 80 00 28 bleu 4000704c <rtems_timecounter_simple_install+0xa8>
<== NEVER TAKEN
40006fb0: b8 10 00 18 mov %i0, %i4
40006fb4: 82 10 20 1f mov 0x1f, %g1
break;
}
power_of_two *= 2;
40006fb8: 10 80 00 05 b 40006fcc <rtems_timecounter_simple_install+0x28>
40006fbc: 90 10 20 02 mov 2, %o0
for ( i = 0; i < 32; ++i ) {
40006fc0: 82 80 7f ff addcc %g1, -1, %g1
40006fc4: 02 80 00 1c be 40007034 <rtems_timecounter_simple_install+0x90>
<== NEVER TAKEN
40006fc8: 90 10 00 02 mov %g2, %o0
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40006fcc: 80 a6 80 08 cmp %i2, %o0
40006fd0: 18 bf ff fc bgu 40006fc0 <rtems_timecounter_simple_install+0x1c>
40006fd4: 85 2a 20 01 sll %o0, 1, %g2
40006fd8: 21 20 00 00 sethi %hi(0x80000000), %l0
40006fdc: ba 00 bf ff add %g2, -1, %i5
40006fe0: 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;
40006fe4: 94 10 20 00 clr %o2
40006fe8: 96 10 00 1a mov %i2, %o3
40006fec: 40 00 43 c9 call 40017f10 <__udivdi3>
40006ff0: 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 );
40006ff4: 82 5e 40 08 smul %i1, %o0, %g1
40006ff8: 86 56 40 09 umul %i1, %o1, %g3
40006ffc: 85 40 00 00 rd %y, %g2
tc->scaler = scaler;
40007000: d0 27 20 30 st %o0, [ %i4 + 0x30 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40007004: 84 00 40 02 add %g1, %g2, %g2
tc->scaler = scaler;
40007008: d2 27 20 34 st %o1, [ %i4 + 0x34 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
4000700c: 82 10 20 64 mov 0x64, %g1
tc->real_interval = counter_ticks_per_clock_tick;
40007010: f4 27 20 38 st %i2, [ %i4 + 0x38 ]
tc->binary_interval = ( mask + 1 ) / 2;
40007014: e0 27 20 3c st %l0, [ %i4 + 0x3c ]
tc->tc.tc_get_timecount = get_timecount;
40007018: f6 27 00 00 st %i3, [ %i4 ]
tc->tc.tc_counter_mask = mask;
4000701c: fa 27 20 08 st %i5, [ %i4 + 8 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40007020: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
40007024: c0 27 20 10 clr [ %i4 + 0x10 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40007028: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
_Timecounter_Install( &tc->tc );
4000702c: 40 00 06 b0 call 40008aec <_Timecounter_Install>
40007030: 91 e8 00 1c restore %g0, %i4, %o0
40007034: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
40007038: 21 1f ff ff sethi %hi(0x7ffffc00), %l0
<== NOT EXECUTED
4000703c: ba 00 bf ff add %g2, -1, %i5
<== NOT EXECUTED
40007040: a0 14 23 ff or %l0, 0x3ff, %l0
<== NOT EXECUTED
40007044: 10 bf ff e8 b 40006fe4 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40007048: a0 0a 00 10 and %o0, %l0, %l0
<== NOT EXECUTED
if ( power_of_two >= counter_ticks_per_clock_tick ) {
4000704c: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
40007050: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
40007054: 10 bf ff e4 b 40006fe4 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40007058: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED