=============================================================================== 400073a0 <_IO_Initialize_all_drivers>: #include 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 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 : __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 : __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_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 <== 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_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 <== 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 <== 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 <== 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 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 <== NOT EXECUTED 4000a530: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4> <== NOT EXECUTED =============================================================================== 40007380 : #include 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 : 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 <== 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 <== NOT EXECUTED =============================================================================== 40007394 : #include #include 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_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 <== 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 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 : 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 <== 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 <== NOT EXECUTED =============================================================================== 40011410 : 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 <== 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 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_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 <== 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 <== 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_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 <== 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 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_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 <== 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 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_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 <== 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 <== 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_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 <== 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 <== 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 <== 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 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 <== 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 <== 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 <== 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 4000745c: 84 10 00 03 mov %g3, %g2 40007460: 80 a7 40 18 cmp %i5, %i0 40007464: 02 80 00 3e be 4000755c <== 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 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 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 <== 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 <== 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 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000757c: 01 00 00 00 nop <== NOT EXECUTED *registered_major = major; 40007580: 10 bf ff c7 b 4000749c <== NOT EXECUTED 40007584: f0 26 80 00 st %i0, [ %i2 ] <== NOT EXECUTED *major = m; 40007588: 10 bf ff f6 b 40007560 <== NOT EXECUTED 4000758c: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED =============================================================================== 40007590 : #include 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 <== 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 <== 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 } return RTEMS_UNSATISFIED; } 400075fc: 81 c7 e0 08 ret 40007600: 91 e8 00 01 restore %g0, %g1, %o0 =============================================================================== 400115ec : 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 <== 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 <== 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 : #include #include 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 <== 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 : 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 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 40006ddc: 80 88 60 ff btst 0xff, %g1 40006de0: 02 80 00 31 be 40006ea4 <== 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 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 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 <== 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 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 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 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 40006e88: 94 12 a0 34 or %o2, 0x34, %o2 ! 40006c34 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 <== 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 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 40006ee4: e0 20 60 04 st %l0, [ %g1 + 4 ] =============================================================================== 40006c4c : 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 <== 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 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 40006cb8: b4 58 80 1b smul %g2, %i3, %i2 40006cbc: 80 a4 00 1a cmp %l0, %i2 40006cc0: 1a 80 00 33 bcc 40006d8c 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 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 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 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 : 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 <== 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 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 <== 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 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 400070d8: fa 07 40 00 ld [ %i5 ], %i5 400070dc: 10 bf ff f9 b 400070c0 400070e0: fa 07 60 04 ld [ %i5 + 4 ], %i5 =============================================================================== 400070e4 : 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 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 <== ALWAYS TAKEN 40007114: 80 a6 e0 00 cmp %i3, 0 40007118: 12 80 00 14 bne 40007168 <== 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 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 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 40007178: 84 10 00 1d mov %i5, %g2 =============================================================================== 400113fc : #include #include 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 *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 <== 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 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 <== 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 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 <== 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 <== NOT EXECUTED 4000ae4c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED