RTEMS-5
Annotated Report
Fri Aug 10 12:56:21 2018
40007800 <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
40007800: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
40007804: 03 10 00 4f sethi %hi(0x40013c00), %g1
40007808: 84 10 20 01 mov 1, %g2
4000780c: c4 28 62 30 stb %g2, [ %g1 + 0x230 ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40007810: 03 10 00 42 sethi %hi(0x40010800), %g1
40007814: f8 00 60 78 ld [ %g1 + 0x78 ], %i4 ! 40010878 <_IO_Number_of_drivers>
40007818: 80 a7 20 00 cmp %i4, 0
4000781c: 02 80 00 0a be 40007844 <_IO_Initialize_all_drivers+0x44>
<== NEVER TAKEN
40007820: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
40007824: 90 10 00 1d mov %i5, %o0
40007828: 94 10 20 00 clr %o2
4000782c: 40 00 1c 79 call 4000ea10 <rtems_io_initialize>
40007830: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40007834: ba 07 60 01 inc %i5
40007838: 80 a7 40 1c cmp %i5, %i4
4000783c: 12 bf ff fb bne 40007828 <_IO_Initialize_all_drivers+0x28>
<== NEVER TAKEN
40007840: 90 10 00 1d mov %i5, %o0
}
40007844: 81 c7 e0 08 ret
40007848: 81 e8 00 00 restore
4001108c <_Objects_Information_table>:
4001108c: 00 00 00 00 40 01 37 d8 40 01 37 ac 40 01 37 78 ....@.7.@.7.@.7x
4001109c: 00 00 00 00 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 ...._Allocator..
400110ac: 00 00 00 00 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 ....(fmt null)..
400110bc: 00 00 00 00 28 6e 75 6c 6c 29 00 ....(null).
400077e0 <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
400077e0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
400077e4: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
400077e8: 40 00 02 3f call 400080e4 <_Terminate>
<== NOT EXECUTED
400077ec: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400077f0: 01 00 00 00 nop
<== NOT EXECUTED
400077f4 <rtems_get_version_string>:
#include <rtems.h>
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
400077f4: 11 10 00 45 sethi %hi(0x40011400), %o0
<== NOT EXECUTED
}
400077f8: 81 c3 e0 08 retl
<== NOT EXECUTED
400077fc: 90 12 21 68 or %o0, 0x168, %o0 ! 40011568 <_RTEMS_version>
<== NOT EXECUTED
40007794 <rtems_initialize_executive>:
RTEMS_SYSINIT_DEVICE_DRIVERS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
40007794: 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;
40007798: 3b 10 00 45 sethi %hi(0x40011400), %i5
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
4000779c: 39 10 00 45 sethi %hi(0x40011400), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
400077a0: ba 17 61 c0 or %i5, 0x1c0, %i5
400077a4: b8 17 22 08 or %i4, 0x208, %i4
400077a8: 80 a7 40 1c cmp %i5, %i4
400077ac: 02 80 00 09 be 400077d0 <rtems_initialize_executive+0x3c>
<== NEVER TAKEN
400077b0: 03 10 00 4f sethi %hi(0x40013c00), %g1
( *item->handler )();
400077b4: c2 07 40 00 ld [ %i5 ], %g1
400077b8: 9f c0 40 00 call %g1
400077bc: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
400077c0: 80 a7 40 1c cmp %i5, %i4
400077c4: 32 bf ff fd bne,a 400077b8 <rtems_initialize_executive+0x24>
400077c8: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
400077cc: 03 10 00 4f sethi %hi(0x40013c00), %g1
400077d0: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
400077d4: 40 00 14 e7 call 4000cb70 <_Thread_Start_multitasking>
400077d8: c4 20 62 3c st %g2, [ %g1 + 0x23c ]
400077dc: 01 00 00 00 nop
<== NOT EXECUTED
4000e950 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e950: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e954: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000e958: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 40010878 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000e95c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000e960: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000e964: 08 80 00 11 bleu 4000e9a8 <rtems_io_close+0x58>
<== NOT EXECUTED
4000e968: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
4000e96c: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e970: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e974: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e978: 03 10 00 4a sethi %hi(0x40012800), %g1
<== NOT EXECUTED
4000e97c: 82 10 62 c0 or %g1, 0x2c0, %g1 ! 40012ac0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000e980: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e984: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e988: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e98c: 02 80 00 06 be 4000e9a4 <rtems_io_close+0x54>
<== NOT EXECUTED
4000e990: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e994: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e998: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e99c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e9a0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e9a4: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e9a8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e9ac: 81 e8 00 00 restore
<== NOT EXECUTED
4000e9b0 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e9b0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e9b4: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000e9b8: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 40010878 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000e9bc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000e9c0: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000e9c4: 08 80 00 11 bleu 4000ea08 <rtems_io_control+0x58>
<== NOT EXECUTED
4000e9c8: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
4000e9cc: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e9d0: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e9d4: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e9d8: 03 10 00 4a sethi %hi(0x40012800), %g1
<== NOT EXECUTED
4000e9dc: 82 10 62 c0 or %g1, 0x2c0, %g1 ! 40012ac0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000e9e0: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e9e4: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e9e8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e9ec: 02 80 00 06 be 4000ea04 <rtems_io_control+0x54>
<== NOT EXECUTED
4000e9f0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e9f4: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e9f8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e9fc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ea00: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000ea04: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000ea08: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ea0c: 81 e8 00 00 restore
<== NOT EXECUTED
4000ea10 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000ea10: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000ea14: 03 10 00 42 sethi %hi(0x40010800), %g1
4000ea18: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 40010878 <_IO_Number_of_drivers>
{
4000ea1c: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000ea20: 80 a0 40 08 cmp %g1, %o0
4000ea24: 08 80 00 10 bleu 4000ea64 <rtems_io_initialize+0x54>
<== NEVER TAKEN
4000ea28: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
4000ea2c: 83 2a 20 01 sll %o0, 1, %g1
4000ea30: 07 10 00 4a sethi %hi(0x40012800), %g3
4000ea34: 82 00 40 08 add %g1, %o0, %g1
4000ea38: 86 10 e2 c0 or %g3, 0x2c0, %g3
4000ea3c: 83 28 60 03 sll %g1, 3, %g1
4000ea40: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000ea44: 80 a0 60 00 cmp %g1, 0
4000ea48: 02 80 00 06 be 4000ea60 <rtems_io_initialize+0x50>
4000ea4c: 94 10 00 1a mov %i2, %o2
4000ea50: 9f c0 40 00 call %g1
4000ea54: 92 10 00 19 mov %i1, %o1
4000ea58: 81 c7 e0 08 ret
4000ea5c: 91 e8 00 08 restore %g0, %o0, %o0
4000ea60: b0 10 20 00 clr %i0
}
4000ea64: 81 c7 e0 08 ret
4000ea68: 81 e8 00 00 restore
4000ea6c <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000ea6c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000ea70: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000ea74: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 40010878 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000ea78: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000ea7c: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000ea80: 08 80 00 11 bleu 4000eac4 <rtems_io_open+0x58>
<== NOT EXECUTED
4000ea84: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
4000ea88: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000ea8c: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000ea90: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000ea94: 03 10 00 4a sethi %hi(0x40012800), %g1
<== NOT EXECUTED
4000ea98: 82 10 62 c0 or %g1, 0x2c0, %g1 ! 40012ac0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000ea9c: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000eaa0: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000eaa4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000eaa8: 02 80 00 06 be 4000eac0 <rtems_io_open+0x54>
<== NOT EXECUTED
4000eaac: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000eab0: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000eab4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000eab8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eabc: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000eac0: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000eac4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eac8: 81 e8 00 00 restore
<== NOT EXECUTED
4000eacc <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000eacc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000ead0: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000ead4: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 40010878 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000ead8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000eadc: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000eae0: 08 80 00 11 bleu 4000eb24 <rtems_io_read+0x58>
<== NOT EXECUTED
4000eae4: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
4000eae8: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000eaec: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000eaf0: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000eaf4: 03 10 00 4a sethi %hi(0x40012800), %g1
<== NOT EXECUTED
4000eaf8: 82 10 62 c0 or %g1, 0x2c0, %g1 ! 40012ac0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000eafc: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000eb00: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000eb04: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000eb08: 02 80 00 06 be 4000eb20 <rtems_io_read+0x54>
<== NOT EXECUTED
4000eb0c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000eb10: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000eb14: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000eb18: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eb1c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000eb20: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000eb24: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eb28: 81 e8 00 00 restore
<== NOT EXECUTED
4000eb2c <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000eb2c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000eb30: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000eb34: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 40010878 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000eb38: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000eb3c: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000eb40: 08 80 00 11 bleu 4000eb84 <rtems_io_write+0x58>
<== NOT EXECUTED
4000eb44: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
4000eb48: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000eb4c: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000eb50: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000eb54: 03 10 00 4a sethi %hi(0x40012800), %g1
<== NOT EXECUTED
4000eb58: 82 10 62 c0 or %g1, 0x2c0, %g1 ! 40012ac0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000eb5c: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000eb60: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000eb64: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000eb68: 02 80 00 06 be 4000eb80 <rtems_io_write+0x54>
<== NOT EXECUTED
4000eb6c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000eb70: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000eb74: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000eb78: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eb7c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000eb80: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000eb84: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eb88: 81 e8 00 00 restore
<== NOT EXECUTED
4000e93c <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
4000e93c: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
4000e940: 90 10 20 05 mov 5, %o0
4000e944: 7f ff e5 e8 call 400080e4 <_Terminate>
4000e948: 92 10 00 18 mov %i0, %o1
4000e94c: 01 00 00 00 nop
<== NOT EXECUTED
40007bd8 <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
)
{
40007bd8: 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 ) {
40007bdc: 80 a6 a0 01 cmp %i2, 1
40007be0: 08 80 00 28 bleu 40007c80 <rtems_timecounter_simple_install+0xa8>
<== NEVER TAKEN
40007be4: b8 10 00 18 mov %i0, %i4
40007be8: 82 10 20 1f mov 0x1f, %g1
break;
}
power_of_two *= 2;
40007bec: 10 80 00 05 b 40007c00 <rtems_timecounter_simple_install+0x28>
40007bf0: 90 10 20 02 mov 2, %o0
for ( i = 0; i < 32; ++i ) {
40007bf4: 82 80 7f ff addcc %g1, -1, %g1
40007bf8: 02 80 00 1c be 40007c68 <rtems_timecounter_simple_install+0x90>
<== NEVER TAKEN
40007bfc: 90 10 00 02 mov %g2, %o0
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40007c00: 80 a6 80 08 cmp %i2, %o0
40007c04: 18 bf ff fc bgu 40007bf4 <rtems_timecounter_simple_install+0x1c>
40007c08: 85 2a 20 01 sll %o0, 1, %g2
40007c0c: 21 20 00 00 sethi %hi(0x80000000), %l0
40007c10: ba 00 bf ff add %g2, -1, %i5
40007c14: 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;
40007c18: 94 10 20 00 clr %o2
40007c1c: 96 10 00 1a mov %i2, %o3
40007c20: 40 00 23 53 call 4001096c <__udivdi3>
40007c24: 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 );
40007c28: 82 5e 40 08 smul %i1, %o0, %g1
40007c2c: 86 56 40 09 umul %i1, %o1, %g3
40007c30: 85 40 00 00 rd %y, %g2
tc->scaler = scaler;
40007c34: d0 27 20 30 st %o0, [ %i4 + 0x30 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40007c38: 84 00 40 02 add %g1, %g2, %g2
tc->scaler = scaler;
40007c3c: d2 27 20 34 st %o1, [ %i4 + 0x34 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40007c40: 82 10 20 64 mov 0x64, %g1
tc->real_interval = counter_ticks_per_clock_tick;
40007c44: f4 27 20 38 st %i2, [ %i4 + 0x38 ]
tc->binary_interval = ( mask + 1 ) / 2;
40007c48: e0 27 20 3c st %l0, [ %i4 + 0x3c ]
tc->tc.tc_get_timecount = get_timecount;
40007c4c: f6 27 00 00 st %i3, [ %i4 ]
tc->tc.tc_counter_mask = mask;
40007c50: fa 27 20 08 st %i5, [ %i4 + 8 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40007c54: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
40007c58: c0 27 20 10 clr [ %i4 + 0x10 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40007c5c: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
_Timecounter_Install( &tc->tc );
40007c60: 40 00 06 d7 call 400097bc <_Timecounter_Install>
40007c64: 91 e8 00 1c restore %g0, %i4, %o0
40007c68: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
40007c6c: 21 1f ff ff sethi %hi(0x7ffffc00), %l0
<== NOT EXECUTED
40007c70: ba 00 bf ff add %g2, -1, %i5
<== NOT EXECUTED
40007c74: a0 14 23 ff or %l0, 0x3ff, %l0
<== NOT EXECUTED
40007c78: 10 bf ff e8 b 40007c18 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40007c7c: a0 0a 00 10 and %o0, %l0, %l0
<== NOT EXECUTED
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40007c80: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
40007c84: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
40007c88: 10 bf ff e4 b 40007c18 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40007c8c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED