RTEMS-5
Annotated Report
Fri Aug 10 14:25:04 2018
4007d6c8 <_Copyright_Notice>:
4007d6c8: 43 4f 50 59 52 49 47 48 54 20 28 63 29 20 31 39 COPYRIGHT (c) 19
4007d6d8: 38 39 2d 32 30 30 38 2e 0a 4f 6e 2d 4c 69 6e 65 89-2008..On-Line
4007d6e8: 20 41 70 70 6c 69 63 61 74 69 6f 6e 73 20 52 65 Applications Re
4007d6f8: 73 65 61 72 63 68 20 43 6f 72 70 6f 72 61 74 69 search Corporati
4007d708: 6f 6e 20 28 4f 41 52 29 2e 0a 00 00 00 00 00 00 on (OAR)........
4007d718: 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 00 00 00 00 _Allocator......
4007d728: 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 00 00 00 00 (fmt null)......
4007d738: 28 6e 75 6c 6c 29 00 (null).
40006974 <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
40006974: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
40006978: 03 10 00 4d sethi %hi(0x40013400), %g1
4000697c: 84 10 20 01 mov 1, %g2
40006980: c4 28 61 60 stb %g2, [ %g1 + 0x160 ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40006984: 03 10 00 3f sethi %hi(0x4000fc00), %g1
40006988: f8 00 63 04 ld [ %g1 + 0x304 ], %i4 ! 4000ff04 <_IO_Number_of_drivers>
4000698c: 80 a7 20 00 cmp %i4, 0
40006990: 02 80 00 0a be 400069b8 <_IO_Initialize_all_drivers+0x44>
<== NEVER TAKEN
40006994: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
40006998: 90 10 00 1d mov %i5, %o0
4000699c: 94 10 20 00 clr %o2
400069a0: 40 00 1c 44 call 4000dab0 <rtems_io_initialize>
400069a4: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
400069a8: ba 07 60 01 inc %i5
400069ac: 80 a7 40 1c cmp %i5, %i4
400069b0: 12 bf ff fb bne 4000699c <_IO_Initialize_all_drivers+0x28>
400069b4: 90 10 00 1d mov %i5, %o0
}
400069b8: 81 c7 e0 08 ret
400069bc: 81 e8 00 00 restore
400107c4 <_Objects_Information_table>:
400107c4: 00 00 00 00 40 01 2f 84 40 01 2f 58 40 01 2f 24 ....@./.@./X@./$
400107d4: 00 00 00 00 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 ...._Allocator..
400107e4: 00 00 00 00 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 ....(fmt null)..
400107f4: 00 00 00 00 28 6e 75 6c 6c 29 00 ....(null).
4000f2b8 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
4000f2b8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
Extension_Control *the_extension;
if ( !id )
4000f2bc: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000f2c0: 02 80 00 1b be 4000f32c <rtems_extension_create+0x74>
<== NOT EXECUTED
4000f2c4: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
4000f2c8: 02 80 00 17 be 4000f324 <rtems_extension_create+0x6c>
<== NOT EXECUTED
4000f2cc: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
extern Objects_Information _Extension_Information;
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
4000f2d0: 39 10 00 d3 sethi %hi(0x40034c00), %i4
<== NOT EXECUTED
4000f2d4: 40 00 08 d7 call 40011630 <_Objects_Allocate>
<== NOT EXECUTED
4000f2d8: 90 17 23 dc or %i4, 0x3dc, %o0 ! 40034fdc <_Extension_Information>
<== NOT EXECUTED
return RTEMS_INVALID_NAME;
the_extension = _Extension_Allocate();
if ( !the_extension ) {
4000f2dc: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4000f2e0: 02 80 00 16 be 4000f338 <rtems_extension_create+0x80>
<== NOT EXECUTED
4000f2e4: 94 10 20 24 mov 0x24, %o2
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
4000f2e8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000f2ec: 40 00 3b 59 call 4001e050 <memcpy>
<== NOT EXECUTED
4000f2f0: 90 07 60 24 add %i5, 0x24, %o0
<== NOT EXECUTED
_User_extensions_Add_set( extension );
4000f2f4: 40 00 19 80 call 400158f4 <_User_extensions_Add_set>
<== NOT EXECUTED
4000f2f8: 90 07 60 10 add %i5, 0x10, %o0
<== NOT EXECUTED
information->local_table[ index ] = the_object;
4000f2fc: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
<== NOT EXECUTED
the_object->name = name;
4000f300: f0 27 60 0c st %i0, [ %i5 + 0xc ]
<== NOT EXECUTED
information->local_table[ index ] = the_object;
4000f304: b8 17 23 dc or %i4, 0x3dc, %i4
<== NOT EXECUTED
4000f308: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
<== NOT EXECUTED
4000f30c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000f310: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4000f314: fa 20 c0 01 st %i5, [ %g3 + %g1 ]
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4000f318: 40 00 00 7f call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000f31c: c4 26 80 00 st %g2, [ %i2 ]
<== NOT EXECUTED
(Objects_Name) name
);
*id = the_extension->Object.id;
_Objects_Allocator_unlock();
return RTEMS_SUCCESSFUL;
4000f320: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
4000f324: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f328: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
4000f32c: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
}
4000f330: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f334: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
4000f338: 40 00 00 77 call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000f33c: 01 00 00 00 nop
<== NOT EXECUTED
return RTEMS_TOO_MANY;
4000f340: 10 bf ff f9 b 4000f324 <rtems_extension_create+0x6c>
<== NOT EXECUTED
4000f344: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
4000f348 <rtems_extension_delete>:
#include <rtems/score/userextimpl.h>
rtems_status_code rtems_extension_delete(
rtems_id id
)
{
4000f348: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_RTEMS_Lock_allocator();
4000f34c: 40 00 00 6d call 4000f500 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
4000f350: 39 10 00 d3 sethi %hi(0x40034c00), %i4
<== NOT EXECUTED
_Objects_Free( &_Extension_Information, &the_extension->Object );
}
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Get( Objects_Id id )
{
return (Extension_Control *)
4000f354: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
_Objects_Close( &_Extension_Information, &the_extension->Object );
_User_extensions_Remove_set( &the_extension->Extension );
_Extension_Free( the_extension );
status = RTEMS_SUCCESSFUL;
} else {
status = RTEMS_INVALID_ID;
4000f358: b0 10 20 04 mov 4, %i0
<== NOT EXECUTED
4000f35c: 40 00 09 ed call 40011b10 <_Objects_Get_no_protection>
<== NOT EXECUTED
4000f360: 92 17 23 dc or %i4, 0x3dc, %o1
<== NOT EXECUTED
if ( the_extension != NULL ) {
4000f364: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000f368: 02 80 00 0b be 4000f394 <rtems_extension_delete+0x4c>
<== NOT EXECUTED
4000f36c: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
_Objects_Close( &_Extension_Information, &the_extension->Object );
4000f370: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
4000f374: 40 00 08 b4 call 40011644 <_Objects_Close>
<== NOT EXECUTED
4000f378: 90 17 23 dc or %i4, 0x3dc, %o0
<== NOT EXECUTED
_User_extensions_Remove_set( &the_extension->Extension );
4000f37c: 40 00 1a 4b call 40015ca8 <_User_extensions_Remove_set>
<== NOT EXECUTED
4000f380: 90 07 60 10 add %i5, 0x10, %o0
<== NOT EXECUTED
_Objects_Free( &_Extension_Information, &the_extension->Object );
4000f384: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000f388: 90 17 23 dc or %i4, 0x3dc, %o0
<== NOT EXECUTED
4000f38c: 40 00 09 7a call 40011974 <_Objects_Free>
<== NOT EXECUTED
4000f390: b0 10 20 00 clr %i0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4000f394: 40 00 00 60 call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000f398: 01 00 00 00 nop
<== NOT EXECUTED
}
_Objects_Allocator_unlock();
return status;
}
4000f39c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f3a0: 81 e8 00 00 restore
<== NOT EXECUTED
40006954 <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
40006954: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
40006958: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
4000695c: 40 00 02 51 call 400072a0 <_Terminate>
<== NOT EXECUTED
40006960: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40006964: 01 00 00 00 nop
<== NOT EXECUTED
40006968 <rtems_get_version_string>:
#include <rtems.h>
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
40006968: 11 10 00 43 sethi %hi(0x40010c00), %o0
<== NOT EXECUTED
}
4000696c: 81 c3 e0 08 retl
<== NOT EXECUTED
40006970: 90 12 20 a8 or %o0, 0xa8, %o0 ! 40010ca8 <_RTEMS_version>
<== NOT EXECUTED
40006908 <rtems_initialize_executive>:
RTEMS_SYSINIT_DEVICE_DRIVERS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
40006908: 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;
4000690c: 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 ) {
40006910: 39 10 00 43 sethi %hi(0x40010c00), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
40006914: ba 17 61 00 or %i5, 0x100, %i5
40006918: b8 17 21 44 or %i4, 0x144, %i4
4000691c: 80 a7 40 1c cmp %i5, %i4
40006920: 02 80 00 09 be 40006944 <rtems_initialize_executive+0x3c>
<== NEVER TAKEN
40006924: 03 10 00 4d sethi %hi(0x40013400), %g1
( *item->handler )();
40006928: c2 07 40 00 ld [ %i5 ], %g1
4000692c: 9f c0 40 00 call %g1
40006930: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40006934: 80 a7 40 1c cmp %i5, %i4
40006938: 32 bf ff fd bne,a 4000692c <rtems_initialize_executive+0x24>
4000693c: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
40006940: 03 10 00 4d sethi %hi(0x40013400), %g1
40006944: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
40006948: 40 00 14 ac call 4000bbf8 <_Thread_Start_multitasking>
4000694c: c4 20 61 6c st %g2, [ %g1 + 0x16c ]
40006950: 01 00 00 00 nop
<== NOT EXECUTED
4000d9f0 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000d9f0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000d9f4: 03 10 00 3f sethi %hi(0x4000fc00), %g1
<== NOT EXECUTED
4000d9f8: c2 00 63 04 ld [ %g1 + 0x304 ], %g1 ! 4000ff04 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000d9fc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000da00: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000da04: 08 80 00 11 bleu 4000da48 <rtems_io_close+0x58>
<== NOT EXECUTED
4000da08: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
4000da0c: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000da10: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000da14: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000da18: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
4000da1c: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 40011db0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000da20: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000da24: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000da28: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000da2c: 02 80 00 06 be 4000da44 <rtems_io_close+0x54>
<== NOT EXECUTED
4000da30: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000da34: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000da38: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000da3c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000da40: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000da44: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000da48: 81 c7 e0 08 ret
<== NOT EXECUTED
4000da4c: 81 e8 00 00 restore
<== NOT EXECUTED
4000da50 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000da50: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000da54: 03 10 00 3f sethi %hi(0x4000fc00), %g1
<== NOT EXECUTED
4000da58: c2 00 63 04 ld [ %g1 + 0x304 ], %g1 ! 4000ff04 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000da5c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000da60: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000da64: 08 80 00 11 bleu 4000daa8 <rtems_io_control+0x58>
<== NOT EXECUTED
4000da68: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
4000da6c: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000da70: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000da74: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000da78: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
4000da7c: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 40011db0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000da80: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000da84: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000da88: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000da8c: 02 80 00 06 be 4000daa4 <rtems_io_control+0x54>
<== NOT EXECUTED
4000da90: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000da94: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000da98: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000da9c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000daa0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000daa4: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000daa8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000daac: 81 e8 00 00 restore
<== NOT EXECUTED
4000dab0 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000dab0: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000dab4: 03 10 00 3f sethi %hi(0x4000fc00), %g1
4000dab8: c2 00 63 04 ld [ %g1 + 0x304 ], %g1 ! 4000ff04 <_IO_Number_of_drivers>
{
4000dabc: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000dac0: 80 a0 40 08 cmp %g1, %o0
4000dac4: 08 80 00 10 bleu 4000db04 <rtems_io_initialize+0x54>
<== NEVER TAKEN
4000dac8: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
4000dacc: 83 2a 20 01 sll %o0, 1, %g1
4000dad0: 07 10 00 47 sethi %hi(0x40011c00), %g3
4000dad4: 82 00 40 08 add %g1, %o0, %g1
4000dad8: 86 10 e1 b0 or %g3, 0x1b0, %g3
4000dadc: 83 28 60 03 sll %g1, 3, %g1
4000dae0: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000dae4: 80 a0 60 00 cmp %g1, 0
4000dae8: 02 80 00 06 be 4000db00 <rtems_io_initialize+0x50>
4000daec: 94 10 00 1a mov %i2, %o2
4000daf0: 9f c0 40 00 call %g1
4000daf4: 92 10 00 19 mov %i1, %o1
4000daf8: 81 c7 e0 08 ret
4000dafc: 91 e8 00 08 restore %g0, %o0, %o0
4000db00: b0 10 20 00 clr %i0
}
4000db04: 81 c7 e0 08 ret
4000db08: 81 e8 00 00 restore
4000db0c <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000db0c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000db10: 03 10 00 3f sethi %hi(0x4000fc00), %g1
<== NOT EXECUTED
4000db14: c2 00 63 04 ld [ %g1 + 0x304 ], %g1 ! 4000ff04 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000db18: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000db1c: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000db20: 08 80 00 11 bleu 4000db64 <rtems_io_open+0x58>
<== NOT EXECUTED
4000db24: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
4000db28: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000db2c: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000db30: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000db34: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
4000db38: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 40011db0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000db3c: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000db40: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000db44: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000db48: 02 80 00 06 be 4000db60 <rtems_io_open+0x54>
<== NOT EXECUTED
4000db4c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000db50: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000db54: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000db58: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db5c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000db60: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000db64: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db68: 81 e8 00 00 restore
<== NOT EXECUTED
4000db6c <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000db6c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000db70: 03 10 00 3f sethi %hi(0x4000fc00), %g1
<== NOT EXECUTED
4000db74: c2 00 63 04 ld [ %g1 + 0x304 ], %g1 ! 4000ff04 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000db78: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000db7c: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000db80: 08 80 00 11 bleu 4000dbc4 <rtems_io_read+0x58>
<== NOT EXECUTED
4000db84: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
4000db88: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000db8c: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000db90: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000db94: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
4000db98: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 40011db0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000db9c: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000dba0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000dba4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dba8: 02 80 00 06 be 4000dbc0 <rtems_io_read+0x54>
<== NOT EXECUTED
4000dbac: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000dbb0: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dbb4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000dbb8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dbbc: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000dbc0: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000dbc4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dbc8: 81 e8 00 00 restore
<== NOT EXECUTED
40019c08 <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
)
{
40019c08: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_major_number major_limit = _IO_Number_of_drivers;
40019c0c: 3b 10 01 f1 sethi %hi(0x4007c400), %i5
<== NOT EXECUTED
ISR_lock_Context lock_context;
if ( rtems_interrupt_is_in_progress() )
40019c10: 40 00 06 63 call 4001b59c <_ISR_Is_in_progress>
<== NOT EXECUTED
40019c14: f8 07 63 10 ld [ %i5 + 0x310 ], %i4 ! 4007c710 <_IO_Number_of_drivers>
<== NOT EXECUTED
40019c18: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40019c1c: 12 80 00 45 bne 40019d30 <rtems_io_register_driver+0x128>
<== NOT EXECUTED
40019c20: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
40019c24: 02 80 00 40 be 40019d24 <rtems_io_register_driver+0x11c>
<== NOT EXECUTED
40019c28: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
40019c2c: 02 80 00 3e be 40019d24 <rtems_io_register_driver+0x11c>
<== NOT EXECUTED
40019c30: f8 26 80 00 st %i4, [ %i2 ]
<== NOT EXECUTED
return table->initialization_entry == NULL && table->open_entry == NULL;
40019c34: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
40019c38: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40019c3c: 22 80 00 37 be,a 40019d18 <rtems_io_register_driver+0x110>
<== NOT EXECUTED
40019c40: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
40019c44: 80 a7 00 18 cmp %i4, %i0
<== NOT EXECUTED
40019c48: 08 80 00 4a bleu 40019d70 <rtems_io_register_driver+0x168>
<== NOT EXECUTED
40019c4c: 82 10 20 0a mov 0xa, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40019c50: 91 d0 20 09 ta 9
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
_IO_Driver_registration_acquire( &lock_context );
if ( major == 0 ) {
40019c54: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40019c58: 12 80 00 39 bne 40019d3c <rtems_io_register_driver+0x134>
<== NOT EXECUTED
40019c5c: 85 2e 20 01 sll %i0, 1, %g2
<== NOT EXECUTED
rtems_device_major_number n = _IO_Number_of_drivers;
40019c60: fa 07 63 10 ld [ %i5 + 0x310 ], %i5
<== NOT EXECUTED
for ( m = 0; m < n; ++m ) {
40019c64: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
40019c68: 02 80 00 4f be 40019da4 <rtems_io_register_driver+0x19c>
<== NOT EXECUTED
40019c6c: 07 10 02 2e sethi %hi(0x4008b800), %g3
<== NOT EXECUTED
40019c70: 86 10 e1 6c or %g3, 0x16c, %g3 ! 4008b96c <_IO_Driver_address_table>
<== NOT EXECUTED
40019c74: 10 80 00 05 b 40019c88 <rtems_io_register_driver+0x80>
<== NOT EXECUTED
40019c78: 84 10 00 03 mov %g3, %g2
<== NOT EXECUTED
40019c7c: 80 a7 40 18 cmp %i5, %i0
<== NOT EXECUTED
40019c80: 02 80 00 3e be 40019d78 <rtems_io_register_driver+0x170>
<== NOT EXECUTED
40019c84: 84 00 a0 18 add %g2, 0x18, %g2
<== NOT EXECUTED
return table->initialization_entry == NULL && table->open_entry == NULL;
40019c88: c8 00 80 00 ld [ %g2 ], %g4
<== NOT EXECUTED
40019c8c: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
40019c90: 32 bf ff fb bne,a 40019c7c <rtems_io_register_driver+0x74>
<== NOT EXECUTED
40019c94: b0 06 20 01 inc %i0
<== NOT EXECUTED
40019c98: c8 00 a0 04 ld [ %g2 + 4 ], %g4
<== NOT EXECUTED
40019c9c: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
40019ca0: 32 bf ff f7 bne,a 40019c7c <rtems_io_register_driver+0x74>
<== NOT EXECUTED
40019ca4: b0 06 20 01 inc %i0
<== NOT EXECUTED
if ( m != n )
40019ca8: 80 a7 40 18 cmp %i5, %i0
<== NOT EXECUTED
40019cac: 02 80 00 34 be 40019d7c <rtems_io_register_driver+0x174>
<== NOT EXECUTED
40019cb0: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
40019cb4: 84 5e 20 03 smul %i0, 3, %g2
<== NOT EXECUTED
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
40019cb8: c8 06 40 00 ld [ %i1 ], %g4
<== NOT EXECUTED
40019cbc: 85 28 a0 03 sll %g2, 3, %g2
<== NOT EXECUTED
40019cc0: c8 20 c0 02 st %g4, [ %g3 + %g2 ]
<== NOT EXECUTED
40019cc4: 84 00 c0 02 add %g3, %g2, %g2
<== NOT EXECUTED
40019cc8: c6 06 60 04 ld [ %i1 + 4 ], %g3
<== NOT EXECUTED
40019ccc: c6 20 a0 04 st %g3, [ %g2 + 4 ]
<== NOT EXECUTED
40019cd0: c6 06 60 08 ld [ %i1 + 8 ], %g3
<== NOT EXECUTED
40019cd4: c6 20 a0 08 st %g3, [ %g2 + 8 ]
<== NOT EXECUTED
40019cd8: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
40019cdc: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
40019ce0: c6 06 60 10 ld [ %i1 + 0x10 ], %g3
<== NOT EXECUTED
40019ce4: c6 20 a0 10 st %g3, [ %g2 + 0x10 ]
<== NOT EXECUTED
40019ce8: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
<== NOT EXECUTED
40019cec: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40019cf0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40019cf4: 01 00 00 00 nop
<== NOT EXECUTED
_IO_Driver_registration_release( &lock_context );
if ( _IO_All_drivers_initialized ) {
40019cf8: 03 10 02 43 sethi %hi(0x40090c00), %g1
<== NOT EXECUTED
40019cfc: c4 08 62 28 ldub [ %g1 + 0x228 ], %g2 ! 40090e28 <_IO_All_drivers_initialized>
<== NOT EXECUTED
40019d00: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40019d04: 02 80 00 09 be 40019d28 <rtems_io_register_driver+0x120>
<== NOT EXECUTED
40019d08: 82 10 20 00 clr %g1
<== NOT EXECUTED
/* Other drivers have already been initialized, we initialize
* the driver directly.
*/
return rtems_io_initialize( major, 0, NULL );
40019d0c: b4 10 20 00 clr %i2
<== NOT EXECUTED
40019d10: 40 00 aa 57 call 4004466c <rtems_io_initialize>
<== NOT EXECUTED
40019d14: 93 e8 20 00 restore %g0, 0, %o1
<== NOT EXECUTED
return table->initialization_entry == NULL && table->open_entry == NULL;
40019d18: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40019d1c: 12 bf ff cb bne 40019c48 <rtems_io_register_driver+0x40>
<== NOT EXECUTED
40019d20: 80 a7 00 18 cmp %i4, %i0
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
40019d24: 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;
}
}
40019d28: 81 c7 e0 08 ret
<== NOT EXECUTED
40019d2c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
return RTEMS_CALLED_FROM_ISR;
40019d30: 82 10 20 12 mov 0x12, %g1
<== NOT EXECUTED
}
40019d34: 81 c7 e0 08 ret
<== NOT EXECUTED
40019d38: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
40019d3c: 07 10 02 2e sethi %hi(0x4008b800), %g3
<== NOT EXECUTED
40019d40: 84 00 80 18 add %g2, %i0, %g2
<== NOT EXECUTED
40019d44: 86 10 e1 6c or %g3, 0x16c, %g3
<== NOT EXECUTED
40019d48: 89 28 a0 03 sll %g2, 3, %g4
<== NOT EXECUTED
return table->initialization_entry == NULL && table->open_entry == NULL;
40019d4c: fa 00 c0 04 ld [ %g3 + %g4 ], %i5
<== NOT EXECUTED
40019d50: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
40019d54: 02 80 00 0e be 40019d8c <rtems_io_register_driver+0x184>
<== NOT EXECUTED
40019d58: 88 00 c0 04 add %g3, %g4, %g4
<== NOT EXECUTED
40019d5c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40019d60: 01 00 00 00 nop
<== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
40019d64: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
}
40019d68: 81 c7 e0 08 ret
<== NOT EXECUTED
40019d6c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
40019d70: 81 c7 e0 08 ret
<== NOT EXECUTED
40019d74: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
*major = m;
40019d78: fa 26 80 00 st %i5, [ %i2 ]
<== NOT EXECUTED
40019d7c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40019d80: 01 00 00 00 nop
<== NOT EXECUTED
return sc;
40019d84: 10 bf ff e9 b 40019d28 <rtems_io_register_driver+0x120>
<== NOT EXECUTED
40019d88: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
return table->initialization_entry == NULL && table->open_entry == NULL;
40019d8c: c8 01 20 04 ld [ %g4 + 4 ], %g4
<== NOT EXECUTED
40019d90: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
40019d94: 12 bf ff f2 bne 40019d5c <rtems_io_register_driver+0x154>
<== NOT EXECUTED
40019d98: 01 00 00 00 nop
<== NOT EXECUTED
*registered_major = major;
40019d9c: 10 bf ff c7 b 40019cb8 <rtems_io_register_driver+0xb0>
<== NOT EXECUTED
40019da0: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
*major = m;
40019da4: 10 bf ff f6 b 40019d7c <rtems_io_register_driver+0x174>
<== NOT EXECUTED
40019da8: c0 26 80 00 clr [ %i2 ]
<== NOT EXECUTED
4000dbcc <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000dbcc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000dbd0: 03 10 00 3f sethi %hi(0x4000fc00), %g1
<== NOT EXECUTED
4000dbd4: c2 00 63 04 ld [ %g1 + 0x304 ], %g1 ! 4000ff04 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000dbd8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000dbdc: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000dbe0: 08 80 00 11 bleu 4000dc24 <rtems_io_write+0x58>
<== NOT EXECUTED
4000dbe4: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
4000dbe8: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000dbec: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000dbf0: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000dbf4: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
4000dbf8: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 40011db0 <_IO_Driver_address_table>
<== NOT EXECUTED
4000dbfc: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000dc00: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000dc04: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000dc08: 02 80 00 06 be 4000dc20 <rtems_io_write+0x54>
<== NOT EXECUTED
4000dc0c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000dc10: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dc14: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000dc18: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc1c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000dc20: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000dc24: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc28: 81 e8 00 00 restore
<== NOT EXECUTED
40010c8c <rtems_panic>:
#include <rtems/bspIo.h>
#include <stdarg.h>
void rtems_panic( const char *fmt, ... )
{
40010c8c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
va_list ap;
va_start( ap, fmt );
40010c90: 82 07 a0 48 add %fp, 0x48, %g1
<== NOT EXECUTED
40010c94: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
<== NOT EXECUTED
vprintk( fmt, ap );
40010c98: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
va_start( ap, fmt );
40010c9c: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
<== NOT EXECUTED
vprintk( fmt, ap );
40010ca0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
va_start( ap, fmt );
40010ca4: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
<== NOT EXECUTED
40010ca8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
<== NOT EXECUTED
40010cac: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
<== NOT EXECUTED
vprintk( fmt, ap );
40010cb0: 7f ff d7 2f call 4000696c <vprintk>
<== NOT EXECUTED
40010cb4: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
va_end( ap);
_Terminate( RTEMS_FATAL_SOURCE_PANIC, (Internal_errors_t) fmt );
40010cb8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40010cbc: 40 00 02 30 call 4001157c <_Terminate>
<== NOT EXECUTED
40010cc0: 90 10 20 0b mov 0xb, %o0
<== NOT EXECUTED
40010cc4: 01 00 00 00 nop
<== NOT EXECUTED
400447e8 <rtems_profiling_report_xml>:
(void) indentation_level;
(void) indentation;
return 0;
#endif /* RTEMS_PROFILING */
}
400447e8: 81 c3 e0 08 retl
<== NOT EXECUTED
400447ec: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000d9dc <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
4000d9dc: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
4000d9e0: 90 10 20 05 mov 5, %o0
4000d9e4: 7f ff e6 2f call 400072a0 <_Terminate>
4000d9e8: 92 10 00 18 mov %i0, %o1
4000d9ec: 01 00 00 00 nop
<== NOT EXECUTED
400069c0 <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
)
{
400069c0: 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 ) {
400069c4: 80 a6 a0 01 cmp %i2, 1
400069c8: 08 80 00 28 bleu 40006a68 <rtems_timecounter_simple_install+0xa8>
<== NEVER TAKEN
400069cc: b8 10 00 18 mov %i0, %i4
400069d0: 82 10 20 1f mov 0x1f, %g1
break;
}
power_of_two *= 2;
400069d4: 10 80 00 05 b 400069e8 <rtems_timecounter_simple_install+0x28>
400069d8: 90 10 20 02 mov 2, %o0
for ( i = 0; i < 32; ++i ) {
400069dc: 82 80 7f ff addcc %g1, -1, %g1
400069e0: 02 80 00 1c be 40006a50 <rtems_timecounter_simple_install+0x90>
<== NEVER TAKEN
400069e4: 90 10 00 02 mov %g2, %o0
if ( power_of_two >= counter_ticks_per_clock_tick ) {
400069e8: 80 a6 80 08 cmp %i2, %o0
400069ec: 18 bf ff fc bgu 400069dc <rtems_timecounter_simple_install+0x1c>
400069f0: 85 2a 20 01 sll %o0, 1, %g2
400069f4: 21 20 00 00 sethi %hi(0x80000000), %l0
400069f8: ba 00 bf ff add %g2, -1, %i5
400069fc: 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;
40006a00: 94 10 20 00 clr %o2
40006a04: 96 10 00 1a mov %i2, %o3
40006a08: 40 00 22 e2 call 4000f590 <__udivdi3>
40006a0c: 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 );
40006a10: 82 5e 40 08 smul %i1, %o0, %g1
40006a14: 86 56 40 09 umul %i1, %o1, %g3
40006a18: 85 40 00 00 rd %y, %g2
tc->scaler = scaler;
40006a1c: d0 27 20 30 st %o0, [ %i4 + 0x30 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40006a20: 84 00 40 02 add %g1, %g2, %g2
tc->scaler = scaler;
40006a24: d2 27 20 34 st %o1, [ %i4 + 0x34 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40006a28: 82 10 20 64 mov 0x64, %g1
tc->real_interval = counter_ticks_per_clock_tick;
40006a2c: f4 27 20 38 st %i2, [ %i4 + 0x38 ]
tc->binary_interval = ( mask + 1 ) / 2;
40006a30: e0 27 20 3c st %l0, [ %i4 + 0x3c ]
tc->tc.tc_get_timecount = get_timecount;
40006a34: f6 27 00 00 st %i3, [ %i4 ]
tc->tc.tc_counter_mask = mask;
40006a38: fa 27 20 08 st %i5, [ %i4 + 8 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40006a3c: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
40006a40: c0 27 20 10 clr [ %i4 + 0x10 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40006a44: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
_Timecounter_Install( &tc->tc );
40006a48: 40 00 06 bb call 40008534 <_Timecounter_Install>
40006a4c: 91 e8 00 1c restore %g0, %i4, %o0
40006a50: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
40006a54: 21 1f ff ff sethi %hi(0x7ffffc00), %l0
<== NOT EXECUTED
40006a58: ba 00 bf ff add %g2, -1, %i5
<== NOT EXECUTED
40006a5c: a0 14 23 ff or %l0, 0x3ff, %l0
<== NOT EXECUTED
40006a60: 10 bf ff e8 b 40006a00 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40006a64: a0 0a 00 10 and %o0, %l0, %l0
<== NOT EXECUTED
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40006a68: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
40006a6c: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
40006a70: 10 bf ff e4 b 40006a00 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40006a74: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED