400073a0 <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
400073a0: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
400073a4: 03 10 00 5c sethi %hi(0x40017000), %g1
400073a8: 84 10 20 01 mov 1, %g2
400073ac: c4 28 60 f4 stb %g2, [ %g1 + 0xf4 ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
400073b0: 03 10 00 4f sethi %hi(0x40013c00), %g1
400073b4: f8 00 61 6c ld [ %g1 + 0x16c ], %i4 ! 40013d6c <_IO_Number_of_drivers>
400073b8: 80 a7 20 00 cmp %i4, 0
400073bc: 02 80 00 0a be 400073e4 <_IO_Initialize_all_drivers+0x44> <== NEVER TAKEN
400073c0: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
400073c4: 90 10 00 1d mov %i5, %o0
400073c8: 94 10 20 00 clr %o2
400073cc: 40 00 28 41 call 400114d0 <rtems_io_initialize>
400073d0: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
400073d4: ba 07 60 01 inc %i5
400073d8: 80 a7 40 1c cmp %i5, %i4
400073dc: 12 bf ff fb bne 400073c8 <_IO_Initialize_all_drivers+0x28>
400073e0: 90 10 00 1d mov %i5, %o0
}
400073e4: 81 c7 e0 08 ret
400073e8: 81 e8 00 00 restore
400142e8 <_Objects_Information_table>:
400142e8: 00 00 00 00 40 01 6a 38 40 01 6a 0c 40 01 69 d8 ....@.j8@.j.@.i.
400142f8: 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 00 00 00 00 _Allocator......
40014308: 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 00 00 00 00 (fmt null)......
40014318: 28 6e 75 6c 6c 29 00 (null).
4000c65c <rtems_chain_append>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c65c: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
4000c660: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000c664: 86 02 20 04 add %o0, 4, %g3
<== NOT EXECUTED
the_node->next = tail;
4000c668: c6 22 40 00 st %g3, [ %o1 ]
<== NOT EXECUTED
tail->previous = the_node;
4000c66c: d2 22 20 08 st %o1, [ %o0 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000c670: d2 20 80 00 st %o1, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000c674: c4 22 60 04 st %g2, [ %o1 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c678: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c67c: 01 00 00 00 nop
rtems_interrupt_lock_context lock_context;
chain_acquire( &lock_context );
_Chain_Append_unprotected( chain, node );
chain_release( &lock_context );
}
4000c680: 81 c3 e0 08 retl
4000c684: 01 00 00 00 nop
4000c600 <rtems_chain_extract>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c600: 91 d0 20 09 ta 9
<== NOT EXECUTED
next = the_node->next;
4000c604: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
4000c608: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
next->previous = previous;
4000c60c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
previous->next = next;
4000c610: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c614: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c618: 01 00 00 00 nop
rtems_interrupt_lock_context lock_context;
chain_acquire( &lock_context );
_Chain_Extract_unprotected( node );
chain_release( &lock_context );
}
4000c61c: 81 c3 e0 08 retl
4000c620: 01 00 00 00 nop
4000c624 <rtems_chain_get>:
rtems_chain_node *rtems_chain_get( rtems_chain_control *chain )
{
4000c624: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c628: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000c62c: d0 02 00 00 ld [ %o0 ], %o0
return &the_chain->Tail.Node;
4000c630: 86 00 a0 04 add %g2, 4, %g3
if ( !_Chain_Is_empty(the_chain))
4000c634: 80 a2 00 03 cmp %o0, %g3
4000c638: 22 80 00 05 be,a 4000c64c <rtems_chain_get+0x28>
<== NEVER TAKEN
4000c63c: 90 10 20 00 clr %o0
<== NOT EXECUTED
new_first = old_first->next;
4000c640: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
head->next = new_first;
4000c644: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
new_first->previous = head;
4000c648: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c64c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c650: 01 00 00 00 nop
chain_acquire( &lock_context );
node = _Chain_Get_unprotected( chain );
chain_release( &lock_context );
return node;
}
4000c654: 81 c3 e0 08 retl
4000c658: 01 00 00 00 nop
4000a4a4 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
4000a4a4: 9d e3 bf a0 save %sp, -96, %sp
Extension_Control *the_extension;
if ( !id )
4000a4a8: 80 a6 a0 00 cmp %i2, 0
4000a4ac: 02 80 00 1b be 4000a518 <rtems_extension_create+0x74>
<== NEVER TAKEN
4000a4b0: 80 a6 20 00 cmp %i0, 0
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
4000a4b4: 02 80 00 17 be 4000a510 <rtems_extension_create+0x6c>
<== NEVER TAKEN
4000a4b8: 82 10 20 03 mov 3, %g1
extern Objects_Information _Extension_Information;
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
4000a4bc: 39 10 00 85 sethi %hi(0x40021400), %i4
4000a4c0: 40 00 08 56 call 4000c618 <_Objects_Allocate>
4000a4c4: 90 17 20 54 or %i4, 0x54, %o0 ! 40021454 <_Extension_Information>
return RTEMS_INVALID_NAME;
the_extension = _Extension_Allocate();
if ( !the_extension ) {
4000a4c8: ba 92 20 00 orcc %o0, 0, %i5
4000a4cc: 02 80 00 16 be 4000a524 <rtems_extension_create+0x80>
<== NEVER TAKEN
4000a4d0: 94 10 20 24 mov 0x24, %o2
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
4000a4d4: 92 10 00 19 mov %i1, %o1
4000a4d8: 40 00 24 48 call 400135f8 <memcpy>
4000a4dc: 90 07 60 24 add %i5, 0x24, %o0
_User_extensions_Add_set( extension );
4000a4e0: 40 00 18 07 call 400104fc <_User_extensions_Add_set>
4000a4e4: 90 07 60 10 add %i5, 0x10, %o0
information->local_table[ index ] = the_object;
4000a4e8: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
the_object->name = name;
4000a4ec: f0 27 60 0c st %i0, [ %i5 + 0xc ]
information->local_table[ index ] = the_object;
4000a4f0: b8 17 20 54 or %i4, 0x54, %i4
4000a4f4: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
4000a4f8: c4 07 60 08 ld [ %i5 + 8 ], %g2
4000a4fc: 83 28 60 02 sll %g1, 2, %g1
4000a500: fa 20 c0 01 st %i5, [ %g3 + %g1 ]
_RTEMS_Unlock_allocator();
4000a504: 40 00 00 68 call 4000a6a4 <_RTEMS_Unlock_allocator>
4000a508: c4 26 80 00 st %g2, [ %i2 ]
(Objects_Name) name
);
*id = the_extension->Object.id;
_Objects_Allocator_unlock();
return RTEMS_SUCCESSFUL;
4000a50c: 82 10 20 00 clr %g1
}
4000a510: 81 c7 e0 08 ret
4000a514: 91 e8 00 01 restore %g0, %g1, %o0
return RTEMS_INVALID_ADDRESS;
4000a518: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
}
4000a51c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a520: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
4000a524: 40 00 00 60 call 4000a6a4 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000a528: 01 00 00 00 nop
<== NOT EXECUTED
return RTEMS_TOO_MANY;
4000a52c: 10 bf ff f9 b 4000a510 <rtems_extension_create+0x6c>
<== NOT EXECUTED
4000a530: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
40007380 <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
40007380: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
40007384: 90 10 20 01 mov 1, %o0
40007388: 40 00 02 e8 call 40007f28 <_Terminate>
4000738c: 92 10 00 18 mov %i0, %o1
40007390: 01 00 00 00 nop
<== NOT EXECUTED
400066ec <rtems_fatal_source_text>:
const char *rtems_fatal_source_text( rtems_fatal_source source )
{
size_t i = source;
const char *text = "?";
if ( i < RTEMS_ARRAY_SIZE( fatal_source_text ) ) {
400066ec: 80 a2 20 0c cmp %o0, 0xc
<== NOT EXECUTED
400066f0: 18 80 00 06 bgu 40006708 <rtems_fatal_source_text+0x1c>
<== NOT EXECUTED
400066f4: 03 10 00 40 sethi %hi(0x40010000), %g1
<== NOT EXECUTED
text = fatal_source_text[ i ];
400066f8: 91 2a 20 02 sll %o0, 2, %o0
<== NOT EXECUTED
400066fc: 82 10 63 20 or %g1, 0x320, %g1
<== NOT EXECUTED
40006700: 81 c3 e0 08 retl
<== NOT EXECUTED
40006704: d0 00 40 08 ld [ %g1 + %o0 ], %o0
<== NOT EXECUTED
const char *text = "?";
40006708: 11 10 00 3f sethi %hi(0x4000fc00), %o0
<== NOT EXECUTED
}
return text;
}
4000670c: 81 c3 e0 08 retl
<== NOT EXECUTED
40006710: 90 12 22 50 or %o0, 0x250, %o0 ! 4000fe50 <rtems_filesystem_null_handlers+0x40>
<== NOT EXECUTED
40007394 <rtems_get_version_string>:
#include <rtems.h>
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
40007394: 11 10 00 51 sethi %hi(0x40014400), %o0
<== NOT EXECUTED
}
40007398: 81 c3 e0 08 retl
<== NOT EXECUTED
4000739c: 90 12 23 98 or %o0, 0x398, %o0 ! 40014798 <_RTEMS_version>
<== NOT EXECUTED
40007334 <rtems_initialize_executive>:
RTEMS_SYSINIT_DEVICE_DRIVERS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
40007334: 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;
40007338: 3b 10 00 51 sethi %hi(0x40014400), %i5
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
4000733c: 39 10 00 52 sethi %hi(0x40014800), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
40007340: ba 17 63 f0 or %i5, 0x3f0, %i5
40007344: b8 17 20 34 or %i4, 0x34, %i4
40007348: 80 a7 40 1c cmp %i5, %i4
4000734c: 02 80 00 09 be 40007370 <rtems_initialize_executive+0x3c> <== NEVER TAKEN
40007350: 03 10 00 5c sethi %hi(0x40017000), %g1
( *item->handler )();
40007354: c2 07 40 00 ld [ %i5 ], %g1
40007358: 9f c0 40 00 call %g1
4000735c: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40007360: 80 a7 40 1c cmp %i5, %i4
40007364: 32 bf ff fd bne,a 40007358 <rtems_initialize_executive+0x24>
40007368: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
4000736c: 03 10 00 5c sethi %hi(0x40017000), %g1
40007370: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
40007374: 40 00 13 6f call 4000c130 <_Thread_Start_multitasking>
40007378: c4 20 61 00 st %g2, [ %g1 + 0x100 ]
4000737c: 01 00 00 00 nop
<== NOT EXECUTED
40006720 <rtems_internal_error_text>:
const char *rtems_internal_error_text( rtems_fatal_code error )
{
size_t i = error;
const char *text = "?";
if ( i < RTEMS_ARRAY_SIZE( internal_error_text ) ) {
40006720: 80 a2 20 27 cmp %o0, 0x27
<== NOT EXECUTED
40006724: 18 80 00 06 bgu 4000673c <rtems_internal_error_text+0x1c>
<== NOT EXECUTED
40006728: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
text = internal_error_text[ i ];
4000672c: 91 2a 20 02 sll %o0, 2, %o0
<== NOT EXECUTED
40006730: 82 10 62 04 or %g1, 0x204, %g1
<== NOT EXECUTED
40006734: 81 c3 e0 08 retl
<== NOT EXECUTED
40006738: d0 00 40 08 ld [ %g1 + %o0 ], %o0
<== NOT EXECUTED
const char *text = "?";
4000673c: 11 10 00 3f sethi %hi(0x4000fc00), %o0
<== NOT EXECUTED
}
return text;
}
40006740: 81 c3 e0 08 retl
<== NOT EXECUTED
40006744: 90 12 22 50 or %o0, 0x250, %o0 ! 4000fe50 <rtems_filesystem_null_handlers+0x40>
<== NOT EXECUTED
40011410 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
40011410: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
40011414: 03 10 00 4f sethi %hi(0x40013c00), %g1
40011418: c2 00 61 6c ld [ %g1 + 0x16c ], %g1 ! 40013d6c <_IO_Number_of_drivers>
{
4001141c: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
40011420: 80 a0 40 08 cmp %g1, %o0
40011424: 08 80 00 11 bleu 40011468 <rtems_io_close+0x58>
<== NEVER TAKEN
40011428: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
4001142c: 83 2a 20 01 sll %o0, 1, %g1
40011430: 82 00 40 08 add %g1, %o0, %g1
40011434: 85 28 60 03 sll %g1, 3, %g2
40011438: 03 10 00 57 sethi %hi(0x40015c00), %g1
4001143c: 82 10 61 00 or %g1, 0x100, %g1 ! 40015d00 <_IO_Driver_address_table>
40011440: 82 00 40 02 add %g1, %g2, %g1
40011444: c2 00 60 08 ld [ %g1 + 8 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40011448: 80 a0 60 00 cmp %g1, 0
4001144c: 02 80 00 06 be 40011464 <rtems_io_close+0x54>
40011450: 94 10 00 1a mov %i2, %o2
40011454: 9f c0 40 00 call %g1
40011458: 92 10 00 19 mov %i1, %o1
4001145c: 81 c7 e0 08 ret
40011460: 91 e8 00 08 restore %g0, %o0, %o0
40011464: b0 10 20 00 clr %i0
}
40011468: 81 c7 e0 08 ret
4001146c: 81 e8 00 00 restore
40011470 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
40011470: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
40011474: 03 10 00 4f sethi %hi(0x40013c00), %g1
40011478: c2 00 61 6c ld [ %g1 + 0x16c ], %g1 ! 40013d6c <_IO_Number_of_drivers>
{
4001147c: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
40011480: 80 a0 40 08 cmp %g1, %o0
40011484: 08 80 00 11 bleu 400114c8 <rtems_io_control+0x58>
<== NEVER TAKEN
40011488: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
4001148c: 83 2a 20 01 sll %o0, 1, %g1
40011490: 82 00 40 08 add %g1, %o0, %g1
40011494: 85 28 60 03 sll %g1, 3, %g2
40011498: 03 10 00 57 sethi %hi(0x40015c00), %g1
4001149c: 82 10 61 00 or %g1, 0x100, %g1 ! 40015d00 <_IO_Driver_address_table>
400114a0: 82 00 40 02 add %g1, %g2, %g1
400114a4: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
400114a8: 80 a0 60 00 cmp %g1, 0
400114ac: 02 80 00 06 be 400114c4 <rtems_io_control+0x54>
<== NEVER TAKEN
400114b0: 94 10 00 1a mov %i2, %o2
400114b4: 9f c0 40 00 call %g1
400114b8: 92 10 00 19 mov %i1, %o1
400114bc: 81 c7 e0 08 ret
400114c0: 91 e8 00 08 restore %g0, %o0, %o0
400114c4: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
400114c8: 81 c7 e0 08 ret
<== NOT EXECUTED
400114cc: 81 e8 00 00 restore
<== NOT EXECUTED
400114d0 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
400114d0: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
400114d4: 03 10 00 4f sethi %hi(0x40013c00), %g1
400114d8: c2 00 61 6c ld [ %g1 + 0x16c ], %g1 ! 40013d6c <_IO_Number_of_drivers>
{
400114dc: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
400114e0: 80 a0 40 08 cmp %g1, %o0
400114e4: 08 80 00 10 bleu 40011524 <rtems_io_initialize+0x54>
<== NEVER TAKEN
400114e8: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
400114ec: 83 2a 20 01 sll %o0, 1, %g1
400114f0: 07 10 00 57 sethi %hi(0x40015c00), %g3
400114f4: 82 00 40 08 add %g1, %o0, %g1
400114f8: 86 10 e1 00 or %g3, 0x100, %g3
400114fc: 83 28 60 03 sll %g1, 3, %g1
40011500: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40011504: 80 a0 60 00 cmp %g1, 0
40011508: 02 80 00 06 be 40011520 <rtems_io_initialize+0x50>
4001150c: 94 10 00 1a mov %i2, %o2
40011510: 9f c0 40 00 call %g1
40011514: 92 10 00 19 mov %i1, %o1
40011518: 81 c7 e0 08 ret
4001151c: 91 e8 00 08 restore %g0, %o0, %o0
40011520: b0 10 20 00 clr %i0
}
40011524: 81 c7 e0 08 ret
40011528: 81 e8 00 00 restore
4001152c <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4001152c: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
40011530: 03 10 00 4f sethi %hi(0x40013c00), %g1
40011534: c2 00 61 6c ld [ %g1 + 0x16c ], %g1 ! 40013d6c <_IO_Number_of_drivers>
{
40011538: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4001153c: 80 a0 40 08 cmp %g1, %o0
40011540: 08 80 00 11 bleu 40011584 <rtems_io_open+0x58>
<== NEVER TAKEN
40011544: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
40011548: 83 2a 20 01 sll %o0, 1, %g1
4001154c: 82 00 40 08 add %g1, %o0, %g1
40011550: 85 28 60 03 sll %g1, 3, %g2
40011554: 03 10 00 57 sethi %hi(0x40015c00), %g1
40011558: 82 10 61 00 or %g1, 0x100, %g1 ! 40015d00 <_IO_Driver_address_table>
4001155c: 82 00 40 02 add %g1, %g2, %g1
40011560: c2 00 60 04 ld [ %g1 + 4 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40011564: 80 a0 60 00 cmp %g1, 0
40011568: 02 80 00 06 be 40011580 <rtems_io_open+0x54>
4001156c: 94 10 00 1a mov %i2, %o2
40011570: 9f c0 40 00 call %g1
40011574: 92 10 00 19 mov %i1, %o1
40011578: 81 c7 e0 08 ret
4001157c: 91 e8 00 08 restore %g0, %o0, %o0
40011580: b0 10 20 00 clr %i0
}
40011584: 81 c7 e0 08 ret
40011588: 81 e8 00 00 restore
4001158c <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4001158c: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
40011590: 03 10 00 4f sethi %hi(0x40013c00), %g1
40011594: c2 00 61 6c ld [ %g1 + 0x16c ], %g1 ! 40013d6c <_IO_Number_of_drivers>
{
40011598: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4001159c: 80 a0 40 08 cmp %g1, %o0
400115a0: 08 80 00 11 bleu 400115e4 <rtems_io_read+0x58>
<== NEVER TAKEN
400115a4: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
400115a8: 83 2a 20 01 sll %o0, 1, %g1
400115ac: 82 00 40 08 add %g1, %o0, %g1
400115b0: 85 28 60 03 sll %g1, 3, %g2
400115b4: 03 10 00 57 sethi %hi(0x40015c00), %g1
400115b8: 82 10 61 00 or %g1, 0x100, %g1 ! 40015d00 <_IO_Driver_address_table>
400115bc: 82 00 40 02 add %g1, %g2, %g1
400115c0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
400115c4: 80 a0 60 00 cmp %g1, 0
400115c8: 02 80 00 06 be 400115e0 <rtems_io_read+0x54>
<== NEVER TAKEN
400115cc: 94 10 00 1a mov %i2, %o2
400115d0: 9f c0 40 00 call %g1
400115d4: 92 10 00 19 mov %i1, %o1
400115d8: 81 c7 e0 08 ret
400115dc: 91 e8 00 08 restore %g0, %o0, %o0
400115e0: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
400115e4: 81 c7 e0 08 ret
<== NOT EXECUTED
400115e8: 81 e8 00 00 restore
<== NOT EXECUTED
400073ec <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
)
{
400073ec: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major_limit = _IO_Number_of_drivers;
400073f0: 3b 10 00 4f sethi %hi(0x40013c00), %i5
ISR_lock_Context lock_context;
if ( rtems_interrupt_is_in_progress() )
400073f4: 40 00 06 0e call 40008c2c <_ISR_Is_in_progress>
400073f8: f8 07 61 6c ld [ %i5 + 0x16c ], %i4 ! 40013d6c <_IO_Number_of_drivers>
400073fc: 80 a2 20 00 cmp %o0, 0
40007400: 12 80 00 45 bne 40007514 <rtems_io_register_driver+0x128> <== NEVER TAKEN
40007404: 80 a6 a0 00 cmp %i2, 0
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
40007408: 02 80 00 40 be 40007508 <rtems_io_register_driver+0x11c> <== NEVER TAKEN
4000740c: 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 )
40007410: 02 80 00 3e be 40007508 <rtems_io_register_driver+0x11c> <== NEVER TAKEN
40007414: f8 26 80 00 st %i4, [ %i2 ]
return table->initialization_entry == NULL && table->open_entry == NULL;
40007418: c2 06 40 00 ld [ %i1 ], %g1
4000741c: 80 a0 60 00 cmp %g1, 0
40007420: 22 80 00 37 be,a 400074fc <rtems_io_register_driver+0x110>
40007424: 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 )
40007428: 80 a7 00 18 cmp %i4, %i0
4000742c: 08 80 00 4a bleu 40007554 <rtems_io_register_driver+0x168> <== NEVER TAKEN
40007430: 82 10 20 0a mov 0xa, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007434: 91 d0 20 09 ta 9
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
_IO_Driver_registration_acquire( &lock_context );
if ( major == 0 ) {
40007438: 80 a6 20 00 cmp %i0, 0
4000743c: 12 80 00 39 bne 40007520 <rtems_io_register_driver+0x134> <== NEVER TAKEN
40007440: 85 2e 20 01 sll %i0, 1, %g2
rtems_device_major_number n = _IO_Number_of_drivers;
40007444: fa 07 61 6c ld [ %i5 + 0x16c ], %i5
for ( m = 0; m < n; ++m ) {
40007448: 80 a7 60 00 cmp %i5, 0
4000744c: 02 80 00 4f be 40007588 <rtems_io_register_driver+0x19c> <== NEVER TAKEN
40007450: 07 10 00 57 sethi %hi(0x40015c00), %g3
40007454: 86 10 e1 00 or %g3, 0x100, %g3 ! 40015d00 <_IO_Driver_address_table>
40007458: 10 80 00 05 b 4000746c <rtems_io_register_driver+0x80>
4000745c: 84 10 00 03 mov %g3, %g2
40007460: 80 a7 40 18 cmp %i5, %i0
40007464: 02 80 00 3e be 4000755c <rtems_io_register_driver+0x170> <== NEVER TAKEN
40007468: 84 00 a0 18 add %g2, 0x18, %g2
return table->initialization_entry == NULL && table->open_entry == NULL;
4000746c: c8 00 80 00 ld [ %g2 ], %g4
40007470: 80 a1 20 00 cmp %g4, 0
40007474: 32 bf ff fb bne,a 40007460 <rtems_io_register_driver+0x74>
40007478: b0 06 20 01 inc %i0
4000747c: c8 00 a0 04 ld [ %g2 + 4 ], %g4
40007480: 80 a1 20 00 cmp %g4, 0
40007484: 32 bf ff f7 bne,a 40007460 <rtems_io_register_driver+0x74>
40007488: b0 06 20 01 inc %i0
if ( m != n )
4000748c: 80 a7 40 18 cmp %i5, %i0
40007490: 02 80 00 34 be 40007560 <rtems_io_register_driver+0x174> <== NEVER TAKEN
40007494: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
40007498: 84 5e 20 03 smul %i0, 3, %g2
<== NOT EXECUTED
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
4000749c: c8 06 40 00 ld [ %i1 ], %g4
<== NOT EXECUTED
400074a0: 85 28 a0 03 sll %g2, 3, %g2
<== NOT EXECUTED
400074a4: c8 20 c0 02 st %g4, [ %g3 + %g2 ]
<== NOT EXECUTED
400074a8: 84 00 c0 02 add %g3, %g2, %g2
<== NOT EXECUTED
400074ac: c6 06 60 04 ld [ %i1 + 4 ], %g3
<== NOT EXECUTED
400074b0: c6 20 a0 04 st %g3, [ %g2 + 4 ]
<== NOT EXECUTED
400074b4: c6 06 60 08 ld [ %i1 + 8 ], %g3
<== NOT EXECUTED
400074b8: c6 20 a0 08 st %g3, [ %g2 + 8 ]
<== NOT EXECUTED
400074bc: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
400074c0: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
400074c4: c6 06 60 10 ld [ %i1 + 0x10 ], %g3
<== NOT EXECUTED
400074c8: c6 20 a0 10 st %g3, [ %g2 + 0x10 ]
<== NOT EXECUTED
400074cc: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
<== NOT EXECUTED
400074d0: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400074d4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400074d8: 01 00 00 00 nop
_IO_Driver_registration_release( &lock_context );
if ( _IO_All_drivers_initialized ) {
400074dc: 03 10 00 5c sethi %hi(0x40017000), %g1
400074e0: c4 08 60 f4 ldub [ %g1 + 0xf4 ], %g2 ! 400170f4 <_IO_All_drivers_initialized>
400074e4: 80 a0 a0 00 cmp %g2, 0
400074e8: 02 80 00 09 be 4000750c <rtems_io_register_driver+0x120> <== NEVER TAKEN
400074ec: 82 10 20 00 clr %g1
/* Other drivers have already been initialized, we initialize
* the driver directly.
*/
return rtems_io_initialize( major, 0, NULL );
400074f0: b4 10 20 00 clr %i2
400074f4: 40 00 27 f7 call 400114d0 <rtems_io_initialize>
400074f8: 93 e8 20 00 restore %g0, 0, %o1
return table->initialization_entry == NULL && table->open_entry == NULL;
400074fc: 80 a0 60 00 cmp %g1, 0
40007500: 12 bf ff cb bne 4000742c <rtems_io_register_driver+0x40> <== ALWAYS TAKEN
40007504: 80 a7 00 18 cmp %i4, %i0
return RTEMS_INVALID_ADDRESS;
40007508: 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;
}
}
4000750c: 81 c7 e0 08 ret
<== NOT EXECUTED
40007510: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
return RTEMS_CALLED_FROM_ISR;
40007514: 82 10 20 12 mov 0x12, %g1
<== NOT EXECUTED
}
40007518: 81 c7 e0 08 ret
<== NOT EXECUTED
4000751c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
40007520: 07 10 00 57 sethi %hi(0x40015c00), %g3
<== NOT EXECUTED
40007524: 84 00 80 18 add %g2, %i0, %g2
<== NOT EXECUTED
40007528: 86 10 e1 00 or %g3, 0x100, %g3
<== NOT EXECUTED
4000752c: 89 28 a0 03 sll %g2, 3, %g4
<== NOT EXECUTED
return table->initialization_entry == NULL && table->open_entry == NULL;
40007530: fa 00 c0 04 ld [ %g3 + %g4 ], %i5
<== NOT EXECUTED
40007534: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
40007538: 02 80 00 0e be 40007570 <rtems_io_register_driver+0x184>
<== NOT EXECUTED
4000753c: 88 00 c0 04 add %g3, %g4, %g4
<== NOT EXECUTED
40007540: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007544: 01 00 00 00 nop
<== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
40007548: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
}
4000754c: 81 c7 e0 08 ret
<== NOT EXECUTED
40007550: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
40007554: 81 c7 e0 08 ret
<== NOT EXECUTED
40007558: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
*major = m;
4000755c: fa 26 80 00 st %i5, [ %i2 ]
<== NOT EXECUTED
40007560: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007564: 01 00 00 00 nop
<== NOT EXECUTED
return sc;
40007568: 10 bf ff e9 b 4000750c <rtems_io_register_driver+0x120>
<== NOT EXECUTED
4000756c: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
return table->initialization_entry == NULL && table->open_entry == NULL;
40007570: c8 01 20 04 ld [ %g4 + 4 ], %g4
<== NOT EXECUTED
40007574: 80 a1 20 00 cmp %g4, 0
<== NOT EXECUTED
40007578: 12 bf ff f2 bne 40007540 <rtems_io_register_driver+0x154>
<== NOT EXECUTED
4000757c: 01 00 00 00 nop
<== NOT EXECUTED
*registered_major = major;
40007580: 10 bf ff c7 b 4000749c <rtems_io_register_driver+0xb0>
<== NOT EXECUTED
40007584: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
*major = m;
40007588: 10 bf ff f6 b 40007560 <rtems_io_register_driver+0x174>
<== NOT EXECUTED
4000758c: c0 26 80 00 clr [ %i2 ]
<== NOT EXECUTED
40007590 <rtems_io_unregister_driver>:
#include <string.h>
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
40007590: 9d e3 bf a0 save %sp, -96, %sp
if ( rtems_interrupt_is_in_progress() )
40007594: 40 00 05 a6 call 40008c2c <_ISR_Is_in_progress>
40007598: 01 00 00 00 nop
4000759c: 80 a2 20 00 cmp %o0, 0
400075a0: 12 80 00 17 bne 400075fc <rtems_io_unregister_driver+0x6c> <== NEVER TAKEN
400075a4: 82 10 20 12 mov 0x12, %g1
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
400075a8: 05 10 00 4f sethi %hi(0x40013c00), %g2
400075ac: c4 00 a1 6c ld [ %g2 + 0x16c ], %g2 ! 40013d6c <_IO_Number_of_drivers>
400075b0: 80 a0 80 18 cmp %g2, %i0
400075b4: 08 80 00 12 bleu 400075fc <rtems_io_unregister_driver+0x6c> <== NEVER TAKEN
400075b8: 82 10 20 0d mov 0xd, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400075bc: 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],
400075c0: 07 10 00 57 sethi %hi(0x40015c00), %g3
<== NOT EXECUTED
400075c4: 85 2e 20 01 sll %i0, 1, %g2
<== NOT EXECUTED
400075c8: 86 10 e1 00 or %g3, 0x100, %g3
<== NOT EXECUTED
400075cc: b0 00 80 18 add %g2, %i0, %i0
<== NOT EXECUTED
400075d0: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
memset(
400075d4: c0 26 00 03 clr [ %i0 + %g3 ]
<== NOT EXECUTED
&_IO_Driver_address_table[major],
400075d8: b0 06 00 03 add %i0, %g3, %i0
<== NOT EXECUTED
memset(
400075dc: c0 26 20 04 clr [ %i0 + 4 ]
<== NOT EXECUTED
400075e0: c0 26 20 08 clr [ %i0 + 8 ]
<== NOT EXECUTED
400075e4: c0 26 20 0c clr [ %i0 + 0xc ]
<== NOT EXECUTED
400075e8: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
400075ec: c0 26 20 14 clr [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400075f0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400075f4: 01 00 00 00 nop
0,
sizeof( rtems_driver_address_table )
);
_IO_Driver_registration_release( &lock_context );
return RTEMS_SUCCESSFUL;
400075f8: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
return RTEMS_UNSATISFIED;
}
400075fc: 81 c7 e0 08 ret
40007600: 91 e8 00 01 restore %g0, %g1, %o0
400115ec <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
400115ec: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
400115f0: 03 10 00 4f sethi %hi(0x40013c00), %g1
400115f4: c2 00 61 6c ld [ %g1 + 0x16c ], %g1 ! 40013d6c <_IO_Number_of_drivers>
{
400115f8: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
400115fc: 80 a0 40 08 cmp %g1, %o0
40011600: 08 80 00 11 bleu 40011644 <rtems_io_write+0x58>
<== NEVER TAKEN
40011604: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
40011608: 83 2a 20 01 sll %o0, 1, %g1
4001160c: 82 00 40 08 add %g1, %o0, %g1
40011610: 85 28 60 03 sll %g1, 3, %g2
40011614: 03 10 00 57 sethi %hi(0x40015c00), %g1
40011618: 82 10 61 00 or %g1, 0x100, %g1 ! 40015d00 <_IO_Driver_address_table>
4001161c: 82 00 40 02 add %g1, %g2, %g1
40011620: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
40011624: 80 a0 60 00 cmp %g1, 0
40011628: 02 80 00 06 be 40011640 <rtems_io_write+0x54>
<== NEVER TAKEN
4001162c: 94 10 00 1a mov %i2, %o2
40011630: 9f c0 40 00 call %g1
40011634: 92 10 00 19 mov %i1, %o1
40011638: 81 c7 e0 08 ret
4001163c: 91 e8 00 08 restore %g0, %o0, %o0
40011640: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
40011644: 81 c7 e0 08 ret
<== NOT EXECUTED
40011648: 81 e8 00 00 restore
<== NOT EXECUTED
4001a3ac <rtems_panic>:
#include <rtems/bspIo.h>
#include <stdarg.h>
void rtems_panic( const char *fmt, ... )
{
4001a3ac: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
va_list ap;
va_start( ap, fmt );
4001a3b0: 82 07 a0 48 add %fp, 0x48, %g1
<== NOT EXECUTED
4001a3b4: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
<== NOT EXECUTED
vprintk( fmt, ap );
4001a3b8: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
va_start( ap, fmt );
4001a3bc: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
<== NOT EXECUTED
vprintk( fmt, ap );
4001a3c0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
va_start( ap, fmt );
4001a3c4: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
<== NOT EXECUTED
4001a3c8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
<== NOT EXECUTED
4001a3cc: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
<== NOT EXECUTED
vprintk( fmt, ap );
4001a3d0: 7f ff d2 8a call 4000edf8 <vprintk>
<== NOT EXECUTED
4001a3d4: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
va_end( ap);
_Terminate( RTEMS_FATAL_SOURCE_PANIC, (Internal_errors_t) fmt );
4001a3d8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4001a3dc: 40 00 02 30 call 4001ac9c <_Terminate>
<== NOT EXECUTED
4001a3e0: 90 10 20 0b mov 0xb, %o0
<== NOT EXECUTED
4001a3e4: 01 00 00 00 nop
<== NOT EXECUTED
40006d98 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
40006d98: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = NULL;
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
40006d9c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
uintptr_t excess = value % alignment;
40006da0: 81 80 20 00 wr %g0, %y
40006da4: 01 00 00 00 nop
40006da8: 01 00 00 00 nop
40006dac: 01 00 00 00 nop
40006db0: b6 76 40 01 udiv %i1, %g1, %i3
40006db4: b6 5e c0 01 smul %i3, %g1, %i3
if (excess > 0) {
40006db8: b6 a6 40 1b subcc %i1, %i3, %i3
40006dbc: 22 80 00 3c be,a 40006eac <rtems_rbheap_allocate+0x114>
40006dc0: b6 10 00 19 mov %i1, %i3
value += alignment - excess;
40006dc4: 82 00 40 19 add %g1, %i1, %g1
40006dc8: b6 20 40 1b sub %g1, %i3, %i3
40006dcc: 80 a6 c0 19 cmp %i3, %i1
40006dd0: 82 60 3f ff subx %g0, -1, %g1
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
40006dd4: 80 a6 60 00 cmp %i1, 0
40006dd8: 02 80 00 33 be 40006ea4 <rtems_rbheap_allocate+0x10c>
40006ddc: 80 88 60 ff btst 0xff, %g1
40006de0: 02 80 00 31 be 40006ea4 <rtems_rbheap_allocate+0x10c>
<== NEVER TAKEN
40006de4: 84 06 20 04 add %i0, 4, %g2
return _Chain_Immutable_head( the_chain )->next;
40006de8: fa 06 00 00 ld [ %i0 ], %i5
while (current != tail && big_enough == NULL) {
40006dec: 80 a7 40 02 cmp %i5, %g2
40006df0: 02 80 00 2d be 40006ea4 <rtems_rbheap_allocate+0x10c>
40006df4: 01 00 00 00 nop
if (free_chunk->size >= size) {
40006df8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40006dfc: 80 a6 c0 01 cmp %i3, %g1
40006e00: 38 80 00 26 bgu,a 40006e98 <rtems_rbheap_allocate+0x100>
40006e04: fa 07 40 00 ld [ %i5 ], %i5
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
40006e08: 80 a7 60 00 cmp %i5, 0
40006e0c: 02 80 00 26 be 40006ea4 <rtems_rbheap_allocate+0x10c>
<== NEVER TAKEN
40006e10: 80 a0 40 1b cmp %g1, %i3
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
40006e14: 08 80 00 28 bleu 40006eb4 <rtems_rbheap_allocate+0x11c>
40006e18: b8 10 00 01 mov %g1, %i4
return _Chain_Immutable_head( the_chain )->next;
40006e1c: f2 06 20 0c ld [ %i0 + 0xc ], %i1
return &the_chain->Tail.Node;
40006e20: 82 06 20 10 add %i0, 0x10, %g1
if ( !_Chain_Is_empty(the_chain))
40006e24: 80 a6 40 01 cmp %i1, %g1
40006e28: 12 80 00 2b bne 40006ed4 <rtems_rbheap_allocate+0x13c>
40006e2c: a0 06 20 0c add %i0, 0xc, %l0
(*control->extend_descriptors)(control);
40006e30: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40006e34: 9f c0 40 00 call %g1
40006e38: 90 10 00 18 mov %i0, %o0
return _Chain_Immutable_head( the_chain )->next;
40006e3c: f4 06 20 0c ld [ %i0 + 0xc ], %i2
if ( !_Chain_Is_empty(the_chain))
40006e40: 80 a6 40 1a cmp %i1, %i2
40006e44: 02 80 00 18 be 40006ea4 <rtems_rbheap_allocate+0x10c>
40006e48: 01 00 00 00 nop
new_first = old_first->next;
40006e4c: c2 06 80 00 ld [ %i2 ], %g1
head->next = new_first;
40006e50: c2 26 20 0c st %g1, [ %i0 + 0xc ]
new_first->previous = head;
40006e54: e0 20 60 04 st %l0, [ %g1 + 4 ]
rtems_rbheap_chunk *new_chunk = get_chunk(control);
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
40006e58: 82 27 00 1b sub %i4, %i3, %g1
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
40006e5c: c4 07 60 18 ld [ %i5 + 0x18 ], %g2
free_chunk->size = new_free_size;
40006e60: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
new_chunk->begin = free_chunk->begin + new_free_size;
40006e64: 82 00 80 01 add %g2, %g1, %g1
new_chunk->size = aligned_size;
40006e68: f6 26 a0 1c st %i3, [ %i2 + 0x1c ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40006e6c: 96 10 20 01 mov 1, %o3
new_chunk->begin = free_chunk->begin + new_free_size;
40006e70: c2 26 a0 18 st %g1, [ %i2 + 0x18 ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40006e74: 92 06 a0 08 add %i2, 8, %o1
node->next = NULL;
40006e78: c0 26 80 00 clr [ %i2 ]
40006e7c: 90 06 20 18 add %i0, 0x18, %o0
40006e80: 15 10 00 1b sethi %hi(0x40006c00), %o2
40006e84: 40 00 00 98 call 400070e4 <rtems_rbtree_insert>
40006e88: 94 12 a0 34 or %o2, 0x34, %o2 ! 40006c34 <chunk_compare>
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
40006e8c: f0 06 a0 18 ld [ %i2 + 0x18 ], %i0
}
}
}
return ptr;
}
40006e90: 81 c7 e0 08 ret
40006e94: 81 e8 00 00 restore
while (current != tail && big_enough == NULL) {
40006e98: 80 a0 80 1d cmp %g2, %i5
40006e9c: 32 bf ff d8 bne,a 40006dfc <rtems_rbheap_allocate+0x64> <== NEVER TAKEN
40006ea0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
void *ptr = NULL;
40006ea4: 81 c7 e0 08 ret
40006ea8: 91 e8 20 00 restore %g0, 0, %o0
if (excess > 0) {
40006eac: 10 bf ff ca b 40006dd4 <rtems_rbheap_allocate+0x3c>
40006eb0: 82 10 20 01 mov 1, %g1
next = the_node->next;
40006eb4: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40006eb8: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
40006ebc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40006ec0: c4 20 40 00 st %g2, [ %g1 ]
node->next = NULL;
40006ec4: c0 27 40 00 clr [ %i5 ]
ptr = (void *) free_chunk->begin;
40006ec8: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
return ptr;
40006ecc: 81 c7 e0 08 ret
40006ed0: 81 e8 00 00 restore
new_first = old_first->next;
40006ed4: c2 06 40 00 ld [ %i1 ], %g1
head->next = new_first;
40006ed8: c2 26 20 0c st %g1, [ %i0 + 0xc ]
new_first->previous = head;
40006edc: b4 10 00 19 mov %i1, %i2
40006ee0: 10 bf ff de b 40006e58 <rtems_rbheap_allocate+0xc0>
40006ee4: e0 20 60 04 st %l0, [ %g1 + 4 ]
40006c4c <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
40006c4c: 9d e3 bf a0 save %sp, -96, %sp
/*
* Ensure that the alignment is at least two, so that we can keep
* chunk_compare() that simple.
*/
alignment = alignment < 2 ? 2 : alignment;
40006c50: 80 a6 e0 02 cmp %i3, 2
40006c54: 1a 80 00 03 bcc 40006c60 <rtems_rbheap_initialize+0x14> <== ALWAYS TAKEN
40006c58: b4 06 40 1a add %i1, %i2, %i2
40006c5c: b6 10 20 02 mov 2, %i3
<== NOT EXECUTED
uintptr_t excess = value % alignment;
40006c60: 81 80 20 00 wr %g0, %y
40006c64: 01 00 00 00 nop
40006c68: 01 00 00 00 nop
40006c6c: 01 00 00 00 nop
40006c70: 82 76 40 1b udiv %i1, %i3, %g1
40006c74: 82 58 40 1b smul %g1, %i3, %g1
if (excess > 0) {
40006c78: 82 a6 40 01 subcc %i1, %g1, %g1
40006c7c: 02 80 00 39 be 40006d60 <rtems_rbheap_initialize+0x114>
40006c80: 80 a6 40 1a cmp %i1, %i2
value += alignment - excess;
40006c84: a0 06 40 1b add %i1, %i3, %l0
40006c88: a0 24 00 01 sub %l0, %g1, %l0
40006c8c: 80 a4 00 19 cmp %l0, %i1
40006c90: 82 60 3f ff subx %g0, -1, %g1
aligned_begin = align_up(alignment, begin);
aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40006c94: 80 a6 40 1a cmp %i1, %i2
uintptr_t excess = value % alignment;
40006c98: 81 80 20 00 wr %g0, %y
40006c9c: 01 00 00 00 nop
40006ca0: 01 00 00 00 nop
40006ca4: 01 00 00 00 nop
40006ca8: 84 76 80 1b udiv %i2, %i3, %g2
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40006cac: 86 40 20 00 addx %g0, 0, %g3
40006cb0: 80 88 c0 01 btst %g3, %g1
40006cb4: 02 80 00 36 be 40006d8c <rtems_rbheap_initialize+0x140>
40006cb8: b4 58 80 1b smul %g2, %i3, %i2
40006cbc: 80 a4 00 1a cmp %l0, %i2
40006cc0: 1a 80 00 33 bcc 40006d8c <rtems_rbheap_initialize+0x140>
40006cc4: 82 06 20 04 add %i0, 4, %g1
return &the_chain->Tail.Node;
40006cc8: b2 06 20 10 add %i0, 0x10, %i1
head->next = tail;
40006ccc: c2 26 00 00 st %g1, [ %i0 ]
return &the_chain->Head.Node;
40006cd0: a2 06 20 0c add %i0, 0xc, %l1
head->previous = NULL;
40006cd4: c0 26 20 04 clr [ %i0 + 4 ]
(*control->extend_descriptors)(control);
40006cd8: 90 10 00 18 mov %i0, %o0
tail->previous = head;
40006cdc: f0 26 20 08 st %i0, [ %i0 + 8 ]
head->next = tail;
40006ce0: f2 26 20 0c st %i1, [ %i0 + 0xc ]
head->previous = NULL;
40006ce4: c0 26 20 10 clr [ %i0 + 0x10 ]
tail->previous = head;
40006ce8: e2 26 20 14 st %l1, [ %i0 + 0x14 ]
RB_INIT( the_rbtree );
40006cec: c0 26 20 18 clr [ %i0 + 0x18 ]
rtems_rbheap_chunk *first = NULL;
rtems_chain_initialize_empty(free_chain);
rtems_chain_initialize_empty(&control->spare_descriptor_chain);
rtems_rbtree_initialize_empty(chunk_tree);
control->alignment = alignment;
40006cf0: f6 26 20 1c st %i3, [ %i0 + 0x1c ]
control->handler_arg = handler_arg;
40006cf4: fa 26 20 24 st %i5, [ %i0 + 0x24 ]
(*control->extend_descriptors)(control);
40006cf8: 9f c7 00 00 call %i4
40006cfc: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
return _Chain_Immutable_head( the_chain )->next;
40006d00: c4 06 20 0c ld [ %i0 + 0xc ], %g2
if ( !_Chain_Is_empty(the_chain))
40006d04: 80 a0 80 19 cmp %g2, %i1
40006d08: 02 80 00 14 be 40006d58 <rtems_rbheap_initialize+0x10c>
40006d0c: 82 10 20 1a mov 0x1a, %g1
new_first = old_first->next;
40006d10: c2 00 80 00 ld [ %g2 ], %g1
head->next = new_first;
40006d14: c2 26 20 0c st %g1, [ %i0 + 0xc ]
control->extend_descriptors = extend_descriptors;
first = get_chunk(control);
if (first != NULL) {
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
40006d18: b4 26 80 10 sub %i2, %l0, %i2
new_first->previous = head;
40006d1c: e2 20 60 04 st %l1, [ %g1 + 4 ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40006d20: 96 10 20 01 mov 1, %o3
first->begin = aligned_begin;
40006d24: e0 20 a0 18 st %l0, [ %g2 + 0x18 ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40006d28: 15 10 00 1b sethi %hi(0x40006c00), %o2
first->size = aligned_end - aligned_begin;
40006d2c: f4 20 a0 1c st %i2, [ %g2 + 0x1c ]
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
40006d30: 94 12 a0 34 or %o2, 0x34, %o2
the_node->previous = after_node;
40006d34: f0 20 a0 04 st %i0, [ %g2 + 4 ]
40006d38: 92 00 a0 08 add %g2, 8, %o1
before_node = after_node->next;
40006d3c: c2 06 00 00 ld [ %i0 ], %g1
after_node->next = the_node;
40006d40: c4 26 00 00 st %g2, [ %i0 ]
40006d44: 90 06 20 18 add %i0, 0x18, %o0
the_node->next = before_node;
40006d48: c2 20 80 00 st %g1, [ %g2 ]
40006d4c: 40 00 00 e6 call 400070e4 <rtems_rbtree_insert>
40006d50: c4 20 60 04 st %g2, [ %g1 + 4 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
40006d54: 82 10 20 00 clr %g1
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
40006d58: 81 c7 e0 08 ret
40006d5c: 91 e8 00 01 restore %g0, %g1, %o0
if (excess > 0) {
40006d60: 82 10 20 01 mov 1, %g1
uintptr_t excess = value % alignment;
40006d64: 81 80 20 00 wr %g0, %y
40006d68: 01 00 00 00 nop
40006d6c: 01 00 00 00 nop
40006d70: 01 00 00 00 nop
40006d74: 84 76 80 1b udiv %i2, %i3, %g2
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40006d78: 86 40 20 00 addx %g0, 0, %g3
if (excess > 0) {
40006d7c: a0 10 00 19 mov %i1, %l0
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
40006d80: 80 88 c0 01 btst %g3, %g1
40006d84: 12 bf ff ce bne 40006cbc <rtems_rbheap_initialize+0x70>
40006d88: b4 58 80 1b smul %g2, %i3, %i2
sc = RTEMS_INVALID_ADDRESS;
40006d8c: 82 10 20 09 mov 9, %g1
}
40006d90: 81 c7 e0 08 ret
40006d94: 91 e8 00 01 restore %g0, %g1, %o0
40007084 <rtems_rbtree_find>:
const rtems_rbtree_control *the_rbtree,
const rtems_rbtree_node *the_node,
rtems_rbtree_compare compare,
bool is_unique
)
{
40007084: 9d e3 bf a0 save %sp, -96, %sp
return RB_ROOT( the_rbtree );
40007088: fa 06 00 00 ld [ %i0 ], %i5
rtems_rbtree_node *iter_node = rtems_rbtree_root( the_rbtree );
rtems_rbtree_node *found = NULL;
while ( iter_node != NULL ) {
4000708c: 80 a7 60 00 cmp %i5, 0
40007090: 02 80 00 0f be 400070cc <rtems_rbtree_find+0x48>
<== NEVER TAKEN
40007094: b0 10 20 00 clr %i0
rtems_rbtree_compare_result compare_result =
40007098: 92 10 00 1d mov %i5, %o1
4000709c: 9f c6 80 00 call %i2
400070a0: 90 10 00 19 mov %i1, %o0
( *compare )( the_node, iter_node );
if ( rtems_rbtree_is_equal( compare_result ) ) {
400070a4: 80 a2 20 00 cmp %o0, 0
400070a8: 12 80 00 0b bne 400070d4 <rtems_rbtree_find+0x50>
400070ac: 01 00 00 00 nop
found = iter_node;
if ( is_unique )
400070b0: 80 a6 e0 00 cmp %i3, 0
400070b4: 12 80 00 06 bne 400070cc <rtems_rbtree_find+0x48>
<== ALWAYS TAKEN
400070b8: b0 10 00 1d mov %i5, %i0
400070bc: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
while ( iter_node != NULL ) {
400070c0: 80 a7 60 00 cmp %i5, 0
400070c4: 12 bf ff f6 bne 4000709c <rtems_rbtree_find+0x18>
400070c8: 92 10 00 1d mov %i5, %o1
400070cc: 81 c7 e0 08 ret
400070d0: 81 e8 00 00 restore
break;
}
if ( rtems_rbtree_is_greater( compare_result ) ) {
400070d4: 24 bf ff fb ble,a 400070c0 <rtems_rbtree_find+0x3c>
400070d8: fa 07 40 00 ld [ %i5 ], %i5
400070dc: 10 bf ff f9 b 400070c0 <rtems_rbtree_find+0x3c>
400070e0: fa 07 60 04 ld [ %i5 + 4 ], %i5
400070e4 <rtems_rbtree_insert>:
rtems_rbtree_control *the_rbtree,
rtems_rbtree_node *the_node,
rtems_rbtree_compare compare,
bool is_unique
)
{
400070e4: 9d e3 bf a0 save %sp, -96, %sp
return &RB_ROOT( the_rbtree );
400070e8: 82 10 00 18 mov %i0, %g1
rtems_rbtree_node **which = _RBTree_Root_reference( the_rbtree );
rtems_rbtree_node *parent = NULL;
while ( *which != NULL ) {
400070ec: fa 00 40 00 ld [ %g1 ], %i5
rtems_rbtree_node *parent = NULL;
400070f0: 84 10 20 00 clr %g2
rtems_rbtree_compare_result compare_result;
parent = *which;
compare_result = ( *compare )( the_node, parent );
400070f4: 92 10 00 1d mov %i5, %o1
while ( *which != NULL ) {
400070f8: 80 a7 60 00 cmp %i5, 0
400070fc: 02 80 00 12 be 40007144 <rtems_rbtree_insert+0x60>
40007100: 90 10 00 19 mov %i1, %o0
compare_result = ( *compare )( the_node, parent );
40007104: 9f c6 80 00 call %i2
40007108: 01 00 00 00 nop
if ( is_unique && rtems_rbtree_is_equal( compare_result ) ) {
4000710c: 80 a2 20 00 cmp %o0, 0
40007110: 12 80 00 04 bne 40007120 <rtems_rbtree_insert+0x3c>
<== ALWAYS TAKEN
40007114: 80 a6 e0 00 cmp %i3, 0
40007118: 12 80 00 14 bne 40007168 <rtems_rbtree_insert+0x84>
<== NOT EXECUTED
4000711c: 01 00 00 00 nop
<== NOT EXECUTED
return parent;
}
if ( rtems_rbtree_is_lesser( compare_result ) ) {
40007120: 80 a2 20 00 cmp %o0, 0
40007124: 06 80 00 13 bl 40007170 <rtems_rbtree_insert+0x8c>
40007128: 82 07 60 04 add %i5, 4, %g1
{
4000712c: 84 10 00 1d mov %i5, %g2
while ( *which != NULL ) {
40007130: fa 00 40 00 ld [ %g1 ], %i5
compare_result = ( *compare )( the_node, parent );
40007134: 92 10 00 1d mov %i5, %o1
while ( *which != NULL ) {
40007138: 80 a7 60 00 cmp %i5, 0
4000713c: 12 bf ff f2 bne 40007104 <rtems_rbtree_insert+0x20>
40007140: 90 10 00 19 mov %i1, %o0
RB_SET( child, parent, Node );
40007144: c4 26 60 08 st %g2, [ %i1 + 8 ]
40007148: 84 10 20 01 mov 1, %g2
4000714c: c0 26 60 04 clr [ %i1 + 4 ]
}
}
_RBTree_Initialize_node( the_node );
_RBTree_Add_child( the_node, parent, which );
_RBTree_Insert_color( the_rbtree, the_node );
40007150: 92 10 00 19 mov %i1, %o1
40007154: c0 26 40 00 clr [ %i1 ]
40007158: 90 10 00 18 mov %i0, %o0
4000715c: c4 26 60 0c st %g2, [ %i1 + 0xc ]
40007160: 40 00 0a 84 call 40009b70 <_RBTree_Insert_color>
40007164: f2 20 40 00 st %i1, [ %g1 ]
return NULL;
}
40007168: 81 c7 e0 08 ret
4000716c: 91 e8 00 1d restore %g0, %i5, %o0
return &RB_LEFT( the_node, Node );
40007170: 82 10 00 1d mov %i5, %g1
{
40007174: 10 bf ff ef b 40007130 <rtems_rbtree_insert+0x4c>
40007178: 84 10 00 1d mov %i5, %g2
400113fc <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
400113fc: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
40011400: 90 10 20 05 mov 5, %o0
40011404: 7f ff da c9 call 40007f28 <_Terminate>
40011408: 92 10 00 18 mov %i0, %o1
4001140c: 01 00 00 00 nop
<== NOT EXECUTED
4000ad98 <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
)
{
4000ad98: 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 ) {
4000ad9c: 80 a6 a0 01 cmp %i2, 1
4000ada0: 08 80 00 28 bleu 4000ae40 <rtems_timecounter_simple_install+0xa8> <== NEVER TAKEN
4000ada4: b8 10 00 18 mov %i0, %i4
4000ada8: 82 10 20 1f mov 0x1f, %g1
break;
}
power_of_two *= 2;
4000adac: 10 80 00 05 b 4000adc0 <rtems_timecounter_simple_install+0x28>
4000adb0: 90 10 20 02 mov 2, %o0
for ( i = 0; i < 32; ++i ) {
4000adb4: 82 80 7f ff addcc %g1, -1, %g1
4000adb8: 02 80 00 1c be 4000ae28 <rtems_timecounter_simple_install+0x90> <== NEVER TAKEN
4000adbc: 90 10 00 02 mov %g2, %o0
if ( power_of_two >= counter_ticks_per_clock_tick ) {
4000adc0: 80 a6 80 08 cmp %i2, %o0
4000adc4: 18 bf ff fc bgu 4000adb4 <rtems_timecounter_simple_install+0x1c>
4000adc8: 85 2a 20 01 sll %o0, 1, %g2
4000adcc: 21 20 00 00 sethi %hi(0x80000000), %l0
4000add0: ba 00 bf ff add %g2, -1, %i5
4000add4: 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;
4000add8: 94 10 20 00 clr %o2
4000addc: 96 10 00 1a mov %i2, %o3
4000ade0: 40 00 22 22 call 40013668 <__udivdi3>
4000ade4: 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 );
4000ade8: 82 5e 40 08 smul %i1, %o0, %g1
4000adec: 86 56 40 09 umul %i1, %o1, %g3
4000adf0: 85 40 00 00 rd %y, %g2
tc->scaler = scaler;
4000adf4: d0 27 20 30 st %o0, [ %i4 + 0x30 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
4000adf8: 84 00 40 02 add %g1, %g2, %g2
tc->scaler = scaler;
4000adfc: d2 27 20 34 st %o1, [ %i4 + 0x34 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
4000ae00: 82 10 20 64 mov 0x64, %g1
tc->real_interval = counter_ticks_per_clock_tick;
4000ae04: f4 27 20 38 st %i2, [ %i4 + 0x38 ]
tc->binary_interval = ( mask + 1 ) / 2;
4000ae08: e0 27 20 3c st %l0, [ %i4 + 0x3c ]
tc->tc.tc_get_timecount = get_timecount;
4000ae0c: f6 27 00 00 st %i3, [ %i4 ]
tc->tc.tc_counter_mask = mask;
4000ae10: fa 27 20 08 st %i5, [ %i4 + 8 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
4000ae14: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
4000ae18: c0 27 20 10 clr [ %i4 + 0x10 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
4000ae1c: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
_Timecounter_Install( &tc->tc );
4000ae20: 40 00 06 e9 call 4000c9c4 <_Timecounter_Install>
4000ae24: 91 e8 00 1c restore %g0, %i4, %o0
4000ae28: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
4000ae2c: 21 1f ff ff sethi %hi(0x7ffffc00), %l0
<== NOT EXECUTED
4000ae30: ba 00 bf ff add %g2, -1, %i5
<== NOT EXECUTED
4000ae34: a0 14 23 ff or %l0, 0x3ff, %l0
<== NOT EXECUTED
4000ae38: 10 bf ff e8 b 4000add8 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
4000ae3c: a0 0a 00 10 and %o0, %l0, %l0
<== NOT EXECUTED
if ( power_of_two >= counter_ticks_per_clock_tick ) {
4000ae40: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
4000ae44: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
4000ae48: 10 bf ff e4 b 4000add8 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
4000ae4c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED