40007054 <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
40007054: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
40007058: 03 10 00 6b sethi %hi(0x4001ac00), %g1
4000705c: 84 10 20 01 mov 1, %g2
40007060: c4 28 61 b8 stb %g2, [ %g1 + 0x1b8 ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40007064: 03 10 00 5c sethi %hi(0x40017000), %g1
40007068: f8 00 62 e4 ld [ %g1 + 0x2e4 ], %i4 ! 400172e4 <_IO_Number_of_drivers>
4000706c: 80 a7 20 00 cmp %i4, 0
40007070: 02 80 00 0a be 40007098 <_IO_Initialize_all_drivers+0x44> <== NEVER TAKEN
40007074: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
40007078: 90 10 00 1d mov %i5, %o0
4000707c: 94 10 20 00 clr %o2
40007080: 40 00 1d 4f call 4000e5bc <rtems_io_initialize>
40007084: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
40007088: ba 07 60 01 inc %i5
4000708c: 80 a7 40 1c cmp %i5, %i4
40007090: 12 bf ff fb bne 4000707c <_IO_Initialize_all_drivers+0x28>
40007094: 90 10 00 1d mov %i5, %o0
}
40007098: 81 c7 e0 08 ret
4000709c: 81 e8 00 00 restore
40017950 <_Objects_Information_table>:
40017950: 00 00 00 00 40 01 a7 d4 40 01 a7 a8 40 01 a7 74 ....@...@...@..t
40017960: 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 00 00 00 00 _Allocator......
40017970: 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 00 00 00 00 (fmt null)......
40017980: 28 6e 75 6c 6c 29 00 (null).
40008b70 <rtems_chain_extract>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008b70: 91 d0 20 09 ta 9
<== NOT EXECUTED
next = the_node->next;
40008b74: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
40008b78: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
next->previous = previous;
40008b7c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
previous->next = next;
40008b80: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008b84: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008b88: 01 00 00 00 nop
rtems_interrupt_lock_context lock_context;
chain_acquire( &lock_context );
_Chain_Extract_unprotected( node );
chain_release( &lock_context );
}
40008b8c: 81 c3 e0 08 retl
40008b90: 01 00 00 00 nop
40008b94 <rtems_chain_insert>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008b94: 91 d0 20 09 ta 9
<== NOT EXECUTED
the_node->previous = after_node;
40008b98: d0 22 60 04 st %o0, [ %o1 + 4 ]
<== NOT EXECUTED
before_node = after_node->next;
40008b9c: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
after_node->next = the_node;
40008ba0: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
the_node->next = before_node;
40008ba4: c4 22 40 00 st %g2, [ %o1 ]
<== NOT EXECUTED
before_node->previous = the_node;
40008ba8: d2 20 a0 04 st %o1, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008bac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008bb0: 01 00 00 00 nop
rtems_interrupt_lock_context lock_context;
chain_acquire( &lock_context );
_Chain_Insert_unprotected( after_node, node );
chain_release( &lock_context );
}
40008bb4: 81 c3 e0 08 retl
40008bb8: 01 00 00 00 nop
40008bbc <rtems_chain_prepend>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008bbc: 91 d0 20 09 ta 9
<== NOT EXECUTED
the_node->previous = after_node;
40008bc0: d0 22 60 04 st %o0, [ %o1 + 4 ]
<== NOT EXECUTED
before_node = after_node->next;
40008bc4: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
after_node->next = the_node;
40008bc8: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
the_node->next = before_node;
40008bcc: c4 22 40 00 st %g2, [ %o1 ]
<== NOT EXECUTED
before_node->previous = the_node;
40008bd0: d2 20 a0 04 st %o1, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008bd4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008bd8: 01 00 00 00 nop
rtems_interrupt_lock_context lock_context;
chain_acquire( &lock_context );
_Chain_Prepend_unprotected( chain, node );
chain_release( &lock_context );
}
40008bdc: 81 c3 e0 08 retl
40008be0: 01 00 00 00 nop
40008a80 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
40008a80: 9d e3 bf a0 save %sp, -96, %sp
Extension_Control *the_extension;
if ( !id )
40008a84: 80 a6 a0 00 cmp %i2, 0
40008a88: 02 80 00 1b be 40008af4 <rtems_extension_create+0x74>
<== NEVER TAKEN
40008a8c: 80 a6 20 00 cmp %i0, 0
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
40008a90: 02 80 00 17 be 40008aec <rtems_extension_create+0x6c>
<== NEVER TAKEN
40008a94: 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 );
40008a98: 39 10 00 67 sethi %hi(0x40019c00), %i4
40008a9c: 40 00 08 8f call 4000acd8 <_Objects_Allocate>
40008aa0: 90 17 20 14 or %i4, 0x14, %o0 ! 40019c14 <_Extension_Information>
return RTEMS_INVALID_NAME;
the_extension = _Extension_Allocate();
if ( !the_extension ) {
40008aa4: ba 92 20 00 orcc %o0, 0, %i5
40008aa8: 02 80 00 16 be 40008b00 <rtems_extension_create+0x80>
<== NEVER TAKEN
40008aac: 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;
40008ab0: 92 10 00 19 mov %i1, %o1
40008ab4: 40 00 23 c0 call 400119b4 <memcpy>
40008ab8: 90 07 60 24 add %i5, 0x24, %o0
_User_extensions_Add_set( extension );
40008abc: 40 00 17 1d call 4000e730 <_User_extensions_Add_set>
40008ac0: 90 07 60 10 add %i5, 0x10, %o0
information->local_table[ index ] = the_object;
40008ac4: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
the_object->name = name;
40008ac8: f0 27 60 0c st %i0, [ %i5 + 0xc ]
information->local_table[ index ] = the_object;
40008acc: b8 17 20 14 or %i4, 0x14, %i4
40008ad0: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
40008ad4: c4 07 60 08 ld [ %i5 + 8 ], %g2
40008ad8: 83 28 60 02 sll %g1, 2, %g1
40008adc: fa 20 c0 01 st %i5, [ %g3 + %g1 ]
_RTEMS_Unlock_allocator();
40008ae0: 40 00 00 68 call 40008c80 <_RTEMS_Unlock_allocator>
40008ae4: c4 26 80 00 st %g2, [ %i2 ]
(Objects_Name) name
);
*id = the_extension->Object.id;
_Objects_Allocator_unlock();
return RTEMS_SUCCESSFUL;
40008ae8: 82 10 20 00 clr %g1
}
40008aec: 81 c7 e0 08 ret
40008af0: 91 e8 00 01 restore %g0, %g1, %o0
return RTEMS_INVALID_ADDRESS;
40008af4: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
}
40008af8: 81 c7 e0 08 ret
<== NOT EXECUTED
40008afc: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
40008b00: 40 00 00 60 call 40008c80 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40008b04: 01 00 00 00 nop
<== NOT EXECUTED
return RTEMS_TOO_MANY;
40008b08: 10 bf ff f9 b 40008aec <rtems_extension_create+0x6c>
<== NOT EXECUTED
40008b0c: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
400070ac <rtems_extension_delete>:
#include <rtems/score/userextimpl.h>
rtems_status_code rtems_extension_delete(
rtems_id id
)
{
400070ac: 9d e3 bf a0 save %sp, -96, %sp
_RTEMS_Lock_allocator();
400070b0: 40 00 00 6d call 40007264 <_RTEMS_Lock_allocator>
400070b4: 39 10 00 5c sethi %hi(0x40017000), %i4
_Objects_Free( &_Extension_Information, &the_extension->Object );
}
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Get( Objects_Id id )
{
return (Extension_Control *)
400070b8: 90 10 00 18 mov %i0, %o0
_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;
400070bc: b0 10 20 04 mov 4, %i0
400070c0: 40 00 09 07 call 400094dc <_Objects_Get_no_protection>
400070c4: 92 17 23 b8 or %i4, 0x3b8, %o1
if ( the_extension != NULL ) {
400070c8: 80 a2 20 00 cmp %o0, 0
400070cc: 02 80 00 0b be 400070f8 <rtems_extension_delete+0x4c>
<== NEVER TAKEN
400070d0: ba 10 00 08 mov %o0, %i5
_Objects_Close( &_Extension_Information, &the_extension->Object );
400070d4: 92 10 00 08 mov %o0, %o1
400070d8: 40 00 07 f1 call 4000909c <_Objects_Close>
400070dc: 90 17 23 b8 or %i4, 0x3b8, %o0
_User_extensions_Remove_set( &the_extension->Extension );
400070e0: 40 00 15 36 call 4000c5b8 <_User_extensions_Remove_set>
400070e4: 90 07 60 10 add %i5, 0x10, %o0
_Objects_Free( &_Extension_Information, &the_extension->Object );
400070e8: 92 10 00 1d mov %i5, %o1
400070ec: 90 17 23 b8 or %i4, 0x3b8, %o0
400070f0: 40 00 08 b7 call 400093cc <_Objects_Free>
400070f4: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
400070f8: 40 00 00 60 call 40007278 <_RTEMS_Unlock_allocator>
400070fc: 01 00 00 00 nop
}
_Objects_Allocator_unlock();
return status;
}
40007100: 81 c7 e0 08 ret
40007104: 81 e8 00 00 restore
40007034 <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
40007034: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
40007038: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
4000703c: 40 00 02 46 call 40007954 <_Terminate>
<== NOT EXECUTED
40007040: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40007044: 01 00 00 00 nop
<== NOT EXECUTED
400064e4 <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 ) ) {
400064e4: 80 a2 20 0c cmp %o0, 0xc
<== NOT EXECUTED
400064e8: 18 80 00 06 bgu 40006500 <rtems_fatal_source_text+0x1c>
<== NOT EXECUTED
400064ec: 03 10 00 43 sethi %hi(0x40010c00), %g1
<== NOT EXECUTED
text = fatal_source_text[ i ];
400064f0: 91 2a 20 02 sll %o0, 2, %o0
<== NOT EXECUTED
400064f4: 82 10 63 c0 or %g1, 0x3c0, %g1
<== NOT EXECUTED
400064f8: 81 c3 e0 08 retl
<== NOT EXECUTED
400064fc: d0 00 40 08 ld [ %g1 + %o0 ], %o0
<== NOT EXECUTED
const char *text = "?";
40006500: 11 10 00 42 sethi %hi(0x40010800), %o0
<== NOT EXECUTED
}
return text;
}
40006504: 81 c3 e0 08 retl
<== NOT EXECUTED
40006508: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40010af0 <rtems_filesystem_null_handlers+0x40>
<== NOT EXECUTED
40007048 <rtems_get_version_string>:
#include <rtems.h>
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
40007048: 11 10 00 60 sethi %hi(0x40018000), %o0
<== NOT EXECUTED
}
4000704c: 81 c3 e0 08 retl
<== NOT EXECUTED
40007050: 90 12 23 68 or %o0, 0x368, %o0 ! 40018368 <_RTEMS_version>
<== NOT EXECUTED
40006fe8 <rtems_initialize_executive>:
RTEMS_SYSINIT_DEVICE_DRIVERS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
40006fe8: 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;
40006fec: 3b 10 00 60 sethi %hi(0x40018000), %i5
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40006ff0: 39 10 00 61 sethi %hi(0x40018400), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
40006ff4: ba 17 63 c0 or %i5, 0x3c0, %i5
40006ff8: b8 17 20 08 or %i4, 8, %i4
40006ffc: 80 a7 40 1c cmp %i5, %i4
40007000: 02 80 00 09 be 40007024 <rtems_initialize_executive+0x3c> <== NEVER TAKEN
40007004: 03 10 00 6b sethi %hi(0x4001ac00), %g1
( *item->handler )();
40007008: c2 07 40 00 ld [ %i5 ], %g1
4000700c: 9f c0 40 00 call %g1
40007010: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40007014: 80 a7 40 1c cmp %i5, %i4
40007018: 32 bf ff fd bne,a 4000700c <rtems_initialize_executive+0x24>
4000701c: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
40007020: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40007024: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
40007028: 40 00 14 d3 call 4000c374 <_Thread_Start_multitasking>
4000702c: c4 20 61 c4 st %g2, [ %g1 + 0x1c4 ]
40007030: 01 00 00 00 nop
<== NOT EXECUTED
40006518 <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 ) ) {
40006518: 80 a2 20 27 cmp %o0, 0x27
<== NOT EXECUTED
4000651c: 18 80 00 06 bgu 40006534 <rtems_internal_error_text+0x1c>
<== NOT EXECUTED
40006520: 03 10 00 45 sethi %hi(0x40011400), %g1
<== NOT EXECUTED
text = internal_error_text[ i ];
40006524: 91 2a 20 02 sll %o0, 2, %o0
<== NOT EXECUTED
40006528: 82 10 62 a4 or %g1, 0x2a4, %g1
<== NOT EXECUTED
4000652c: 81 c3 e0 08 retl
<== NOT EXECUTED
40006530: d0 00 40 08 ld [ %g1 + %o0 ], %o0
<== NOT EXECUTED
const char *text = "?";
40006534: 11 10 00 42 sethi %hi(0x40010800), %o0
<== NOT EXECUTED
}
return text;
}
40006538: 81 c3 e0 08 retl
<== NOT EXECUTED
4000653c: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40010af0 <rtems_filesystem_null_handlers+0x40>
<== NOT EXECUTED
4000e4fc <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e4fc: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e500: 03 10 00 5c sethi %hi(0x40017000), %g1
4000e504: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1 ! 400172e4 <_IO_Number_of_drivers>
{
4000e508: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000e50c: 80 a0 40 08 cmp %g1, %o0
4000e510: 08 80 00 11 bleu 4000e554 <rtems_io_close+0x58>
<== NEVER TAKEN
4000e514: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
4000e518: 83 2a 20 01 sll %o0, 1, %g1
4000e51c: 82 00 40 08 add %g1, %o0, %g1
4000e520: 85 28 60 03 sll %g1, 3, %g2
4000e524: 03 10 00 65 sethi %hi(0x40019400), %g1
4000e528: 82 10 60 6c or %g1, 0x6c, %g1 ! 4001946c <_IO_Driver_address_table>
4000e52c: 82 00 40 02 add %g1, %g2, %g1
4000e530: c2 00 60 08 ld [ %g1 + 8 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e534: 80 a0 60 00 cmp %g1, 0
4000e538: 02 80 00 06 be 4000e550 <rtems_io_close+0x54>
<== NEVER TAKEN
4000e53c: 94 10 00 1a mov %i2, %o2
4000e540: 9f c0 40 00 call %g1
4000e544: 92 10 00 19 mov %i1, %o1
4000e548: 81 c7 e0 08 ret
4000e54c: 91 e8 00 08 restore %g0, %o0, %o0
4000e550: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e554: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e558: 81 e8 00 00 restore
<== NOT EXECUTED
4000e55c <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e55c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e560: 03 10 00 5c sethi %hi(0x40017000), %g1
<== NOT EXECUTED
4000e564: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1 ! 400172e4 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000e568: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000e56c: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000e570: 08 80 00 11 bleu 4000e5b4 <rtems_io_control+0x58>
<== NOT EXECUTED
4000e574: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
4000e578: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e57c: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e580: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e584: 03 10 00 65 sethi %hi(0x40019400), %g1
<== NOT EXECUTED
4000e588: 82 10 60 6c or %g1, 0x6c, %g1 ! 4001946c <_IO_Driver_address_table>
<== NOT EXECUTED
4000e58c: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e590: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e594: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e598: 02 80 00 06 be 4000e5b0 <rtems_io_control+0x54>
<== NOT EXECUTED
4000e59c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e5a0: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e5a4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e5a8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e5ac: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e5b0: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e5b4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e5b8: 81 e8 00 00 restore
<== NOT EXECUTED
4000e5bc <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e5bc: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e5c0: 03 10 00 5c sethi %hi(0x40017000), %g1
4000e5c4: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1 ! 400172e4 <_IO_Number_of_drivers>
{
4000e5c8: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000e5cc: 80 a0 40 08 cmp %g1, %o0
4000e5d0: 08 80 00 10 bleu 4000e610 <rtems_io_initialize+0x54>
<== NEVER TAKEN
4000e5d4: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
4000e5d8: 83 2a 20 01 sll %o0, 1, %g1
4000e5dc: 07 10 00 65 sethi %hi(0x40019400), %g3
4000e5e0: 82 00 40 08 add %g1, %o0, %g1
4000e5e4: 86 10 e0 6c or %g3, 0x6c, %g3
4000e5e8: 83 28 60 03 sll %g1, 3, %g1
4000e5ec: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e5f0: 80 a0 60 00 cmp %g1, 0
4000e5f4: 02 80 00 06 be 4000e60c <rtems_io_initialize+0x50>
4000e5f8: 94 10 00 1a mov %i2, %o2
4000e5fc: 9f c0 40 00 call %g1
4000e600: 92 10 00 19 mov %i1, %o1
4000e604: 81 c7 e0 08 ret
4000e608: 91 e8 00 08 restore %g0, %o0, %o0
4000e60c: b0 10 20 00 clr %i0
}
4000e610: 81 c7 e0 08 ret
4000e614: 81 e8 00 00 restore
4000e618 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e618: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e61c: 03 10 00 5c sethi %hi(0x40017000), %g1
4000e620: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1 ! 400172e4 <_IO_Number_of_drivers>
{
4000e624: 90 10 00 18 mov %i0, %o0
if ( major >= _IO_Number_of_drivers )
4000e628: 80 a0 40 08 cmp %g1, %o0
4000e62c: 08 80 00 11 bleu 4000e670 <rtems_io_open+0x58>
<== NEVER TAKEN
4000e630: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
4000e634: 83 2a 20 01 sll %o0, 1, %g1
4000e638: 82 00 40 08 add %g1, %o0, %g1
4000e63c: 85 28 60 03 sll %g1, 3, %g2
4000e640: 03 10 00 65 sethi %hi(0x40019400), %g1
4000e644: 82 10 60 6c or %g1, 0x6c, %g1 ! 4001946c <_IO_Driver_address_table>
4000e648: 82 00 40 02 add %g1, %g2, %g1
4000e64c: c2 00 60 04 ld [ %g1 + 4 ], %g1
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e650: 80 a0 60 00 cmp %g1, 0
4000e654: 02 80 00 06 be 4000e66c <rtems_io_open+0x54>
<== NEVER TAKEN
4000e658: 94 10 00 1a mov %i2, %o2
4000e65c: 9f c0 40 00 call %g1
4000e660: 92 10 00 19 mov %i1, %o1
4000e664: 81 c7 e0 08 ret
4000e668: 91 e8 00 08 restore %g0, %o0, %o0
4000e66c: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e670: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e674: 81 e8 00 00 restore
<== NOT EXECUTED
4000e678 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e678: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e67c: 03 10 00 5c sethi %hi(0x40017000), %g1
<== NOT EXECUTED
4000e680: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1 ! 400172e4 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000e684: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000e688: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000e68c: 08 80 00 11 bleu 4000e6d0 <rtems_io_read+0x58>
<== NOT EXECUTED
4000e690: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
4000e694: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e698: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e69c: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e6a0: 03 10 00 65 sethi %hi(0x40019400), %g1
<== NOT EXECUTED
4000e6a4: 82 10 60 6c or %g1, 0x6c, %g1 ! 4001946c <_IO_Driver_address_table>
<== NOT EXECUTED
4000e6a8: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e6ac: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e6b0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e6b4: 02 80 00 06 be 4000e6cc <rtems_io_read+0x54>
<== NOT EXECUTED
4000e6b8: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e6bc: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e6c0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e6c4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e6c8: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e6cc: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e6d0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e6d4: 81 e8 00 00 restore
<== NOT EXECUTED
4000e6d8 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
4000e6d8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
4000e6dc: 03 10 00 5c sethi %hi(0x40017000), %g1
<== NOT EXECUTED
4000e6e0: c2 00 62 e4 ld [ %g1 + 0x2e4 ], %g1 ! 400172e4 <_IO_Number_of_drivers>
<== NOT EXECUTED
{
4000e6e4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( major >= _IO_Number_of_drivers )
4000e6e8: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000e6ec: 08 80 00 11 bleu 4000e730 <rtems_io_write+0x58>
<== NOT EXECUTED
4000e6f0: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
4000e6f4: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000e6f8: 82 00 40 08 add %g1, %o0, %g1
<== NOT EXECUTED
4000e6fc: 85 28 60 03 sll %g1, 3, %g2
<== NOT EXECUTED
4000e700: 03 10 00 65 sethi %hi(0x40019400), %g1
<== NOT EXECUTED
4000e704: 82 10 60 6c or %g1, 0x6c, %g1 ! 4001946c <_IO_Driver_address_table>
<== NOT EXECUTED
4000e708: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000e70c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
<== NOT EXECUTED
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
4000e710: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e714: 02 80 00 06 be 4000e72c <rtems_io_write+0x54>
<== NOT EXECUTED
4000e718: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e71c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e720: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e724: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e728: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e72c: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
4000e730: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e734: 81 e8 00 00 restore
<== NOT EXECUTED
4000e4e8 <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
4000e4e8: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
4000e4ec: 90 10 20 05 mov 5, %o0
4000e4f0: 7f ff e5 19 call 40007954 <_Terminate>
4000e4f4: 92 10 00 18 mov %i0, %o1
4000e4f8: 01 00 00 00 nop
<== NOT EXECUTED
400070a0 <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
)
{
400070a0: 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 ) {
400070a4: 80 a6 a0 01 cmp %i2, 1
400070a8: 08 80 00 28 bleu 40007148 <rtems_timecounter_simple_install+0xa8> <== NEVER TAKEN
400070ac: b8 10 00 18 mov %i0, %i4
400070b0: 82 10 20 1f mov 0x1f, %g1
break;
}
power_of_two *= 2;
400070b4: 10 80 00 05 b 400070c8 <rtems_timecounter_simple_install+0x28>
400070b8: 90 10 20 02 mov 2, %o0
for ( i = 0; i < 32; ++i ) {
400070bc: 82 80 7f ff addcc %g1, -1, %g1
400070c0: 02 80 00 1c be 40007130 <rtems_timecounter_simple_install+0x90> <== NEVER TAKEN
400070c4: 90 10 00 02 mov %g2, %o0
if ( power_of_two >= counter_ticks_per_clock_tick ) {
400070c8: 80 a6 80 08 cmp %i2, %o0
400070cc: 18 bf ff fc bgu 400070bc <rtems_timecounter_simple_install+0x1c>
400070d0: 85 2a 20 01 sll %o0, 1, %g2
400070d4: 21 20 00 00 sethi %hi(0x80000000), %l0
400070d8: ba 00 bf ff add %g2, -1, %i5
400070dc: 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;
400070e0: 94 10 20 00 clr %o2
400070e4: 96 10 00 1a mov %i2, %o3
400070e8: 40 00 3c e2 call 40016470 <__udivdi3>
400070ec: 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 );
400070f0: 82 5e 40 08 smul %i1, %o0, %g1
400070f4: 86 56 40 09 umul %i1, %o1, %g3
400070f8: 85 40 00 00 rd %y, %g2
tc->scaler = scaler;
400070fc: d0 27 20 30 st %o0, [ %i4 + 0x30 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40007100: 84 00 40 02 add %g1, %g2, %g2
tc->scaler = scaler;
40007104: d2 27 20 34 st %o1, [ %i4 + 0x34 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40007108: 82 10 20 64 mov 0x64, %g1
tc->real_interval = counter_ticks_per_clock_tick;
4000710c: f4 27 20 38 st %i2, [ %i4 + 0x38 ]
tc->binary_interval = ( mask + 1 ) / 2;
40007110: e0 27 20 3c st %l0, [ %i4 + 0x3c ]
tc->tc.tc_get_timecount = get_timecount;
40007114: f6 27 00 00 st %i3, [ %i4 ]
tc->tc.tc_counter_mask = mask;
40007118: fa 27 20 08 st %i5, [ %i4 + 8 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
4000711c: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
40007120: c0 27 20 10 clr [ %i4 + 0x10 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40007124: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
_Timecounter_Install( &tc->tc );
40007128: 40 00 06 b0 call 40008be8 <_Timecounter_Install>
4000712c: 91 e8 00 1c restore %g0, %i4, %o0
40007130: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
40007134: 21 1f ff ff sethi %hi(0x7ffffc00), %l0
<== NOT EXECUTED
40007138: ba 00 bf ff add %g2, -1, %i5
<== NOT EXECUTED
4000713c: a0 14 23 ff or %l0, 0x3ff, %l0
<== NOT EXECUTED
40007140: 10 bf ff e8 b 400070e0 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40007144: a0 0a 00 10 and %o0, %l0, %l0
<== NOT EXECUTED
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40007148: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
4000714c: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
40007150: 10 bf ff e4 b 400070e0 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40007154: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED