40012878 <_Copyright_Notice>:
40012878: 43 4f 50 59 52 49 47 48 54 20 28 63 29 20 31 39 COPYRIGHT (c) 19
40012888: 38 39 2d 32 30 30 38 2e 0a 4f 6e 2d 4c 69 6e 65 89-2008..On-Line
40012898: 20 41 70 70 6c 69 63 61 74 69 6f 6e 73 20 52 65 Applications Re
400128a8: 73 65 61 72 63 68 20 43 6f 72 70 6f 72 61 74 69 search Corporati
400128b8: 6f 6e 20 28 4f 41 52 29 2e 0a 00 00 00 00 00 00 on (OAR)........
400128c8: 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 00 00 00 00 _Allocator......
400128d8: 28 66 6d 74 20 6e 75 6c 6c 29 0a 00 00 00 00 00 (fmt null)......
400128e8: 28 6e 75 6c 6c 29 00 (null).
400073a4 <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
400073a4: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
400073a8: 03 10 00 52 sethi %hi(0x40014800), %g1
400073ac: 84 10 20 01 mov 1, %g2
400073b0: c4 28 60 60 stb %g2, [ %g1 + 0x60 ]
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
400073b4: 03 10 00 43 sethi %hi(0x40010c00), %g1
400073b8: f8 00 61 14 ld [ %g1 + 0x114 ], %i4 ! 40010d14 <_IO_Number_of_drivers>
400073bc: 80 a7 20 00 cmp %i4, 0
400073c0: 02 80 00 0a be 400073e8 <_IO_Initialize_all_drivers+0x44> <== NEVER TAKEN
400073c4: ba 10 20 00 clr %i5
(void) rtems_io_initialize( major, 0, NULL );
400073c8: 90 10 00 1d mov %i5, %o0
400073cc: 94 10 20 00 clr %o2
400073d0: 40 00 1d 18 call 4000e830 <rtems_io_initialize>
400073d4: 92 10 20 00 clr %o1
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
400073d8: ba 07 60 01 inc %i5
400073dc: 80 a7 40 1c cmp %i5, %i4
400073e0: 12 bf ff fb bne 400073cc <_IO_Initialize_all_drivers+0x28>
400073e4: 90 10 00 1d mov %i5, %o0
}
400073e8: 81 c7 e0 08 ret
400073ec: 81 e8 00 00 restore
400116dc <_Objects_Information_table>:
400116dc: 00 00 00 00 40 01 42 84 40 01 42 58 40 01 42 24 ....@.B.@.BX@.B$
400116ec: 00 00 00 00 5f 41 6c 6c 6f 63 61 74 6f 72 00 00 ...._Allocator..
400116fc: 00 00 00 00 5f 54 4f 44 00 00 00 00 28 66 6d 74 ...._TOD....(fmt
4001170c: 20 6e 75 6c 6c 29 0a 00 00 00 00 00 28 6e 75 6c null)......(nul
4001171c: 6c 29 00 l).
40007694 <rtems_chain_append>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007694: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
40007698: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000769c: 86 02 20 04 add %o0, 4, %g3
<== NOT EXECUTED
the_node->next = tail;
400076a0: c6 22 40 00 st %g3, [ %o1 ]
<== NOT EXECUTED
tail->previous = the_node;
400076a4: d2 22 20 08 st %o1, [ %o0 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
400076a8: d2 20 80 00 st %o1, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
400076ac: c4 22 60 04 st %g2, [ %o1 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400076b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400076b4: 01 00 00 00 nop
rtems_interrupt_lock_context lock_context;
chain_acquire( &lock_context );
_Chain_Append_unprotected( chain, node );
chain_release( &lock_context );
}
400076b8: 81 c3 e0 08 retl
400076bc: 01 00 00 00 nop
400076e8 <rtems_chain_append_with_empty_check>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400076e8: 91 d0 20 09 ta 9
<== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
400076ec: c8 02 00 00 ld [ %o0 ], %g4
<== NOT EXECUTED
old_last = tail->previous;
400076f0: c6 02 20 08 ld [ %o0 + 8 ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
400076f4: 84 02 20 04 add %o0, 4, %g2
<== NOT EXECUTED
the_node->next = tail;
400076f8: c4 22 40 00 st %g2, [ %o1 ]
<== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
400076fc: 84 18 80 04 xor %g2, %g4, %g2
<== NOT EXECUTED
tail->previous = the_node;
40007700: d2 22 20 08 st %o1, [ %o0 + 8 ]
<== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
40007704: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
old_last->next = the_node;
40007708: d2 20 c0 00 st %o1, [ %g3 ]
<== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
4000770c: 90 60 3f ff subx %g0, -1, %o0
<== NOT EXECUTED
the_node->previous = old_last;
40007710: c6 22 60 04 st %g3, [ %o1 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007714: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007718: 01 00 00 00 nop
chain_acquire( &lock_context );
was_empty = _Chain_Append_with_empty_check_unprotected( chain, node );
chain_release( &lock_context );
return was_empty;
}
4000771c: 81 c3 e0 08 retl
40007720: 01 00 00 00 nop
40007634 <rtems_chain_get>:
_Chain_Extract_unprotected( node );
chain_release( &lock_context );
}
rtems_chain_node *rtems_chain_get( rtems_chain_control *chain )
{
40007634: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007638: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000763c: d0 02 00 00 ld [ %o0 ], %o0
return &the_chain->Tail.Node;
40007640: 86 00 a0 04 add %g2, 4, %g3
if ( !_Chain_Is_empty(the_chain))
40007644: 80 a2 00 03 cmp %o0, %g3
40007648: 22 80 00 05 be,a 4000765c <rtems_chain_get+0x28>
4000764c: 90 10 20 00 clr %o0
new_first = old_first->next;
40007650: c6 02 00 00 ld [ %o0 ], %g3
<== NOT EXECUTED
head->next = new_first;
40007654: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
new_first->previous = head;
40007658: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000765c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007660: 01 00 00 00 nop
chain_acquire( &lock_context );
node = _Chain_Get_unprotected( chain );
chain_release( &lock_context );
return node;
}
40007664: 81 c3 e0 08 retl
40007668: 01 00 00 00 nop
4000775c <rtems_chain_get_with_empty_check>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000775c: 91 d0 20 09 ta 9
<== NOT EXECUTED
Chain_Node *old_first = head->next;
40007760: c6 02 00 00 ld [ %o0 ], %g3
return &the_chain->Tail.Node;
40007764: 84 02 20 04 add %o0, 4, %g2
if ( old_first != tail ) {
40007768: 80 a0 80 03 cmp %g2, %g3
4000776c: 22 80 00 0d be,a 400077a0 <rtems_chain_get_with_empty_check+0x44>
40007770: c0 22 40 00 clr [ %o1 ]
Chain_Node *new_first = old_first->next;
40007774: c8 00 c0 00 ld [ %g3 ], %g4
<== NOT EXECUTED
head->next = new_first;
40007778: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
is_empty_now = new_first == tail;
4000777c: 84 18 80 04 xor %g2, %g4, %g2
<== NOT EXECUTED
new_first->previous = head;
40007780: d0 21 20 04 st %o0, [ %g4 + 4 ]
<== NOT EXECUTED
is_empty_now = new_first == tail;
40007784: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
*the_node = old_first;
40007788: c6 22 40 00 st %g3, [ %o1 ]
<== NOT EXECUTED
is_empty_now = new_first == tail;
4000778c: 90 60 3f ff subx %g0, -1, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007790: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007794: 01 00 00 00 nop
chain_acquire( &lock_context );
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node );
chain_release( &lock_context );
return is_empty_now;
}
40007798: 81 c3 e0 08 retl
4000779c: 90 0a 20 01 and %o0, 1, %o0
bool is_empty_now = true;
400077a0: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
400077a4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400077a8: 01 00 00 00 nop
400077ac: 81 c3 e0 08 retl
400077b0: 90 0a 20 01 and %o0, 1, %o0
400075ac <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
400075ac: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
400075b0: 40 00 00 21 call 40007634 <rtems_chain_get>
400075b4: 90 10 00 18 mov %i0, %o0
) {
rtems_event_set out;
sc = rtems_event_receive(
400075b8: 96 07 bf fc add %fp, -4, %o3
&& (node = rtems_chain_get( chain )) == NULL
400075bc: ba 10 00 08 mov %o0, %i5
sc = rtems_event_receive(
400075c0: 94 10 00 1a mov %i2, %o2
400075c4: 92 10 20 00 clr %o1
&& (node = rtems_chain_get( chain )) == NULL
400075c8: 80 a7 60 00 cmp %i5, 0
400075cc: 12 80 00 0a bne 400075f4 <rtems_chain_get_with_wait+0x48>
400075d0: 90 10 00 19 mov %i1, %o0
sc = rtems_event_receive(
400075d4: 7f ff fe f7 call 400071b0 <rtems_event_receive>
400075d8: 01 00 00 00 nop
while (
400075dc: 80 a2 20 00 cmp %o0, 0
400075e0: 02 bf ff f4 be 400075b0 <rtems_chain_get_with_wait+0x4> <== NEVER TAKEN
400075e4: 01 00 00 00 nop
timeout,
&out
);
}
*node_ptr = node;
400075e8: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
400075ec: 81 c7 e0 08 ret
400075f0: 91 e8 00 08 restore %g0, %o0, %o0
400075f4: 90 10 20 00 clr %o0
*node_ptr = node;
400075f8: fa 26 c0 00 st %i5, [ %i3 ]
}
400075fc: 81 c7 e0 08 ret
40007600: 91 e8 00 08 restore %g0, %o0, %o0
4000766c <rtems_chain_insert>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000766c: 91 d0 20 09 ta 9
<== NOT EXECUTED
the_node->previous = after_node;
40007670: d0 22 60 04 st %o0, [ %o1 + 4 ]
<== NOT EXECUTED
before_node = after_node->next;
40007674: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
after_node->next = the_node;
40007678: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
the_node->next = before_node;
4000767c: c4 22 40 00 st %g2, [ %o1 ]
<== NOT EXECUTED
before_node->previous = the_node;
40007680: d2 20 a0 04 st %o1, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007684: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007688: 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 );
}
4000768c: 81 c3 e0 08 retl
40007690: 01 00 00 00 nop
400076c0 <rtems_chain_prepend>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400076c0: 91 d0 20 09 ta 9
<== NOT EXECUTED
the_node->previous = after_node;
400076c4: d0 22 60 04 st %o0, [ %o1 + 4 ]
<== NOT EXECUTED
before_node = after_node->next;
400076c8: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
after_node->next = the_node;
400076cc: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
the_node->next = before_node;
400076d0: c4 22 40 00 st %g2, [ %o1 ]
<== NOT EXECUTED
before_node->previous = the_node;
400076d4: d2 20 a0 04 st %o1, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400076d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400076dc: 01 00 00 00 nop
rtems_interrupt_lock_context lock_context;
chain_acquire( &lock_context );
_Chain_Prepend_unprotected( chain, node );
chain_release( &lock_context );
}
400076e0: 81 c3 e0 08 retl
400076e4: 01 00 00 00 nop
40007724 <rtems_chain_prepend_with_empty_check>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007724: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40007728: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
the_node->previous = after_node;
4000772c: d0 22 60 04 st %o0, [ %o1 + 4 ]
<== NOT EXECUTED
return &the_chain->Tail.Node;
40007730: 86 02 20 04 add %o0, 4, %g3
<== NOT EXECUTED
after_node->next = the_node;
40007734: d2 22 00 00 st %o1, [ %o0 ]
<== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
40007738: 86 18 80 03 xor %g2, %g3, %g3
<== NOT EXECUTED
the_node->next = before_node;
4000773c: c4 22 40 00 st %g2, [ %o1 ]
<== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
40007740: 80 a0 00 03 cmp %g0, %g3
<== NOT EXECUTED
before_node->previous = the_node;
40007744: d2 20 a0 04 st %o1, [ %g2 + 4 ]
<== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
40007748: 90 60 3f ff subx %g0, -1, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000774c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007750: 01 00 00 00 nop
chain_acquire( &lock_context );
was_empty = _Chain_Prepend_with_empty_check_unprotected( chain, node );
chain_release( &lock_context );
return was_empty;
}
40007754: 81 c3 e0 08 retl
40007758: 01 00 00 00 nop
40007384 <rtems_fatal_error_occurred>:
#include <rtems/score/interr.h>
void rtems_fatal_error_occurred(
uint32_t the_error
)
{
40007384: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( INTERNAL_ERROR_RTEMS_API, the_error );
40007388: 90 10 20 01 mov 1, %o0
4000738c: 40 00 02 86 call 40007da4 <_Terminate>
40007390: 92 10 00 18 mov %i0, %o1
40007394: 01 00 00 00 nop
<== NOT EXECUTED
40007338 <rtems_initialize_executive>:
RTEMS_SYSINIT_DEVICE_DRIVERS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
40007338: 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;
4000733c: 3b 10 00 47 sethi %hi(0x40011c00), %i5
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40007340: 39 10 00 47 sethi %hi(0x40011c00), %i4
RTEMS_OBFUSCATE_VARIABLE( addr );
40007344: ba 17 62 a0 or %i5, 0x2a0, %i5
40007348: b8 17 22 e4 or %i4, 0x2e4, %i4
4000734c: 80 a7 40 1c cmp %i5, %i4
40007350: 02 80 00 09 be 40007374 <rtems_initialize_executive+0x3c> <== NEVER TAKEN
40007354: 03 10 00 52 sethi %hi(0x40014800), %g1
( *item->handler )();
40007358: c2 07 40 00 ld [ %i5 ], %g1
4000735c: 9f c0 40 00 call %g1
40007360: ba 07 60 04 add %i5, 4, %i5
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
40007364: 80 a7 40 1c cmp %i5, %i4
40007368: 32 bf ff fd bne,a 4000735c <rtems_initialize_executive+0x24>
4000736c: c2 07 40 00 ld [ %i5 ], %g1
_System_state_Current = state;
40007370: 03 10 00 52 sethi %hi(0x40014800), %g1
40007374: 84 10 20 02 mov 2, %g2
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
40007378: 40 00 15 24 call 4000c808 <_Thread_Start_multitasking>
4000737c: c4 20 60 6c st %g2, [ %g1 + 0x6c ]
40007380: 01 00 00 00 nop
<== NOT EXECUTED
4000a918 <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
)
{
4000a918: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major_limit = _IO_Number_of_drivers;
4000a91c: 3b 10 00 52 sethi %hi(0x40014800), %i5
ISR_lock_Context lock_context;
if ( rtems_interrupt_is_in_progress() )
4000a920: 40 00 06 15 call 4000c174 <_ISR_Is_in_progress>
4000a924: f8 07 60 64 ld [ %i5 + 0x64 ], %i4 ! 40014864 <_IO_Number_of_drivers>
4000a928: 80 a2 20 00 cmp %o0, 0
4000a92c: 12 80 00 45 bne 4000aa40 <rtems_io_register_driver+0x128>
4000a930: 80 a6 a0 00 cmp %i2, 0
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
4000a934: 02 80 00 40 be 4000aa34 <rtems_io_register_driver+0x11c>
4000a938: 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 )
4000a93c: 02 80 00 3e be 4000aa34 <rtems_io_register_driver+0x11c>
4000a940: f8 26 80 00 st %i4, [ %i2 ]
return table->initialization_entry == NULL && table->open_entry == NULL;
4000a944: c2 06 40 00 ld [ %i1 ], %g1
4000a948: 80 a0 60 00 cmp %g1, 0
4000a94c: 22 80 00 37 be,a 4000aa28 <rtems_io_register_driver+0x110>
4000a950: 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 )
4000a954: 80 a7 00 18 cmp %i4, %i0
4000a958: 08 80 00 4a bleu 4000aa80 <rtems_io_register_driver+0x168>
4000a95c: 82 10 20 0a mov 0xa, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a960: 91 d0 20 09 ta 9
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
_IO_Driver_registration_acquire( &lock_context );
if ( major == 0 ) {
4000a964: 80 a6 20 00 cmp %i0, 0
4000a968: 12 80 00 39 bne 4000aa4c <rtems_io_register_driver+0x134>
4000a96c: 85 2e 20 01 sll %i0, 1, %g2
rtems_device_major_number n = _IO_Number_of_drivers;
4000a970: fa 07 60 64 ld [ %i5 + 0x64 ], %i5
for ( m = 0; m < n; ++m ) {
4000a974: 80 a7 60 00 cmp %i5, 0
4000a978: 02 80 00 4f be 4000aab4 <rtems_io_register_driver+0x19c> <== NEVER TAKEN
4000a97c: 07 10 00 5a sethi %hi(0x40016800), %g3
4000a980: 86 10 e3 30 or %g3, 0x330, %g3 ! 40016b30 <_IO_Driver_address_table>
4000a984: 10 80 00 05 b 4000a998 <rtems_io_register_driver+0x80>
4000a988: 84 10 00 03 mov %g3, %g2
4000a98c: 80 a7 40 18 cmp %i5, %i0
4000a990: 02 80 00 3e be 4000aa88 <rtems_io_register_driver+0x170>
4000a994: 84 00 a0 18 add %g2, 0x18, %g2
return table->initialization_entry == NULL && table->open_entry == NULL;
4000a998: c8 00 80 00 ld [ %g2 ], %g4
4000a99c: 80 a1 20 00 cmp %g4, 0
4000a9a0: 32 bf ff fb bne,a 4000a98c <rtems_io_register_driver+0x74>
4000a9a4: b0 06 20 01 inc %i0
4000a9a8: c8 00 a0 04 ld [ %g2 + 4 ], %g4
4000a9ac: 80 a1 20 00 cmp %g4, 0
4000a9b0: 32 bf ff f7 bne,a 4000a98c <rtems_io_register_driver+0x74>
4000a9b4: b0 06 20 01 inc %i0
if ( m != n )
4000a9b8: 80 a7 40 18 cmp %i5, %i0
4000a9bc: 02 80 00 34 be 4000aa8c <rtems_io_register_driver+0x174> <== NEVER TAKEN
4000a9c0: f0 26 80 00 st %i0, [ %i2 ]
<== NOT EXECUTED
4000a9c4: 84 5e 20 03 smul %i0, 3, %g2
<== NOT EXECUTED
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
4000a9c8: c8 06 40 00 ld [ %i1 ], %g4
<== NOT EXECUTED
4000a9cc: 85 28 a0 03 sll %g2, 3, %g2
<== NOT EXECUTED
4000a9d0: c8 20 c0 02 st %g4, [ %g3 + %g2 ]
<== NOT EXECUTED
4000a9d4: 84 00 c0 02 add %g3, %g2, %g2
<== NOT EXECUTED
4000a9d8: c6 06 60 04 ld [ %i1 + 4 ], %g3
<== NOT EXECUTED
4000a9dc: c6 20 a0 04 st %g3, [ %g2 + 4 ]
<== NOT EXECUTED
4000a9e0: c6 06 60 08 ld [ %i1 + 8 ], %g3
<== NOT EXECUTED
4000a9e4: c6 20 a0 08 st %g3, [ %g2 + 8 ]
<== NOT EXECUTED
4000a9e8: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
4000a9ec: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
<== NOT EXECUTED
4000a9f0: c6 06 60 10 ld [ %i1 + 0x10 ], %g3
<== NOT EXECUTED
4000a9f4: c6 20 a0 10 st %g3, [ %g2 + 0x10 ]
<== NOT EXECUTED
4000a9f8: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
<== NOT EXECUTED
4000a9fc: c6 20 a0 14 st %g3, [ %g2 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aa00: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000aa04: 01 00 00 00 nop
_IO_Driver_registration_release( &lock_context );
if ( _IO_All_drivers_initialized ) {
4000aa08: 03 10 00 61 sethi %hi(0x40018400), %g1
4000aa0c: c4 08 63 8c ldub [ %g1 + 0x38c ], %g2 ! 4001878c <_IO_All_drivers_initialized>
4000aa10: 80 a0 a0 00 cmp %g2, 0
4000aa14: 02 80 00 09 be 4000aa38 <rtems_io_register_driver+0x120> <== NEVER TAKEN
4000aa18: 82 10 20 00 clr %g1
/* Other drivers have already been initialized, we initialize
* the driver directly.
*/
return rtems_io_initialize( major, 0, NULL );
4000aa1c: b4 10 20 00 clr %i2
4000aa20: 7f ff ff 64 call 4000a7b0 <rtems_io_initialize>
4000aa24: 93 e8 20 00 restore %g0, 0, %o1
return table->initialization_entry == NULL && table->open_entry == NULL;
4000aa28: 80 a0 60 00 cmp %g1, 0
4000aa2c: 12 bf ff cb bne 4000a958 <rtems_io_register_driver+0x40>
4000aa30: 80 a7 00 18 cmp %i4, %i0
return RTEMS_INVALID_ADDRESS;
4000aa34: 82 10 20 09 mov 9, %g1
/* The driver will be initialized together with all other drivers
* in a later stage by _IO_Initialize_all_drivers().
*/
return RTEMS_SUCCESSFUL;
}
}
4000aa38: 81 c7 e0 08 ret
4000aa3c: 91 e8 00 01 restore %g0, %g1, %o0
return RTEMS_CALLED_FROM_ISR;
4000aa40: 82 10 20 12 mov 0x12, %g1
}
4000aa44: 81 c7 e0 08 ret
4000aa48: 91 e8 00 01 restore %g0, %g1, %o0
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
4000aa4c: 07 10 00 5a sethi %hi(0x40016800), %g3
4000aa50: 84 00 80 18 add %g2, %i0, %g2
4000aa54: 86 10 e3 30 or %g3, 0x330, %g3
4000aa58: 89 28 a0 03 sll %g2, 3, %g4
return table->initialization_entry == NULL && table->open_entry == NULL;
4000aa5c: fa 00 c0 04 ld [ %g3 + %g4 ], %i5
4000aa60: 80 a7 60 00 cmp %i5, 0
4000aa64: 02 80 00 0e be 4000aa9c <rtems_io_register_driver+0x184>
4000aa68: 88 00 c0 04 add %g3, %g4, %g4
4000aa6c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000aa70: 01 00 00 00 nop
return RTEMS_RESOURCE_IN_USE;
4000aa74: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
}
4000aa78: 81 c7 e0 08 ret
4000aa7c: 91 e8 00 01 restore %g0, %g1, %o0
4000aa80: 81 c7 e0 08 ret
4000aa84: 91 e8 00 01 restore %g0, %g1, %o0
*major = m;
4000aa88: fa 26 80 00 st %i5, [ %i2 ]
<== NOT EXECUTED
4000aa8c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000aa90: 01 00 00 00 nop
return sc;
4000aa94: 10 bf ff e9 b 4000aa38 <rtems_io_register_driver+0x120>
4000aa98: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
return table->initialization_entry == NULL && table->open_entry == NULL;
4000aa9c: c8 01 20 04 ld [ %g4 + 4 ], %g4
4000aaa0: 80 a1 20 00 cmp %g4, 0
4000aaa4: 12 bf ff f2 bne 4000aa6c <rtems_io_register_driver+0x154>
4000aaa8: 01 00 00 00 nop
*registered_major = major;
4000aaac: 10 bf ff c7 b 4000a9c8 <rtems_io_register_driver+0xb0>
4000aab0: f0 26 80 00 st %i0, [ %i2 ]
*major = m;
4000aab4: 10 bf ff f6 b 4000aa8c <rtems_io_register_driver+0x174>
<== NOT EXECUTED
4000aab8: c0 26 80 00 clr [ %i2 ]
<== NOT EXECUTED
4000aabc <rtems_io_unregister_driver>:
#include <string.h>
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
4000aabc: 9d e3 bf a0 save %sp, -96, %sp
if ( rtems_interrupt_is_in_progress() )
4000aac0: 40 00 05 ad call 4000c174 <_ISR_Is_in_progress>
4000aac4: 01 00 00 00 nop
4000aac8: 80 a2 20 00 cmp %o0, 0
4000aacc: 12 80 00 17 bne 4000ab28 <rtems_io_unregister_driver+0x6c>
4000aad0: 82 10 20 12 mov 0x12, %g1
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
4000aad4: 05 10 00 52 sethi %hi(0x40014800), %g2
4000aad8: c4 00 a0 64 ld [ %g2 + 0x64 ], %g2 ! 40014864 <_IO_Number_of_drivers>
4000aadc: 80 a0 80 18 cmp %g2, %i0
4000aae0: 08 80 00 12 bleu 4000ab28 <rtems_io_unregister_driver+0x6c>
4000aae4: 82 10 20 0d mov 0xd, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000aae8: 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],
4000aaec: 07 10 00 5a sethi %hi(0x40016800), %g3
<== NOT EXECUTED
4000aaf0: 85 2e 20 01 sll %i0, 1, %g2
<== NOT EXECUTED
4000aaf4: 86 10 e3 30 or %g3, 0x330, %g3
<== NOT EXECUTED
4000aaf8: b0 00 80 18 add %g2, %i0, %i0
<== NOT EXECUTED
4000aafc: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
memset(
4000ab00: c0 26 00 03 clr [ %i0 + %g3 ]
<== NOT EXECUTED
&_IO_Driver_address_table[major],
4000ab04: b0 06 00 03 add %i0, %g3, %i0
<== NOT EXECUTED
memset(
4000ab08: c0 26 20 04 clr [ %i0 + 4 ]
<== NOT EXECUTED
4000ab0c: c0 26 20 08 clr [ %i0 + 8 ]
<== NOT EXECUTED
4000ab10: c0 26 20 0c clr [ %i0 + 0xc ]
<== NOT EXECUTED
4000ab14: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
4000ab18: c0 26 20 14 clr [ %i0 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ab1c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ab20: 01 00 00 00 nop
0,
sizeof( rtems_driver_address_table )
);
_IO_Driver_registration_release( &lock_context );
return RTEMS_SUCCESSFUL;
4000ab24: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
return RTEMS_UNSATISFIED;
}
4000ab28: 81 c7 e0 08 ret
4000ab2c: 91 e8 00 01 restore %g0, %g1, %o0
40006440 <rtems_panic>:
#include <rtems/bspIo.h>
#include <stdarg.h>
void rtems_panic( const char *fmt, ... )
{
40006440: 9d e3 bf 98 save %sp, -104, %sp
va_list ap;
va_start( ap, fmt );
40006444: 82 07 a0 48 add %fp, 0x48, %g1
40006448: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
vprintk( fmt, ap );
4000644c: 92 10 00 01 mov %g1, %o1
va_start( ap, fmt );
40006450: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
vprintk( fmt, ap );
40006454: 90 10 00 18 mov %i0, %o0
va_start( ap, fmt );
40006458: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4000645c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40006460: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
vprintk( fmt, ap );
40006464: 7f ff fe cb call 40005f90 <vprintk>
40006468: c2 27 bf fc st %g1, [ %fp + -4 ]
va_end( ap);
_Terminate( RTEMS_FATAL_SOURCE_PANIC, (Internal_errors_t) fmt );
4000646c: 92 10 00 18 mov %i0, %o1
40006470: 40 00 02 30 call 40006d30 <_Terminate>
40006474: 90 10 20 0b mov 0xb, %o0
40006478: 01 00 00 00 nop
<== NOT EXECUTED
40007a44 <rtems_rbtree_find>:
const rtems_rbtree_control *the_rbtree,
const rtems_rbtree_node *the_node,
rtems_rbtree_compare compare,
bool is_unique
)
{
40007a44: 9d e3 bf a0 save %sp, -96, %sp
40007a48: 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 ) {
40007a4c: 80 a7 60 00 cmp %i5, 0
40007a50: 02 80 00 0f be 40007a8c <rtems_rbtree_find+0x48>
<== NEVER TAKEN
40007a54: b0 10 20 00 clr %i0
rtems_rbtree_compare_result compare_result =
40007a58: 92 10 00 1d mov %i5, %o1
40007a5c: 9f c6 80 00 call %i2
40007a60: 90 10 00 19 mov %i1, %o0
( *compare )( the_node, iter_node );
if ( rtems_rbtree_is_equal( compare_result ) ) {
40007a64: 80 a2 20 00 cmp %o0, 0
40007a68: 12 80 00 0b bne 40007a94 <rtems_rbtree_find+0x50>
40007a6c: 01 00 00 00 nop
found = iter_node;
if ( is_unique )
40007a70: 80 a6 e0 00 cmp %i3, 0
40007a74: 12 80 00 06 bne 40007a8c <rtems_rbtree_find+0x48>
40007a78: b0 10 00 1d mov %i5, %i0
40007a7c: fa 07 40 00 ld [ %i5 ], %i5
while ( iter_node != NULL ) {
40007a80: 80 a7 60 00 cmp %i5, 0
40007a84: 12 bf ff f6 bne 40007a5c <rtems_rbtree_find+0x18>
40007a88: 92 10 00 1d mov %i5, %o1
40007a8c: 81 c7 e0 08 ret
40007a90: 81 e8 00 00 restore
break;
}
if ( rtems_rbtree_is_greater( compare_result ) ) {
40007a94: 24 bf ff fb ble,a 40007a80 <rtems_rbtree_find+0x3c>
40007a98: fa 07 40 00 ld [ %i5 ], %i5
40007a9c: 10 bf ff f9 b 40007a80 <rtems_rbtree_find+0x3c>
40007aa0: fa 07 60 04 ld [ %i5 + 4 ], %i5
40007b3c <rtems_rbtree_initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
40007b3c: 9d e3 bf a0 save %sp, -96, %sp
RB_INIT( the_rbtree );
40007b40: c0 26 00 00 clr [ %i0 ]
rtems_rbtree_initialize_empty( the_rbtree );
count = number_nodes;
next = starting_address;
while ( count-- ) {
40007b44: 80 a6 e0 00 cmp %i3, 0
40007b48: 02 80 00 0b be 40007b74 <rtems_rbtree_initialize+0x38> <== NEVER TAKEN
40007b4c: a0 06 ff ff add %i3, -1, %l0
rtems_rbtree_insert( the_rbtree, next, compare, is_unique );
40007b50: 92 10 00 1a mov %i2, %o1
40007b54: 96 10 00 1d mov %i5, %o3
40007b58: 94 10 00 19 mov %i1, %o2
40007b5c: 7f ff ff d2 call 40007aa4 <rtems_rbtree_insert>
40007b60: 90 10 00 18 mov %i0, %o0
while ( count-- ) {
40007b64: a0 04 3f ff add %l0, -1, %l0
40007b68: 80 a4 3f ff cmp %l0, -1
40007b6c: 12 bf ff f9 bne 40007b50 <rtems_rbtree_initialize+0x14>
40007b70: b4 06 80 1c add %i2, %i4, %i2
next = (rtems_rbtree_node *) _Addresses_Add_offset( next, node_size );
}
}
40007b74: 81 c7 e0 08 ret
40007b78: 81 e8 00 00 restore
4000e75c <rtems_shutdown_executive>:
#include <rtems/init.h>
#include <rtems/score/interr.h>
void rtems_shutdown_executive( uint32_t result )
{
4000e75c: 9d e3 bf a0 save %sp, -96, %sp
_Terminate( RTEMS_FATAL_SOURCE_EXIT, result );
4000e760: 90 10 20 05 mov 5, %o0
4000e764: 7f ff e5 90 call 40007da4 <_Terminate>
4000e768: 92 10 00 18 mov %i0, %o1
4000e76c: 01 00 00 00 nop
<== NOT EXECUTED
400073f0 <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
)
{
400073f0: 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 ) {
400073f4: 80 a6 a0 01 cmp %i2, 1
400073f8: 08 80 00 28 bleu 40007498 <rtems_timecounter_simple_install+0xa8> <== NEVER TAKEN
400073fc: b8 10 00 18 mov %i0, %i4
40007400: 82 10 20 1f mov 0x1f, %g1
break;
}
power_of_two *= 2;
40007404: 10 80 00 05 b 40007418 <rtems_timecounter_simple_install+0x28>
40007408: 90 10 20 02 mov 2, %o0
for ( i = 0; i < 32; ++i ) {
4000740c: 82 80 7f ff addcc %g1, -1, %g1
40007410: 02 80 00 1c be 40007480 <rtems_timecounter_simple_install+0x90> <== NEVER TAKEN
40007414: 90 10 00 02 mov %g2, %o0
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40007418: 80 a6 80 08 cmp %i2, %o0
4000741c: 18 bf ff fc bgu 4000740c <rtems_timecounter_simple_install+0x1c>
40007420: 85 2a 20 01 sll %o0, 1, %g2
40007424: 21 20 00 00 sethi %hi(0x80000000), %l0
40007428: ba 00 bf ff add %g2, -1, %i5
4000742c: 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;
40007430: 94 10 20 00 clr %o2
40007434: 96 10 00 1a mov %i2, %o3
40007438: 40 00 23 c6 call 40010350 <__udivdi3>
4000743c: 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 );
40007440: 82 5e 40 08 smul %i1, %o0, %g1
40007444: 86 56 40 09 umul %i1, %o1, %g3
40007448: 85 40 00 00 rd %y, %g2
tc->scaler = scaler;
4000744c: d0 27 20 30 st %o0, [ %i4 + 0x30 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
40007450: 84 00 40 02 add %g1, %g2, %g2
tc->scaler = scaler;
40007454: d2 27 20 34 st %o1, [ %i4 + 0x34 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40007458: 82 10 20 64 mov 0x64, %g1
tc->real_interval = counter_ticks_per_clock_tick;
4000745c: f4 27 20 38 st %i2, [ %i4 + 0x38 ]
tc->binary_interval = ( mask + 1 ) / 2;
40007460: e0 27 20 3c st %l0, [ %i4 + 0x3c ]
tc->tc.tc_get_timecount = get_timecount;
40007464: f6 27 00 00 st %i3, [ %i4 ]
tc->tc.tc_counter_mask = mask;
40007468: fa 27 20 08 st %i5, [ %i4 + 8 ]
tc->tc.tc_frequency = (uint32_t) ( ( frequency_in_hz * scaler ) >> 32 );
4000746c: c4 27 20 14 st %g2, [ %i4 + 0x14 ]
40007470: c0 27 20 10 clr [ %i4 + 0x10 ]
tc->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
40007474: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
_Timecounter_Install( &tc->tc );
40007478: 40 00 07 1e call 400090f0 <_Timecounter_Install>
4000747c: 91 e8 00 1c restore %g0, %i4, %o0
40007480: 85 28 a0 01 sll %g2, 1, %g2
<== NOT EXECUTED
40007484: 21 1f ff ff sethi %hi(0x7ffffc00), %l0
<== NOT EXECUTED
40007488: ba 00 bf ff add %g2, -1, %i5
<== NOT EXECUTED
4000748c: a0 14 23 ff or %l0, 0x3ff, %l0
<== NOT EXECUTED
40007490: 10 bf ff e8 b 40007430 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
40007494: a0 0a 00 10 and %o0, %l0, %l0
<== NOT EXECUTED
if ( power_of_two >= counter_ticks_per_clock_tick ) {
40007498: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
4000749c: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
400074a0: 10 bf ff e4 b 40007430 <rtems_timecounter_simple_install+0x40>
<== NOT EXECUTED
400074a4: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED