400070cc <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
400070cc: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
400070d0: 03 10 00 4e sethi %hi(0x40013800), %g1
400070d4: 84 10 20 01 mov 1, %g2
400070d8: c4 28 61 a4 stb %g2, [ %g1 + 0x1a4 ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
400070dc: 03 10 00 40 sethi %hi(0x40010000), %g1
400070e0: f8 00 61 00 ld [ %g1 + 0x100 ], %i4 ! 40010100 <_IO_Number_of_drivers>
400070e4: 80 a7 20 00 cmp %i4, 0
400070e8: 02 80 00 0a be 40007110 <_IO_Initialize_all_drivers+0x44> <== NEVER TAKEN
400070ec: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
400070f0: 90 10 00 1d mov %i5, %o0
400070f4: 94 10 20 00 clr %o2
400070f8: 40 00 1c b7 call 4000e3d4 <rtems_io_initialize>
400070fc: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40007100: ba 07 60 01 inc %i5
40007104: 80 a7 40 1c cmp %i5, %i4
40007108: 12 bf ff fb bne 400070f4 <_IO_Initialize_all_drivers+0x28> <== NEVER TAKEN
4000710c: 90 10 00 1d mov %i5, %o0
}
40007110: 81 c7 e0 08 ret
40007114: 81 e8 00 00 restore
40010904 <_Objects_Information_table>:
40010904: 00 00 00 00 40 01 30 58 40 01 30 2c 40 01 2f f8 ....@.0X@.0,@./.
40010914: 00 00 00 00 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 ...._Allocator..
40010924: 00 00 00 00 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 ....(fmt null)..
40010934: 00 00 00 00 28 6e 75 6c 6c 29 00 ....(null).
400070ac <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
400070ac: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
400070b0: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
400070b4: 40 00 02 3f call 400079b0 <_Terminate>
<== NOT EXECUTED
400070b8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400070bc: 01 00 00 00 nop
<== NOT EXECUTED
400070c0 <rtems_get_version_string>:
#include <rtems.h>
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
400070c0: 11 10 00 43 sethi %hi(0x40010c00), %o0
<== NOT EXECUTED
}
400070c4: 81 c3 e0 08 retl
<== NOT EXECUTED
400070c8: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 40010de0 <_RTEMS_version>
<== NOT EXECUTED
40007060 <rtems_initialize_executive>:
RTEMS_SYSINIT_DEVICE_DRIVERS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
40007060: 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;
40007064: 3b 10 00 43 sethi %hi(0x40010c00), %i5
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40007068: 39 10 00 43 sethi %hi(0x40010c00), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
4000706c: ba 17 62 40 or %i5, 0x240, %i5
40007070: b8 17 22 88 or %i4, 0x288, %i4
40007074: 80 a7 40 1c cmp %i5, %i4
40007078: 02 80 00 09 be 4000709c <rtems_initialize_executive+0x3c> <== NEVER TAKEN
4000707c: 03 10 00 4e sethi %hi(0x40013800), %g1
( *item->handler )();
40007080: c2 07 40 00 ld [ %i5 ], %g1
40007084: 9f c0 40 00 call %g1
40007088: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
4000708c: 80 a7 40 1c cmp %i5, %i4
40007090: 32 bf ff fd bne,a 40007084 <rtems_initialize_executive+0x24>
40007094: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
40007098: 03 10 00 4e sethi %hi(0x40013800), %g1
4000709c: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
400070a0: 40 00 15 46 call 4000c5b8 <_Thread_Start_multitasking>
400070a4: c4 20 61 b0 st %g2, [ %g1 + 0x1b0 ]
400070a8: 01 00 00 00 nop
<== NOT EXECUTED
4000e314 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e314: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e318: 03 10 00 40 sethi %hi(0x40010000), %g1
4000e31c: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40010100 <_IO_Number_of_drivers>
{
4000e320: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000e324: 80 a0 40 08 cmp %g1, %o0
4000e328: 08 80 00 11 bleu 4000e36c <rtems_io_close+0x58>
<== ALWAYS TAKEN
4000e32c: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
4000e330: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e334: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e338: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e33c: 03 10 00 48 sethi %hi(0x40012000), %g1
<== NOT EXECUTED
4000e340: 82 10 63 40 or %g1, 0x340, %g1 ! 40012340 <_IO_Driver_address_table>
<== NOT EXECUTED
4000e344: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e348: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e34c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e350: 02 80 00 06 be 4000e368 <rtems_io_close+0x54>
<== NOT EXECUTED
4000e354: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e358: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e35c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e360: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e364: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e368: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e36c: 81 c7 e0 08 ret
4000e370: 81 e8 00 00 restore
4000e374 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e374: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e378: 03 10 00 40 sethi %hi(0x40010000), %g1
4000e37c: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40010100 <_IO_Number_of_drivers>
{
4000e380: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000e384: 80 a0 40 08 cmp %g1, %o0
4000e388: 08 80 00 11 bleu 4000e3cc <rtems_io_control+0x58>
<== ALWAYS TAKEN
4000e38c: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
4000e390: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e394: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e398: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e39c: 03 10 00 48 sethi %hi(0x40012000), %g1
<== NOT EXECUTED
4000e3a0: 82 10 63 40 or %g1, 0x340, %g1 ! 40012340 <_IO_Driver_address_table>
<== NOT EXECUTED
4000e3a4: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e3a8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e3ac: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e3b0: 02 80 00 06 be 4000e3c8 <rtems_io_control+0x54>
<== NOT EXECUTED
4000e3b4: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e3b8: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e3bc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e3c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e3c4: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e3c8: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e3cc: 81 c7 e0 08 ret
4000e3d0: 81 e8 00 00 restore
4000e430 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e430: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e434: 03 10 00 40 sethi %hi(0x40010000), %g1
4000e438: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40010100 <_IO_Number_of_drivers>
{
4000e43c: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000e440: 80 a0 40 08 cmp %g1, %o0
4000e444: 08 80 00 11 bleu 4000e488 <rtems_io_open+0x58>
<== ALWAYS TAKEN
4000e448: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
4000e44c: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e450: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e454: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e458: 03 10 00 48 sethi %hi(0x40012000), %g1
<== NOT EXECUTED
4000e45c: 82 10 63 40 or %g1, 0x340, %g1 ! 40012340 <_IO_Driver_address_table>
<== NOT EXECUTED
4000e460: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e464: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e468: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e46c: 02 80 00 06 be 4000e484 <rtems_io_open+0x54>
<== NOT EXECUTED
4000e470: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e474: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e478: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e47c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e480: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e484: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e488: 81 c7 e0 08 ret
4000e48c: 81 e8 00 00 restore
4000e490 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e490: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e494: 03 10 00 40 sethi %hi(0x40010000), %g1
4000e498: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40010100 <_IO_Number_of_drivers>
{
4000e49c: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000e4a0: 80 a0 40 08 cmp %g1, %o0
4000e4a4: 08 80 00 11 bleu 4000e4e8 <rtems_io_read+0x58>
<== ALWAYS TAKEN
4000e4a8: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
4000e4ac: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e4b0: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e4b4: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e4b8: 03 10 00 48 sethi %hi(0x40012000), %g1
<== NOT EXECUTED
4000e4bc: 82 10 63 40 or %g1, 0x340, %g1 ! 40012340 <_IO_Driver_address_table>
<== NOT EXECUTED
4000e4c0: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e4c4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e4c8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e4cc: 02 80 00 06 be 4000e4e4 <rtems_io_read+0x54>
<== NOT EXECUTED
4000e4d0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e4d4: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e4d8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e4dc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e4e0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e4e4: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e4e8: 81 c7 e0 08 ret
4000e4ec: 81 e8 00 00 restore
4000e4f0 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e4f0: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e4f4: 03 10 00 40 sethi %hi(0x40010000), %g1
4000e4f8: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40010100 <_IO_Number_of_drivers>
{
4000e4fc: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000e500: 80 a0 40 08 cmp %g1, %o0
4000e504: 08 80 00 11 bleu 4000e548 <rtems_io_write+0x58>
<== ALWAYS TAKEN
4000e508: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
4000e50c: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e510: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e514: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e518: 03 10 00 48 sethi %hi(0x40012000), %g1
<== NOT EXECUTED
4000e51c: 82 10 63 40 or %g1, 0x340, %g1 ! 40012340 <_IO_Driver_address_table>
<== NOT EXECUTED
4000e520: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e524: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e528: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e52c: 02 80 00 06 be 4000e544 <rtems_io_write+0x54>
<== NOT EXECUTED
4000e530: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e534: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e538: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e53c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e540: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e544: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e548: 81 c7 e0 08 ret
4000e54c: 81 e8 00 00 restore
4000e300 <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
4000e300: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
4000e304: 90 10 20 05 mov 5, %o0
4000e308: 7f ff e5 aa call 400079b0 <_Terminate>
4000e30c: 92 10 00 18 mov %i0, %o1
4000e310: 01 00 00 00 nop
<== NOT EXECUTED
400088f8 <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
)
{
400088f8: 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 ) {
400088fc: 80 a6 a0 01 cmp %i2, 1
40008900: 08 80 00 28 bleu 400089a0 <rtems_timecounter_simple_install+0xa8> <== NEVER TAKEN
40008904: b8 10 00 18 mov %i0, %i4
40008908: 82 10 20 1f mov 0x1f, %g1
break;
}
power_of_two *= 2;
4000890c: 10 80 00 05 b 40008920 <rtems_timecounter_simple_install+0x28>
40008910: 90 10 20 02 mov 2, %o0
for ( i = 0; i < 32; ++i ) {
40008914: 82 80 7f ff addcc %g1, -1, %g1
40008918: 02 80 00 1c be 40008988 <rtems_timecounter_simple_install+0x90> <== NEVER TAKEN
4000891c: 90 10 00 02 mov %g2, %o0
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40008920: 80 a6 80 08 cmp %i2, %o0
40008924: 18 bf ff fc bgu 40008914 <rtems_timecounter_simple_install+0x1c>
40008928: 85 2a 20 01 sll %o0, 1, %g2
4000892c: 21 20 00 00 sethi %hi(0x80000000), %l0
40008930: ba 00 bf ff add %g2, -1, %i5
40008934: 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;
40008938: 94 10 20 00 clr %o2
4000893c: 96 10 00 1a mov %i2, %o3
40008940: 40 00 26 d5 call 40012494 <__udivdi3>
40008944: 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 );
40008948: 82 5e 40 08 smul %i1, %o0, %g1
4000894c: 86 56 40 09 umul %i1, %o1, %g3
40008950: 85 40 00 00 rd %y, %g2
tc->scaler = scaler;
40008954: d0 27 20 30 st %o0, [ %i4 + 0x30 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40008958: 84 00 40 02 add %g1, %g2, %g2
tc->scaler = scaler;
4000895c: d2 27 20 34 st %o1, [ %i4 + 0x34 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40008960: 82 10 20 64 mov 0x64, %g1
tc->real_interval = counter_ticks_per_clock_tick;
40008964: f4 27 20 38 st %i2, [ %i4 + 0x38 ]
tc->binary_interval = ( mask + 1 ) / 2;
40008968: e0 27 20 3c st %l0, [ %i4 + 0x3c ]
tc->tc.tc_get_timecount = get_timecount;
4000896c: f6 27 00 00 st %i3, [ %i4 ]
tc->tc.tc_counter_mask = mask;
40008970: fa 27 20 08 st %i5, [ %i4 + 8 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40008974: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
40008978: c0 27 20 10 clr [ %i4 + 0x10 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
4000897c: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
_Timecounter_Install( &tc->tc );
40008980: 40 00 07 ae call 4000a838 <_Timecounter_Install>
40008984: 91 e8 00 1c restore %g0, %i4, %o0
40008988: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
4000898c: 21 1f ff ff sethi %hi(0x7ffffc00), %l0
<== NOT EXECUTED
40008990: ba 00 bf ff add %g2, -1, %i5
<== NOT EXECUTED
40008994: a0 14 23 ff or %l0, 0x3ff, %l0
<== NOT EXECUTED
40008998: 10 bf ff e8 b 40008938 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
4000899c: a0 0a 00 10 and %o0, %l0, %l0
<== NOT EXECUTED
if ( power_of_two >= counter_ticks_per_clock_tick ) {
400089a0: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
400089a4: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
400089a8: 10 bf ff e4 b 40008938 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
400089ac: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED