RTEMS-5
Annotated Report
Fri Aug 10 12:52:17 2018
40004734 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
40004734: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
if ( !rtems_configuration_get_unified_work_area() ) {
40004738: 03 10 00 40 sethi %hi(0x40010000), %g1
4000473c: c2 08 60 7d ldub [ %g1 + 0x7d ], %g1 ! 4001007d <Configuration+0x31>
40004740: 80 a0 60 00 cmp %g1, 0
40004744: 12 80 00 19 bne 400047a8 <RTEMS_Malloc_Initialize+0x74>
40004748: 80 a6 60 00 cmp %i1, 0
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
size_t i;
for (i = 0; i < area_count; ++i) {
4000474c: 02 80 00 19 be 400047b0 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
40004750: 03 10 00 47 sethi %hi(0x40011c00), %g1
Heap_Control *heap = RTEMS_Malloc_Heap;
40004754: f8 00 63 0c ld [ %g1 + 0x30c ], %i4 ! 40011f0c <RTEMS_Malloc_Heap>
40004758: b3 2e 60 03 sll %i1, 3, %i1
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
4000475c: 37 10 00 1d sethi %hi(0x40007400), %i3
40004760: b2 06 00 19 add %i0, %i1, %i1
40004764: b6 16 e2 d8 or %i3, 0x2d8, %i3
40004768: ba 10 00 1b mov %i3, %i5
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
4000476c: d4 06 20 04 ld [ %i0 + 4 ], %o2
40004770: d2 06 00 00 ld [ %i0 ], %o1
40004774: 96 10 20 08 mov 8, %o3
40004778: 9f c7 40 00 call %i5
4000477c: 90 10 00 1c mov %i4, %o0
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
40004780: 80 a2 20 00 cmp %o0, 0
40004784: 32 80 00 02 bne,a 4000478c <RTEMS_Malloc_Initialize+0x58>
<== ALWAYS TAKEN
40004788: ba 10 00 1a mov %i2, %i5
4000478c: b0 06 20 08 add %i0, 8, %i0
for (i = 0; i < area_count; ++i) {
40004790: 80 a6 00 19 cmp %i0, %i1
40004794: 32 bf ff f7 bne,a 40004770 <RTEMS_Malloc_Initialize+0x3c>
<== NEVER TAKEN
40004798: d4 06 20 04 ld [ %i0 + 4 ], %o2
<== NOT EXECUTED
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
4000479c: 80 a7 40 1b cmp %i5, %i3
400047a0: 02 80 00 04 be 400047b0 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
400047a4: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
}
}
}
400047a8: 81 c7 e0 08 ret
400047ac: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
400047b0: 40 00 0c 93 call 400079fc <_Internal_error>
<== NOT EXECUTED
400047b4: 90 10 20 17 mov 0x17, %o0
<== NOT EXECUTED
400047b8: 01 00 00 00 nop
<== NOT EXECUTED
40004340 <_Console_simple_Read>:
ssize_t _Console_simple_Read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
40004340: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
ssize_t n;
buf = buffer;
n = (ssize_t) count;
for ( i = 0; i < n; ++i ) {
40004344: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40004348: 04 80 00 0c ble 40004378 <_Console_simple_Read+0x38>
<== NOT EXECUTED
4000434c: ba 10 20 00 clr %i5
<== NOT EXECUTED
int c;
do {
c = getchark();
40004350: 40 00 00 22 call 400043d8 <getchark>
<== NOT EXECUTED
40004354: 01 00 00 00 nop
<== NOT EXECUTED
} while (c == -1);
40004358: 80 a2 3f ff cmp %o0, -1
<== NOT EXECUTED
4000435c: 02 bf ff fd be 40004350 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004360: 01 00 00 00 nop
<== NOT EXECUTED
buf[ i ] = (char) c;
40004364: d0 2e 40 1d stb %o0, [ %i1 + %i5 ]
<== NOT EXECUTED
for ( i = 0; i < n; ++i ) {
40004368: ba 07 60 01 inc %i5
<== NOT EXECUTED
4000436c: 80 a6 80 1d cmp %i2, %i5
<== NOT EXECUTED
40004370: 12 bf ff f8 bne 40004350 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004374: 01 00 00 00 nop
<== NOT EXECUTED
}
return n;
}
40004378: 81 c7 e0 08 ret
<== NOT EXECUTED
4000437c: 91 e8 00 1a restore %g0, %i2, %o0
<== NOT EXECUTED
40004700 <_Malloc_Deferred_free>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004700: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
40004704: 05 10 00 47 sethi %hi(0x40011c00), %g2
<== NOT EXECUTED
40004708: 84 10 a3 38 or %g2, 0x338, %g2 ! 40011f38 <_Malloc_GC_list>
<== NOT EXECUTED
4000470c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
40004710: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
40004714: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40004718: d0 20 a0 08 st %o0, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000471c: d0 20 c0 00 st %o0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40004720: c6 22 20 04 st %g3, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004724: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004728: 01 00 00 00 nop
<== NOT EXECUTED
rtems_interrupt_lock_acquire( &_Malloc_GC_lock, &lock_context );
rtems_chain_initialize_node( node );
rtems_chain_append_unprotected( &_Malloc_GC_list, node );
rtems_interrupt_lock_release( &_Malloc_GC_lock, &lock_context );
}
4000472c: 81 c3 e0 08 retl
<== NOT EXECUTED
40004730: 01 00 00 00 nop
<== NOT EXECUTED
400045b4 <_Malloc_Process_deferred_frees>:
return p;
}
void _Malloc_Process_deferred_frees( void )
{
400045b4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400045b8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400045bc: 3b 10 00 47 sethi %hi(0x40011c00), %i5
400045c0: d0 07 63 38 ld [ %i5 + 0x338 ], %o0 ! 40011f38 <_Malloc_GC_list>
400045c4: ba 17 63 38 or %i5, 0x338, %i5
if ( !_Chain_Is_empty(the_chain))
400045c8: b8 07 60 04 add %i5, 4, %i4
400045cc: 80 a2 00 1c cmp %o0, %i4
400045d0: 02 80 00 0e be 40004608 <_Malloc_Process_deferred_frees+0x54>
<== ALWAYS TAKEN
400045d4: 01 00 00 00 nop
new_first = old_first->next;
400045d8: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
head->next = new_first;
400045dc: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
new_first->previous = head;
400045e0: fa 20 a0 04 st %i5, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400045e4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400045e8: 01 00 00 00 nop
<== NOT EXECUTED
/*
* If some free's have been deferred, then do them now.
*/
while ( ( to_be_freed = _Malloc_Get_deferred_free() ) != NULL ) {
free( to_be_freed );
400045ec: 7f ff ff 65 call 40004380 <free>
<== NOT EXECUTED
400045f0: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400045f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400045f8: d0 07 40 00 ld [ %i5 ], %o0
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
400045fc: 80 a2 00 1c cmp %o0, %i4
<== NOT EXECUTED
40004600: 32 bf ff f7 bne,a 400045dc <_Malloc_Process_deferred_frees+0x28>
<== NOT EXECUTED
40004604: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004608: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000460c: 01 00 00 00 nop
}
}
40004610: 81 c7 e0 08 ret
40004614: 81 e8 00 00 restore
40004578 <_Malloc_System_state>:
_System_state_Current = state;
}
RTEMS_INLINE_ROUTINE System_state_Codes _System_state_Get ( void )
{
return _System_state_Current;
40004578: 03 10 00 4e sethi %hi(0x40013800), %g1
<== NOT EXECUTED
4000457c: c2 00 61 b0 ld [ %g1 + 0x1b0 ], %g1 ! 400139b0 <_System_state_Current>
<== NOT EXECUTED
if ( _Thread_Dispatch_is_enabled() ) {
return MALLOC_SYSTEM_STATE_NORMAL;
} else {
return MALLOC_SYSTEM_STATE_NO_ALLOCATION;
}
} else if ( _System_state_Is_before_multitasking( state ) ) {
40004580: 84 18 60 01 xor %g1, 1, %g2
<== NOT EXECUTED
return MALLOC_SYSTEM_STATE_NORMAL;
} else {
return MALLOC_SYSTEM_STATE_NO_PROTECTION;
40004584: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
40004588: 90 40 20 00 addx %g0, 0, %o0
<== NOT EXECUTED
if ( _System_state_Is_up( state ) ) {
4000458c: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
40004590: 02 80 00 04 be 400045a0 <_Malloc_System_state+0x28>
<== NOT EXECUTED
40004594: 01 00 00 00 nop
<== NOT EXECUTED
}
}
40004598: 81 c3 e0 08 retl
<== NOT EXECUTED
4000459c: 01 00 00 00 nop
<== NOT EXECUTED
400045a0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return MALLOC_SYSTEM_STATE_NO_ALLOCATION;
400045a4: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
400045a8: 90 40 20 00 addx %g0, 0, %o0
<== NOT EXECUTED
}
400045ac: 81 c3 e0 08 retl
<== NOT EXECUTED
400045b0: 91 2a 20 01 sll %o0, 1, %o0
<== NOT EXECUTED
40018154 <_calloc_r>:
void *_calloc_r(
struct _reent *ignored,
size_t elements,
size_t size
)
{
40018154: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
(void) ignored;
return calloc( elements, size );
40018158: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
4001815c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40018160: 7f ff b3 b7 call 4000503c <calloc>
<== NOT EXECUTED
40018164: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000ea3c <_close_r>:
int _close_r(
struct _reent *ptr RTEMS_UNUSED,
int fd
)
{
return close( fd );
4000ea3c: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
4000ea40: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000ea44: 7f ff ff c8 call 4000e964 <close>
<== NOT EXECUTED
4000ea48: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000fcb4 <_free_r>:
struct _reent *ignored,
void *ptr
)
{
(void) ignored;
free( ptr );
4000fcb4: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
4000fcb8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000fcbc: 7f ff d1 b1 call 40004380 <free>
<== NOT EXECUTED
4000fcc0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40018260 <_fstat_r>:
int _fstat_r(
struct _reent *ptr RTEMS_UNUSED,
int fd,
struct stat *buf
)
{
40018260: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
return fstat( fd, buf );
40018264: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
40018268: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4001826c: 7f ff ff c3 call 40018178 <fstat>
<== NOT EXECUTED
40018270: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40004470 <_gettimeofday_r>:
int _gettimeofday_r(
struct _reent *ignored_reentrancy_stuff RTEMS_UNUSED,
struct timeval *tp,
void *__tz
)
{
40004470: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !tp )
40004474: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40004478: 02 80 00 06 be 40004490 <_gettimeofday_r+0x20>
<== NOT EXECUTED
4000447c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40004480: 40 00 10 f6 call 40008858 <_Timecounter_Microtime>
<== NOT EXECUTED
40004484: b0 10 20 00 clr %i0
<== NOT EXECUTED
struct timezone *tzp = __tz;
return gettimeofday( tp, tzp );
}
40004488: 81 c7 e0 08 ret
<== NOT EXECUTED
4000448c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
40004490: 40 00 29 77 call 4000ea6c <__errno>
<== NOT EXECUTED
40004494: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004498: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
4000449c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400044a0: 81 c7 e0 08 ret
<== NOT EXECUTED
400044a4: 81 e8 00 00 restore
<== NOT EXECUTED
40018274 <_isatty_r>:
struct _reent *ptr,
int fd
)
{
(void) ptr;
return isatty( fd );
40018274: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
40018278: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4001827c: 40 00 01 55 call 400187d0 <isatty>
<== NOT EXECUTED
40018280: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40018344 <_lseek_r>:
struct _reent *ptr RTEMS_UNUSED,
int fd,
off_t offset,
int whence
)
{
40018344: 86 10 00 0b mov %o3, %g3
<== NOT EXECUTED
return lseek( fd, offset, whence );
40018348: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
4001834c: 96 10 00 0c mov %o4, %o3
<== NOT EXECUTED
40018350: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
40018354: 94 10 00 03 mov %g3, %o2
<== NOT EXECUTED
40018358: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4001835c: 7f ff ff ca call 40018284 <lseek>
<== NOT EXECUTED
40018360: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40018364 <_malloc_r>:
struct _reent *ignored,
size_t size
)
{
(void) ignored;
return malloc( size );
40018364: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
40018368: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4001836c: 7f ff b4 8e call 400055a4 <malloc>
<== NOT EXECUTED
40018370: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4001845c <_read_r>:
struct _reent *ptr RTEMS_UNUSED,
int fd,
void *buf,
size_t nbytes
)
{
4001845c: 82 10 00 0a mov %o2, %g1
<== NOT EXECUTED
return read( fd, buf, nbytes );
40018460: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
40018464: 94 10 00 0b mov %o3, %o2
<== NOT EXECUTED
40018468: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
4001846c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40018470: 7f ff ff c1 call 40018374 <read>
<== NOT EXECUTED
40018474: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40018478 <_realloc_r>:
void *_realloc_r(
struct _reent *ignored,
void *ptr,
size_t size
)
{
40018478: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
(void) ignored;
return realloc( ptr, size );
4001847c: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
40018480: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40018484: 40 00 00 09 call 400184a8 <realloc>
<== NOT EXECUTED
40018488: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4001848c <_write_r>:
struct _reent *ptr RTEMS_UNUSED,
int fd,
const void *buf,
size_t nbytes
)
{
4001848c: 82 10 00 0a mov %o2, %g1
<== NOT EXECUTED
return write( fd, buf, nbytes );
40018490: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
40018494: 94 10 00 0b mov %o3, %o2
<== NOT EXECUTED
40018498: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
4001849c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400184a0: 40 00 00 48 call 400185c0 <write>
<== NOT EXECUTED
400184a4: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000e978 <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
4000e978: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_t *iop;
unsigned int flags;
int rc;
if ( (uint32_t) fd >= rtems_libio_number_iops ) {
4000e97c: 03 10 00 40 sethi %hi(0x40010000), %g1
<== NOT EXECUTED
4000e980: c2 00 61 e8 ld [ %g1 + 0x1e8 ], %g1 ! 400101e8 <rtems_libio_number_iops>
<== NOT EXECUTED
4000e984: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
4000e988: 1a 80 00 1b bcc 4000e9f4 <close+0x7c>
<== NOT EXECUTED
4000e98c: 01 00 00 00 nop
<== NOT EXECUTED
4000e990: b7 2e 20 01 sll %i0, 1, %i3
<== NOT EXECUTED
4000e994: b0 06 c0 18 add %i3, %i0, %i0
<== NOT EXECUTED
4000e998: 37 10 00 4c sethi %hi(0x40013000), %i3
<== NOT EXECUTED
4000e99c: b9 2e 20 04 sll %i0, 4, %i4
<== NOT EXECUTED
4000e9a0: b6 16 e2 20 or %i3, 0x220, %i3
<== NOT EXECUTED
4000e9a4: b8 06 c0 1c add %i3, %i4, %i4
<== NOT EXECUTED
4000e9a8: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
unsigned int actual;
(void) succ;
(void) fail;
_ISR_Local_disable( level );
actual = *obj;
4000e9ac: 10 80 00 0f b 4000e9e8 <close+0x70>
<== NOT EXECUTED
4000e9b0: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e9b4: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000e9b8: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
success = ( actual == *expected );
if ( success ) {
4000e9bc: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
4000e9c0: 12 80 00 03 bne 4000e9cc <close+0x54>
<== NOT EXECUTED
4000e9c4: 84 08 ae ff and %g2, 0xeff, %g2
<== NOT EXECUTED
*obj = desired;
4000e9c8: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e9cc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e9d0: 01 00 00 00 nop
<== NOT EXECUTED
desired,
ATOMIC_ORDER_ACQ_REL,
ATOMIC_ORDER_RELAXED
);
if ( success ) {
4000e9d4: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
4000e9d8: 02 80 00 0d be 4000ea0c <close+0x94>
<== NOT EXECUTED
4000e9dc: 80 88 f0 00 btst -4096, %g3
<== NOT EXECUTED
break;
}
if ( ( flags & ~( LIBIO_FLAGS_REFERENCE_INC - 1U ) ) != 0 ) {
4000e9e0: 12 80 00 16 bne 4000ea38 <close+0xc0>
<== NOT EXECUTED
4000e9e4: 84 10 00 03 mov %g3, %g2
<== NOT EXECUTED
if ( ( flags & LIBIO_FLAGS_OPEN ) == 0 ) {
4000e9e8: 80 88 a1 00 btst 0x100, %g2
<== NOT EXECUTED
4000e9ec: 12 bf ff f2 bne 4000e9b4 <close+0x3c>
<== NOT EXECUTED
4000e9f0: 88 08 af ff and %g2, 0xfff, %g4
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
4000e9f4: 40 00 00 1e call 4000ea6c <__errno>
<== NOT EXECUTED
4000e9f8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000e9fc: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4000ea00: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000ea04: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ea08: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
}
}
rc = (*iop->pathinfo.handlers->close_h)( iop );
4000ea0c: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
4000ea10: b6 06 c0 18 add %i3, %i0, %i3
<== NOT EXECUTED
4000ea14: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
<== NOT EXECUTED
4000ea18: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4000ea1c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000ea20: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000ea24: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
rtems_libio_free( iop );
4000ea28: 7f ff fc f9 call 4000de0c <rtems_libio_free>
<== NOT EXECUTED
4000ea2c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return rc;
}
4000ea30: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ea34: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
4000ea38: 40 00 00 0d call 4000ea6c <__errno>
<== NOT EXECUTED
4000ea3c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000ea40: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000ea44: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000ea48: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ea4c: 81 e8 00 00 restore
<== NOT EXECUTED
40004380 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40004380: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !ptr )
40004384: ba 96 20 00 orcc %i0, 0, %i5
<== NOT EXECUTED
40004388: 02 80 00 0d be 400043bc <free+0x3c>
<== NOT EXECUTED
4000438c: 01 00 00 00 nop
<== NOT EXECUTED
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _Malloc_System_state() != MALLOC_SYSTEM_STATE_NORMAL ) {
40004390: 40 00 00 7a call 40004578 <_Malloc_System_state>
<== NOT EXECUTED
40004394: 01 00 00 00 nop
<== NOT EXECUTED
40004398: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000439c: 12 80 00 0a bne 400043c4 <free+0x44>
<== NOT EXECUTED
400043a0: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
_Malloc_Deferred_free(ptr);
return;
}
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
400043a4: d0 00 63 0c ld [ %g1 + 0x30c ], %o0 ! 40011f0c <RTEMS_Malloc_Heap>
<== NOT EXECUTED
400043a8: 40 00 13 87 call 400091c4 <_Protected_heap_Free>
<== NOT EXECUTED
400043ac: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
400043b0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400043b4: 02 80 00 06 be 400043cc <free+0x4c>
<== NOT EXECUTED
400043b8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
rtems_fatal( RTEMS_FATAL_SOURCE_INVALID_HEAP_FREE, (rtems_fatal_code) ptr );
}
}
400043bc: 81 c7 e0 08 ret
<== NOT EXECUTED
400043c0: 81 e8 00 00 restore
<== NOT EXECUTED
_Malloc_Deferred_free(ptr);
400043c4: 40 00 00 cf call 40004700 <_Malloc_Deferred_free>
<== NOT EXECUTED
400043c8: 81 e8 00 00 restore
<== NOT EXECUTED
400043cc: 40 00 0d 79 call 400079b0 <_Terminate>
<== NOT EXECUTED
400043d0: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
400043d4: 01 00 00 00 nop
<== NOT EXECUTED
40018178 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
40018178: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
4001817c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40018180: 02 80 00 32 be 40018248 <fstat+0xd0>
<== NOT EXECUTED
40018184: 03 10 00 64 sethi %hi(0x40019000), %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
LIBIO_GET_IOP( fd, iop );
40018188: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 40019158 <rtems_libio_number_iops>
<== NOT EXECUTED
4001818c: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
40018190: 1a 80 00 28 bcc 40018230 <fstat+0xb8>
<== NOT EXECUTED
40018194: 91 2e 20 01 sll %i0, 1, %o0
<== NOT EXECUTED
40018198: 39 10 00 72 sethi %hi(0x4001c800), %i4
<== NOT EXECUTED
4001819c: b0 02 00 18 add %o0, %i0, %i0
<== NOT EXECUTED
400181a0: b8 17 20 c0 or %i4, 0xc0, %i4
<== NOT EXECUTED
400181a4: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
400181a8: ba 06 00 1c add %i0, %i4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400181ac: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400181b0: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400181b4: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400181b8: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400181bc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400181c0: 01 00 00 00 nop
<== NOT EXECUTED
400181c4: 80 88 a1 00 btst 0x100, %g2
<== NOT EXECUTED
400181c8: 02 80 00 14 be 40018218 <fstat+0xa0>
<== NOT EXECUTED
400181cc: 94 10 20 60 mov 0x60, %o2
<== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
400181d0: 92 10 20 00 clr %o1
<== NOT EXECUTED
400181d4: 7f ff db d2 call 4000f11c <memset>
<== NOT EXECUTED
400181d8: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
400181dc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
400181e0: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
<== NOT EXECUTED
400181e4: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
400181e8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400181ec: 9f c0 40 00 call %g1
<== NOT EXECUTED
400181f0: 90 07 00 08 add %i4, %o0, %o0
<== NOT EXECUTED
400181f4: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400181f8: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
400181fc: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40018200: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018204: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018208: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001820c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
return rv;
}
40018210: 81 c7 e0 08 ret
<== NOT EXECUTED
40018214: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018218: 91 d0 20 09 ta 9
<== NOT EXECUTED
4001821c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40018220: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018224: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018228: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001822c: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
40018230: 7f ff da 0e call 4000ea68 <__errno>
<== NOT EXECUTED
40018234: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40018238: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4001823c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40018240: 81 c7 e0 08 ret
<== NOT EXECUTED
40018244: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
40018248: 7f ff da 08 call 4000ea68 <__errno>
<== NOT EXECUTED
4001824c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40018250: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
40018254: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40018258: 81 c7 e0 08 ret
<== NOT EXECUTED
4001825c: 81 e8 00 00 restore
<== NOT EXECUTED
4000dc60 <ftruncate>:
#include <unistd.h>
#include <rtems/libio_.h>
int ftruncate( int fd, off_t length )
{
4000dc60: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
if ( length >= 0 ) {
4000dc64: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000dc68: 06 80 00 39 bl 4000dd4c <ftruncate+0xec>
<== NOT EXECUTED
4000dc6c: 03 10 00 40 sethi %hi(0x40010000), %g1
<== NOT EXECUTED
rtems_libio_t *iop;
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
4000dc70: c2 00 61 e8 ld [ %g1 + 0x1e8 ], %g1 ! 400101e8 <rtems_libio_number_iops>
<== NOT EXECUTED
4000dc74: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
4000dc78: 1a 80 00 1f bcc 4000dcf4 <ftruncate+0x94>
<== NOT EXECUTED
4000dc7c: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
4000dc80: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
4000dc84: 31 10 00 4c sethi %hi(0x40013000), %i0
<== NOT EXECUTED
4000dc88: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
4000dc8c: b0 16 22 20 or %i0, 0x220, %i0
<== NOT EXECUTED
4000dc90: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dc94: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000dc98: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4000dc9c: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4000dca0: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dca4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dca8: 01 00 00 00 nop
<== NOT EXECUTED
4000dcac: 82 08 a1 04 and %g2, 0x104, %g1
<== NOT EXECUTED
4000dcb0: 80 a0 61 04 cmp %g1, 0x104
<== NOT EXECUTED
4000dcb4: 12 80 00 16 bne 4000dd0c <ftruncate+0xac>
<== NOT EXECUTED
4000dcb8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
rv = (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
4000dcbc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000dcc0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4000dcc4: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000dcc8: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dccc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000dcd0: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dcd4: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000dcd8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000dcdc: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000dce0: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dce4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dce8: 01 00 00 00 nop
<== NOT EXECUTED
4000dcec: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dcf0: 81 e8 00 00 restore
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
4000dcf4: 40 00 03 5e call 4000ea6c <__errno>
<== NOT EXECUTED
4000dcf8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000dcfc: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4000dd00: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000dd04: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dd08: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dd0c: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000dd10: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
4000dd14: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
4000dd18: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dd1c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dd20: 01 00 00 00 nop
<== NOT EXECUTED
4000dd24: 84 08 a1 00 and %g2, 0x100, %g2
<== NOT EXECUTED
4000dd28: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
4000dd2c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000dd30: 40 00 03 4f call 4000ea6c <__errno>
<== NOT EXECUTED
4000dd34: ba 60 20 00 subx %g0, 0, %i5
<== NOT EXECUTED
4000dd38: ba 0f 60 0d and %i5, 0xd, %i5
<== NOT EXECUTED
4000dd3c: ba 07 60 09 add %i5, 9, %i5
<== NOT EXECUTED
4000dd40: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
4000dd44: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dd48: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
} else {
errno = EINVAL;
4000dd4c: 40 00 03 48 call 4000ea6c <__errno>
<== NOT EXECUTED
4000dd50: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000dd54: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000dd58: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
4000dd5c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dd60: 81 e8 00 00 restore
<== NOT EXECUTED
400043d8 <getchark>:
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
400043d8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( BSP_poll_char )
400043dc: 03 10 00 48 sethi %hi(0x40012000), %g1
<== NOT EXECUTED
400043e0: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 400122e0 <BSP_poll_char>
<== NOT EXECUTED
400043e4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400043e8: 02 80 00 06 be 40004400 <getchark+0x28>
<== NOT EXECUTED
400043ec: 01 00 00 00 nop
<== NOT EXECUTED
return (*BSP_poll_char)();
400043f0: 9f c2 00 00 call %o0
<== NOT EXECUTED
400043f4: 01 00 00 00 nop
<== NOT EXECUTED
400043f8: 81 c7 e0 08 ret
<== NOT EXECUTED
400043fc: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
return -1;
}
40004400: 81 c7 e0 08 ret
<== NOT EXECUTED
40004404: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40004438 <gettimeofday>:
*/
int gettimeofday(
struct timeval *__restrict tp,
void *__restrict __tz RTEMS_UNUSED
)
{
40004438: 9d e3 bf a0 save %sp, -96, %sp
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
4000443c: 80 a6 20 00 cmp %i0, 0
40004440: 02 80 00 06 be 40004458 <gettimeofday+0x20>
<== NEVER TAKEN
40004444: 90 10 00 18 mov %i0, %o0
RTEMS_INLINE_ROUTINE void _TOD_Get_timeval(
struct timeval *time
)
{
_Timecounter_Microtime( time );
40004448: 40 00 11 04 call 40008858 <_Timecounter_Microtime>
4000444c: b0 10 20 00 clr %i0
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
}
40004450: 81 c7 e0 08 ret
40004454: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EFAULT );
40004458: 40 00 29 85 call 4000ea6c <__errno>
<== NOT EXECUTED
4000445c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004460: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
40004464: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004468: 81 c7 e0 08 ret
<== NOT EXECUTED
4000446c: 81 e8 00 00 restore
<== NOT EXECUTED
40018284 <lseek>:
#include <unistd.h>
#include <rtems/libio_.h>
off_t lseek( int fd, off_t offset, int whence )
{
40018284: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_t *iop;
off_t rv;
LIBIO_GET_IOP( fd, iop );
40018288: 03 10 00 64 sethi %hi(0x40019000), %g1
<== NOT EXECUTED
4001828c: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 40019158 <rtems_libio_number_iops>
<== NOT EXECUTED
40018290: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
40018294: 1a 80 00 26 bcc 4001832c <lseek+0xa8>
<== NOT EXECUTED
40018298: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
4001829c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400182a0: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
400182a4: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400182a8: b0 16 20 c0 or %i0, 0xc0, %i0
<== NOT EXECUTED
400182ac: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400182b0: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400182b4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400182b8: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400182bc: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400182c0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400182c4: 01 00 00 00 nop
<== NOT EXECUTED
400182c8: 80 88 a1 00 btst 0x100, %g2
<== NOT EXECUTED
400182cc: 02 80 00 12 be 40018314 <lseek+0x90>
<== NOT EXECUTED
400182d0: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
rv = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
400182d4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
400182d8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
400182dc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400182e0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
400182e4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400182e8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400182ec: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
400182f0: b2 10 00 09 mov %o1, %i1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400182f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
400182f8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400182fc: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018300: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018304: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018308: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
return rv;
}
4001830c: 81 c7 e0 08 ret
<== NOT EXECUTED
40018310: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018314: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018318: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4001831c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018320: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018324: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018328: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
4001832c: 7f ff d9 cf call 4000ea68 <__errno>
<== NOT EXECUTED
40018330: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40018334: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40018338: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4001833c: 81 c7 e0 08 ret
<== NOT EXECUTED
40018340: 93 e8 3f ff restore %g0, -1, %o1
<== NOT EXECUTED
400047bc <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
400047bc: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Validate the parameters
*/
if ( !size )
400047c0: 80 a6 20 00 cmp %i0, 0
400047c4: 02 80 00 0a be 400047ec <malloc+0x30>
<== NEVER TAKEN
400047c8: 90 10 00 18 mov %i0, %o0
return (void *) 0;
return_this = rtems_heap_allocate_aligned_with_boundary( size, 0, 0 );
400047cc: 94 10 20 00 clr %o2
400047d0: 7f ff ff 92 call 40004618 <rtems_heap_allocate_aligned_with_boundary>
400047d4: 92 10 20 00 clr %o1
if ( !return_this ) {
400047d8: b0 92 20 00 orcc %o0, 0, %i0
400047dc: 02 80 00 06 be 400047f4 <malloc+0x38>
<== NEVER TAKEN
400047e0: 01 00 00 00 nop
errno = ENOMEM;
return (void *) 0;
}
return return_this;
}
400047e4: 81 c7 e0 08 ret
400047e8: 81 e8 00 00 restore
400047ec: 81 c7 e0 08 ret
<== NOT EXECUTED
400047f0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
errno = ENOMEM;
400047f4: 40 00 28 9e call 4000ea6c <__errno>
<== NOT EXECUTED
400047f8: 01 00 00 00 nop
<== NOT EXECUTED
400047fc: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
40004800: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return (void *) 0;
40004804: 81 c7 e0 08 ret
<== NOT EXECUTED
40004808: 81 e8 00 00 restore
<== NOT EXECUTED
4000492c <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
4000492c: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
40004930: 80 a6 e0 01 cmp %i3, 1
40004934: 18 80 00 b2 bgu 40004bfc <mount+0x2d0>
<== NEVER TAKEN
40004938: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
4000493c: 40 00 25 7d call 4000df30 <rtems_filesystem_get_mount_handler>
40004940: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
40004944: a2 92 20 00 orcc %o0, 0, %l1
40004948: 02 80 00 ad be 40004bfc <mount+0x2d0>
<== NEVER TAKEN
4000494c: 80 a6 60 00 cmp %i1, 0
const char *target = target_or_null != NULL ? target_or_null : "/";
40004950: 02 80 00 78 be 40004b30 <mount+0x204>
<== ALWAYS TAKEN
40004954: 90 10 00 19 mov %i1, %o0
40004958: 40 00 29 95 call 4000efac <strlen>
<== NOT EXECUTED
4000495c: a6 10 00 19 mov %i1, %l3
<== NOT EXECUTED
40004960: a4 02 20 01 add %o0, 1, %l2
<== NOT EXECUTED
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40004964: 40 00 29 92 call 4000efac <strlen>
40004968: 90 10 00 1a mov %i2, %o0
strlen( source_or_null ) + 1 : 0;
4000496c: 80 a6 20 00 cmp %i0, 0
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40004970: a8 02 20 01 add %o0, 1, %l4
strlen( source_or_null ) + 1 : 0;
40004974: 02 80 00 61 be 40004af8 <mount+0x1cc>
<== ALWAYS TAKEN
40004978: ba 02 20 65 add %o0, 0x65, %i5
4000497c: 40 00 29 8c call 4000efac <strlen>
<== NOT EXECUTED
40004980: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
40004984: 92 07 40 12 add %i5, %l2, %o1
<== NOT EXECUTED
strlen( source_or_null ) + 1 : 0;
40004988: a0 02 20 01 add %o0, 1, %l0
<== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
4000498c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
40004990: 7f ff fe 31 call 40004254 <calloc>
<== NOT EXECUTED
40004994: 92 02 40 10 add %o1, %l0, %o1
<== NOT EXECUTED
if ( mt_entry != NULL ) {
40004998: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4000499c: 12 80 00 08 bne 400049bc <mount+0x90>
<== NOT EXECUTED
400049a0: 84 07 60 64 add %i5, 0x64, %g2
<== NOT EXECUTED
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
400049a4: 40 00 28 32 call 4000ea6c <__errno>
<== NOT EXECUTED
400049a8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400049ac: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
400049b0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400049b4: 81 c7 e0 08 ret
<== NOT EXECUTED
400049b8: 81 e8 00 00 restore
<== NOT EXECUTED
memcpy( str, filesystemtype, filesystemtype_size );
400049bc: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
400049c0: 94 10 00 14 mov %l4, %o2
<== NOT EXECUTED
400049c4: 40 00 28 58 call 4000eb24 <memcpy>
<== NOT EXECUTED
400049c8: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
mt_entry->type = str;
400049cc: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
<== NOT EXECUTED
str += filesystemtype_size;
400049d0: 84 02 00 14 add %o0, %l4, %g2
<== NOT EXECUTED
memcpy( str, source_or_null, source_size );
400049d4: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
400049d8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400049dc: 40 00 28 52 call 4000eb24 <memcpy>
<== NOT EXECUTED
400049e0: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
mt_entry->dev = str;
400049e4: d0 27 60 38 st %o0, [ %i5 + 0x38 ]
<== NOT EXECUTED
rtems_filesystem_global_location_t *mt_fs_root =
400049e8: b4 07 60 40 add %i5, 0x40, %i2
<== NOT EXECUTED
str += source_size;
400049ec: a0 02 00 10 add %o0, %l0, %l0
<== NOT EXECUTED
memcpy( str, target, target_size );
400049f0: 94 10 00 12 mov %l2, %o2
400049f4: 92 10 00 13 mov %l3, %o1
400049f8: 40 00 28 4b call 4000eb24 <memcpy>
400049fc: 90 10 00 10 mov %l0, %o0
mt_entry->mounted = true;
40004a00: 82 10 20 01 mov 1, %g1
40004a04: c2 2f 60 28 stb %g1, [ %i5 + 0x28 ]
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40004a08: 03 10 00 41 sethi %hi(0x40010400), %g1
40004a0c: 82 10 61 10 or %g1, 0x110, %g1 ! 40010510 <rtems_filesystem_default_pathconf>
mt_entry->target = str;
40004a10: e0 27 60 30 st %l0, [ %i5 + 0x30 ]
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize(
40004a14: 96 10 20 24 mov 0x24, %o3
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40004a18: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->reference_count = 1;
40004a1c: 82 10 20 01 mov 1, %g1
mt_entry->mt_fs_root = mt_fs_root;
40004a20: f4 27 60 24 st %i2, [ %i5 + 0x24 ]
40004a24: 94 10 20 01 mov 1, %o2
mt_fs_root->reference_count = 1;
40004a28: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
40004a2c: 92 10 00 1a mov %i2, %o1
mt_fs_root->location.mt_entry = mt_entry;
40004a30: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
40004a34: 90 07 60 14 add %i5, 0x14, %o0
40004a38: 40 00 09 e5 call 400071cc <_Chain_Initialize>
40004a3c: b6 0e e0 01 and %i3, 1, %i3
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
40004a40: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
40004a44: 92 10 00 1c mov %i4, %o1
40004a48: 9f c4 40 00 call %l1
40004a4c: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40004a50: b0 92 20 00 orcc %o0, 0, %i0
40004a54: 12 80 00 25 bne 40004ae8 <mount+0x1bc>
<== NEVER TAKEN
40004a58: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
40004a5c: 02 80 00 48 be 40004b7c <mount+0x250>
<== ALWAYS TAKEN
40004a60: 94 10 20 1f mov 0x1f, %o2
rtems_filesystem_location_info_t *currentloc =
40004a64: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40004a68: 40 00 03 02 call 40005670 <rtems_filesystem_eval_path_start>
<== NOT EXECUTED
40004a6c: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40004a70: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
return (*mt_entry->ops->are_nodes_equal_h)(
40004a74: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40004a78: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
40004a7c: 9f c0 80 00 call %g2
<== NOT EXECUTED
40004a80: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
<== NOT EXECUTED
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
40004a84: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40004a88: 12 80 00 63 bne 40004c14 <mount+0x2e8>
<== NOT EXECUTED
40004a8c: 92 07 bf e0 add %fp, -32, %o1
<== NOT EXECUTED
rtems_filesystem_location_copy_and_detach(
40004a90: 40 00 04 4e call 40005bc8 <rtems_filesystem_location_copy_and_detach>
<== NOT EXECUTED
40004a94: 90 07 bf b0 add %fp, -80, %o0
<== NOT EXECUTED
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40004a98: 40 00 04 77 call 40005c74 <rtems_filesystem_location_transform_to_global>
<== NOT EXECUTED
40004a9c: 90 07 bf b0 add %fp, -80, %o0
<== NOT EXECUTED
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40004aa0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
40004aa4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
mt_entry->mt_point_node = mt_point_node;
40004aa8: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
<== NOT EXECUTED
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40004aac: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40004ab0: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
<== NOT EXECUTED
40004ab4: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004ab8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
40004abc: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40004ac0: 02 80 00 20 be 40004b40 <mount+0x214>
<== NOT EXECUTED
40004ac4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
rtems_filesystem_global_location_release( mt_point_node, true );
40004ac8: 40 00 03 fb call 40005ab4 <rtems_filesystem_global_location_release>
<== NOT EXECUTED
40004acc: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40004ad0: 40 00 02 f4 call 400056a0 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40004ad4: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40004ad8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
40004adc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
<== NOT EXECUTED
40004ae0: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004ae4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
free( mt_entry );
40004ae8: 7f ff fe 26 call 40004380 <free>
<== NOT EXECUTED
40004aec: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
errno = EINVAL;
rv = -1;
}
return rv;
}
40004af0: 81 c7 e0 08 ret
<== NOT EXECUTED
40004af4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
40004af8: 92 07 40 12 add %i5, %l2, %o1
40004afc: 7f ff fd d6 call 40004254 <calloc>
40004b00: 90 10 20 01 mov 1, %o0
if ( mt_entry != NULL ) {
40004b04: ba 92 20 00 orcc %o0, 0, %i5
40004b08: 02 bf ff a7 be 400049a4 <mount+0x78>
<== NEVER TAKEN
40004b0c: 84 07 60 64 add %i5, 0x64, %g2
memcpy( str, filesystemtype, filesystemtype_size );
40004b10: 92 10 00 1a mov %i2, %o1
40004b14: 94 10 00 14 mov %l4, %o2
40004b18: 90 10 00 02 mov %g2, %o0
40004b1c: 40 00 28 02 call 4000eb24 <memcpy>
40004b20: b4 07 60 40 add %i5, 0x40, %i2
str += filesystemtype_size;
40004b24: a0 02 00 14 add %o0, %l4, %l0
mt_entry->type = str;
40004b28: 10 bf ff b2 b 400049f0 <mount+0xc4>
40004b2c: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
const char *target = target_or_null != NULL ? target_or_null : "/";
40004b30: 27 10 00 40 sethi %hi(0x40010000), %l3
40004b34: a4 10 20 02 mov 2, %l2
40004b38: 10 bf ff 8b b 40004964 <mount+0x38>
40004b3c: a6 14 e1 58 or %l3, 0x158, %l3
rtems_libio_lock();
40004b40: 7f ff fe 84 call 40004550 <rtems_libio_lock>
<== NOT EXECUTED
40004b44: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
40004b48: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
40004b4c: 82 10 63 44 or %g1, 0x344, %g1 ! 40011f44 <rtems_filesystem_mount_table>
<== NOT EXECUTED
40004b50: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
the_node->next = tail;
40004b54: 86 00 60 04 add %g1, 4, %g3
<== NOT EXECUTED
tail->previous = the_node;
40004b58: fa 20 60 08 st %i5, [ %g1 + 8 ]
<== NOT EXECUTED
the_node->next = tail;
40004b5c: c6 27 40 00 st %g3, [ %i5 ]
<== NOT EXECUTED
old_last->next = the_node;
40004b60: fa 20 80 00 st %i5, [ %g2 ]
<== NOT EXECUTED
rtems_libio_unlock();
40004b64: 7f ff fe 80 call 40004564 <rtems_libio_unlock>
<== NOT EXECUTED
40004b68: c4 27 60 04 st %g2, [ %i5 + 4 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40004b6c: 40 00 02 cd call 400056a0 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40004b70: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
40004b74: 81 c7 e0 08 ret
<== NOT EXECUTED
40004b78: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_libio_lock();
40004b7c: 7f ff fe 75 call 40004550 <rtems_libio_lock>
40004b80: 01 00 00 00 nop
return _Chain_Immutable_head( the_chain )->next;
40004b84: 03 10 00 47 sethi %hi(0x40011c00), %g1
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
40004b88: c4 00 63 44 ld [ %g1 + 0x344 ], %g2 ! 40011f44 <rtems_filesystem_mount_table>
40004b8c: 82 10 63 44 or %g1, 0x344, %g1
40004b90: 86 00 60 04 add %g1, 4, %g3
40004b94: 80 a0 80 03 cmp %g2, %g3
40004b98: 12 80 00 27 bne 40004c34 <mount+0x308>
<== NEVER TAKEN
40004b9c: 01 00 00 00 nop
old_last = tail->previous;
40004ba0: c6 00 60 08 ld [ %g1 + 8 ], %g3
the_node->next = tail;
40004ba4: c4 27 40 00 st %g2, [ %i5 ]
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
40004ba8: b8 07 60 24 add %i5, 0x24, %i4
tail->previous = the_node;
40004bac: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
40004bb0: fa 20 c0 00 st %i5, [ %g3 ]
rtems_libio_unlock();
40004bb4: 7f ff fe 6c call 40004564 <rtems_libio_unlock>
40004bb8: c6 27 60 04 st %g3, [ %i5 + 4 ]
rtems_filesystem_global_location_t *new_fs_root =
40004bbc: 40 00 03 84 call 400059cc <rtems_filesystem_global_location_obtain>
40004bc0: 90 10 00 1c mov %i4, %o0
40004bc4: b6 10 00 08 mov %o0, %i3
rtems_filesystem_global_location_t *new_fs_current =
40004bc8: 40 00 03 81 call 400059cc <rtems_filesystem_global_location_obtain>
40004bcc: 90 10 00 1c mov %i4, %o0
&rtems_filesystem_root,
40004bd0: 40 00 00 fa call 40004fb8 <rtems_current_user_env_get>
40004bd4: ba 10 00 08 mov %o0, %i5
rtems_filesystem_global_location_assign(
40004bd8: 92 10 00 1b mov %i3, %o1
40004bdc: 40 00 03 d0 call 40005b1c <rtems_filesystem_global_location_assign>
40004be0: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_current,
40004be4: 40 00 00 f5 call 40004fb8 <rtems_current_user_env_get>
40004be8: 01 00 00 00 nop
rtems_filesystem_global_location_assign(
40004bec: 40 00 03 cc call 40005b1c <rtems_filesystem_global_location_assign>
40004bf0: 92 10 00 1d mov %i5, %o1
40004bf4: 81 c7 e0 08 ret
40004bf8: 81 e8 00 00 restore
errno = EINVAL;
40004bfc: 40 00 27 9c call 4000ea6c <__errno>
<== NOT EXECUTED
40004c00: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004c04: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40004c08: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return rv;
40004c0c: 81 c7 e0 08 ret
<== NOT EXECUTED
40004c10: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_eval_path_error( &ctx, EBUSY );
40004c14: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
40004c18: 40 00 01 db call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40004c1c: 92 10 20 10 mov 0x10, %o1
<== NOT EXECUTED
rv = -1;
40004c20: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40004c24: 40 00 02 9f call 400056a0 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40004c28: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40004c2c: 10 bf ff ac b 40004adc <mount+0x1b0>
<== NOT EXECUTED
40004c30: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
errno = EINVAL;
40004c34: 40 00 27 8e call 4000ea6c <__errno>
<== NOT EXECUTED
40004c38: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004c3c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40004c40: 7f ff fe 49 call 40004564 <rtems_libio_unlock>
<== NOT EXECUTED
40004c44: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40004c48: 10 bf ff a5 b 40004adc <mount+0x1b0>
<== NOT EXECUTED
40004c4c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
40004d4c <open>:
/**
* POSIX 1003.1 5.3.1 - Open a File
*/
int open( const char *path, int oflag, ... )
{
40004d4c: 9d e3 bf 00 save %sp, -256, %sp
mode_t mode = 0;
rtems_libio_t *iop = NULL;
va_start( ap, oflag );
mode = va_arg( ap, mode_t );
40004d50: 82 07 a0 50 add %fp, 0x50, %g1
va_start( ap, oflag );
40004d54: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
40004d58: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40004d5c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40004d60: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
iop = rtems_libio_allocate();
40004d64: 40 00 24 15 call 4000ddb8 <rtems_libio_allocate>
40004d68: c2 27 bf 64 st %g1, [ %fp + -156 ]
if ( iop != NULL ) {
40004d6c: ba 92 20 00 orcc %o0, 0, %i5
40004d70: 02 80 00 76 be 40004f48 <open+0x1fc>
<== NEVER TAKEN
40004d74: 82 06 60 01 add %i1, 1, %g1
bool make = (oflag & O_CREAT) == O_CREAT;
40004d78: 86 0e 62 00 and %i1, 0x200, %g3
bool read_access = (rwflag & _FREAD) == _FREAD;
40004d7c: 94 08 60 01 and %g1, 1, %o2
bool exclusive = (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
40004d80: 84 0e 6a 00 and %i1, 0xa00, %g2
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40004d84: 94 02 bf ff add %o2, -1, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40004d88: b8 88 60 02 andcc %g1, 2, %i4
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40004d8c: 94 0a bf fc and %o2, -4, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40004d90: 02 80 00 03 be 40004d9c <open+0x50>
40004d94: 94 02 a0 1c add %o2, 0x1c, %o2
40004d98: 94 12 a0 02 or %o2, 2, %o2
| (make ? RTEMS_FS_MAKE : 0)
40004d9c: 80 a0 e0 00 cmp %g3, 0
40004da0: 32 80 00 02 bne,a 40004da8 <open+0x5c>
<== NEVER TAKEN
40004da4: 94 12 a0 20 or %o2, 0x20, %o2
<== NOT EXECUTED
| (exclusive ? RTEMS_FS_EXCLUSIVE : 0);
40004da8: 80 a0 aa 00 cmp %g2, 0xa00
40004dac: 22 80 00 02 be,a 40004db4 <open+0x68>
<== NEVER TAKEN
40004db0: 94 12 a0 40 or %o2, 0x40, %o2
<== NOT EXECUTED
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
40004db4: 92 10 00 18 mov %i0, %o1
40004db8: 40 00 02 2e call 40005670 <rtems_filesystem_eval_path_start>
40004dbc: 90 07 bf 68 add %fp, -152, %o0
40004dc0: f6 07 bf 74 ld [ %fp + -140 ], %i3
if ( rtems_filesystem_eval_path_has_token( &ctx ) ) {
40004dc4: 80 a6 e0 00 cmp %i3, 0
40004dc8: 12 80 00 45 bne 40004edc <open+0x190>
<== NEVER TAKEN
40004dcc: 80 a7 20 00 cmp %i4, 0
if ( write_access ) {
40004dd0: 02 80 00 0e be 40004e08 <open+0xbc>
40004dd4: c2 07 bf 90 ld [ %fp + -112 ], %g1
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
40004dd8: c0 27 bf ac clr [ %fp + -84 ]
(void) ( *loc->handlers->fstat_h )( loc, &st );
40004ddc: 92 07 bf a0 add %fp, -96, %o1
40004de0: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40004de4: 9f c0 40 00 call %g1
40004de8: 90 07 bf 80 add %fp, -128, %o0
if ( S_ISDIR( type ) ) {
40004dec: 05 00 00 3c sethi %hi(0xf000), %g2
40004df0: c2 07 bf ac ld [ %fp + -84 ], %g1
40004df4: 82 08 40 02 and %g1, %g2, %g1
40004df8: 05 00 00 10 sethi %hi(0x4000), %g2
40004dfc: 80 a0 40 02 cmp %g1, %g2
40004e00: 02 80 00 4e be 40004f38 <open+0x1ec>
<== NEVER TAKEN
40004e04: 92 10 20 15 mov 0x15, %o1
rtems_filesystem_location_copy_and_detach(
40004e08: 92 07 bf 80 add %fp, -128, %o1
40004e0c: 40 00 03 6f call 40005bc8 <rtems_filesystem_location_copy_and_detach>
40004e10: 90 07 60 0c add %i5, 0xc, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
40004e14: 40 00 02 23 call 400056a0 <rtems_filesystem_eval_path_cleanup>
40004e18: 90 07 bf 68 add %fp, -152, %o0
_Atomic_Store_uint(
40004e1c: 40 00 23 da call 4000dd84 <rtems_libio_fcntl_flags>
40004e20: 90 10 00 19 mov %i1, %o0
rv = (*iop->pathinfo.handlers->open_h)( iop, path, oflag, mode );
40004e24: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
atomic_store_explicit( obj, desired, order );
#else
(void) order;
RTEMS_COMPILER_MEMORY_BARRIER();
*obj = desired;
40004e28: d0 27 60 08 st %o0, [ %i5 + 8 ]
40004e2c: 92 10 00 18 mov %i0, %o1
40004e30: c2 00 40 00 ld [ %g1 ], %g1
40004e34: 96 10 00 1a mov %i2, %o3
40004e38: 94 10 00 19 mov %i1, %o2
40004e3c: 9f c0 40 00 call %g1
40004e40: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40004e44: b0 92 20 00 orcc %o0, 0, %i0
40004e48: 12 80 00 13 bne 40004e94 <open+0x148>
<== NEVER TAKEN
40004e4c: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
int fd = rtems_libio_iop_to_descriptor( iop );
40004e50: 31 10 00 4c sethi %hi(0x40013000), %i0
<== NOT EXECUTED
40004e54: 03 2a aa aa sethi %hi(0xaaaaa800), %g1
<== NOT EXECUTED
40004e58: b0 16 22 20 or %i0, 0x220, %i0
<== NOT EXECUTED
40004e5c: 82 10 62 ab or %g1, 0x2ab, %g1
<== NOT EXECUTED
40004e60: b0 27 40 18 sub %i5, %i0, %i0
<== NOT EXECUTED
40004e64: b1 3e 20 04 sra %i0, 4, %i0
<== NOT EXECUTED
40004e68: b0 5e 00 01 smul %i0, %g1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004e6c: 91 d0 20 09 ta 9
<== NOT EXECUTED
ISR_Level level;
(void) order;
_ISR_Local_disable( level );
val = *obj;
*obj = val | arg;
40004e70: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40004e74: 84 10 a1 00 or %g2, 0x100, %g2
<== NOT EXECUTED
40004e78: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004e7c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004e80: 01 00 00 00 nop
if ( truncate ) {
40004e84: 80 8e 64 00 btst 0x400, %i1
40004e88: 12 80 00 07 bne 40004ea4 <open+0x158>
<== NEVER TAKEN
40004e8c: 92 10 20 00 clr %o1
if ( rv < 0 ) {
40004e90: 80 a6 20 00 cmp %i0, 0
40004e94: 06 80 00 0e bl 40004ecc <open+0x180>
<== NEVER TAKEN
40004e98: 01 00 00 00 nop
}
va_end( ap );
return rv;
}
40004e9c: 81 c7 e0 08 ret
40004ea0: 81 e8 00 00 restore
rv = ftruncate( fd, 0 );
40004ea4: 94 10 20 00 clr %o2
<== NOT EXECUTED
40004ea8: 40 00 23 6e call 4000dc60 <ftruncate>
<== NOT EXECUTED
40004eac: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( rv != 0 ) {
40004eb0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40004eb4: 02 bf ff f7 be 40004e90 <open+0x144>
<== NOT EXECUTED
40004eb8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
(*iop->pathinfo.handlers->close_h)( iop );
40004ebc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
40004ec0: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
40004ec4: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004ec8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_libio_free( iop );
40004ecc: 40 00 23 d0 call 4000de0c <rtems_libio_free>
<== NOT EXECUTED
40004ed0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40004ed4: 81 c7 e0 08 ret
<== NOT EXECUTED
40004ed8: 81 e8 00 00 restore
<== NOT EXECUTED
40004edc: e0 07 bf 70 ld [ %fp + -144 ], %l0
<== NOT EXECUTED
rv = rtems_filesystem_mknod(
40004ee0: 98 10 20 00 clr %o4
<== NOT EXECUTED
40004ee4: 9a 10 20 00 clr %o5
<== NOT EXECUTED
40004ee8: 17 00 00 20 sethi %hi(0x8000), %o3
<== NOT EXECUTED
40004eec: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
40004ef0: 96 16 80 0b or %i2, %o3, %o3
<== NOT EXECUTED
40004ef4: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
40004ef8: 7f ff fe 4c call 40004828 <rtems_filesystem_mknod>
<== NOT EXECUTED
40004efc: 90 07 bf 80 add %fp, -128, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
40004f00: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40004f04: 02 80 00 06 be 40004f1c <open+0x1d0>
<== NOT EXECUTED
40004f08: 92 10 20 00 clr %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error( ctx, 0 );
40004f0c: 40 00 01 1e call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40004f10: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
if ( write_access ) {
40004f14: 10 bf ff af b 40004dd0 <open+0x84>
<== NOT EXECUTED
40004f18: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
ctx->flags = flags;
40004f1c: c0 27 bf 78 clr [ %fp + -136 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_continue( ctx );
40004f20: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
ctx->path = path;
40004f24: e0 27 bf 68 st %l0, [ %fp + -152 ]
<== NOT EXECUTED
40004f28: 40 00 01 5f call 400054a4 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
40004f2c: f6 27 bf 6c st %i3, [ %fp + -148 ]
<== NOT EXECUTED
if ( write_access ) {
40004f30: 10 bf ff a8 b 40004dd0 <open+0x84>
<== NOT EXECUTED
40004f34: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
rtems_filesystem_eval_path_error( &ctx, EISDIR );
40004f38: 40 00 01 13 call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40004f3c: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
rtems_filesystem_location_copy_and_detach(
40004f40: 10 bf ff b3 b 40004e0c <open+0xc0>
<== NOT EXECUTED
40004f44: 92 07 bf 80 add %fp, -128, %o1
<== NOT EXECUTED
errno = ENFILE;
40004f48: 40 00 26 c9 call 4000ea6c <__errno>
<== NOT EXECUTED
40004f4c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004f50: 82 10 20 17 mov 0x17, %g1
<== NOT EXECUTED
40004f54: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40004f58: 81 c7 e0 08 ret
<== NOT EXECUTED
40004f5c: 81 e8 00 00 restore
<== NOT EXECUTED
40004f60 <printk>:
/**
* Kernel printf function requiring minimal infrastructure.
*/
int printk(const char *fmt, ...)
{
40004f60: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
va_list ap; /* points to each unnamed argument in turn */
int len;
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
40004f64: 82 07 a0 48 add %fp, 0x48, %g1
<== NOT EXECUTED
40004f68: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
40004f6c: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
40004f70: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
40004f74: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
40004f78: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
<== NOT EXECUTED
40004f7c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
<== NOT EXECUTED
40004f80: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
40004f84: 40 00 03 e6 call 40005f1c <vprintk>
<== NOT EXECUTED
40004f88: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
va_end(ap); /* clean up when done */
return len;
}
40004f8c: 81 c7 e0 08 ret
<== NOT EXECUTED
40004f90: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
40018374 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
40018374: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
40018378: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4001837c: 02 80 00 32 be 40018444 <read+0xd0>
<== NOT EXECUTED
40018380: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
rtems_libio_check_count( count );
40018384: 02 80 00 22 be 4001840c <read+0x98>
<== NOT EXECUTED
40018388: 84 10 20 00 clr %g2
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
4001838c: 03 10 00 64 sethi %hi(0x40019000), %g1
<== NOT EXECUTED
40018390: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 40019158 <rtems_libio_number_iops>
<== NOT EXECUTED
40018394: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
40018398: 1a 80 00 25 bcc 4001842c <read+0xb8>
<== NOT EXECUTED
4001839c: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
400183a0: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400183a4: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
400183a8: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400183ac: b0 16 20 c0 or %i0, 0xc0, %i0
<== NOT EXECUTED
400183b0: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400183b4: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400183b8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400183bc: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400183c0: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400183c4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400183c8: 01 00 00 00 nop
<== NOT EXECUTED
400183cc: 84 08 a1 02 and %g2, 0x102, %g2
<== NOT EXECUTED
400183d0: 80 a0 a1 02 cmp %g2, 0x102
<== NOT EXECUTED
400183d4: 12 80 00 10 bne 40018414 <read+0xa0>
<== NOT EXECUTED
400183d8: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
/*
* Now process the read().
*/
n = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
400183dc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
400183e0: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
400183e4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400183e8: 9f c0 40 00 call %g1
<== NOT EXECUTED
400183ec: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400183f0: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400183f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
400183f8: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
400183fc: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
40018400: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018404: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018408: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
return n;
}
4001840c: 81 c7 e0 08 ret
<== NOT EXECUTED
40018410: 91 e8 00 02 restore %g0, %g2, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018414: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018418: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4001841c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018420: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018424: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018428: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
4001842c: 7f ff d9 8f call 4000ea68 <__errno>
<== NOT EXECUTED
40018430: 01 00 00 00 nop
<== NOT EXECUTED
40018434: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
40018438: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
4001843c: 10 bf ff f4 b 4001840c <read+0x98>
<== NOT EXECUTED
40018440: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_libio_check_buffer( buffer );
40018444: 7f ff d9 89 call 4000ea68 <__errno>
<== NOT EXECUTED
40018448: 01 00 00 00 nop
<== NOT EXECUTED
4001844c: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40018450: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40018454: 10 bf ff ee b 4001840c <read+0x98>
<== NOT EXECUTED
40018458: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400184a8 <realloc>:
return new_ptr;
}
void *realloc( void *ptr, size_t size )
{
400184a8: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Heap_Control *heap;
Heap_Resize_status status;
uintptr_t old_size;
uintptr_t avail_size;
if ( size == 0 ) {
400184ac: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
400184b0: 02 80 00 40 be 400185b0 <realloc+0x108>
<== NOT EXECUTED
400184b4: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
free( ptr );
return NULL;
}
if ( ptr == NULL ) {
400184b8: 02 80 00 34 be 40018588 <realloc+0xe0>
<== NOT EXECUTED
400184bc: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
return malloc( size );
}
heap = RTEMS_Malloc_Heap;
switch ( _Malloc_System_state() ) {
400184c0: 7f ff b3 a8 call 40005360 <_Malloc_System_state>
<== NOT EXECUTED
400184c4: fa 00 63 4c ld [ %g1 + 0x34c ], %i5 ! 4001b34c <RTEMS_Malloc_Heap>
<== NOT EXECUTED
400184c8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400184cc: 02 80 00 21 be 40018550 <realloc+0xa8>
<== NOT EXECUTED
400184d0: 01 00 00 00 nop
<== NOT EXECUTED
400184d4: 80 a2 20 01 cmp %o0, 1
<== NOT EXECUTED
400184d8: 32 80 00 2e bne,a 40018590 <realloc+0xe8>
<== NOT EXECUTED
400184dc: ba 10 20 00 clr %i5
<== NOT EXECUTED
_Malloc_Process_deferred_frees();
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
400184e0: 98 07 bf fc add %fp, -4, %o4
<== NOT EXECUTED
400184e4: 96 07 bf f8 add %fp, -8, %o3
<== NOT EXECUTED
400184e8: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
400184ec: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400184f0: 40 00 00 6e call 400186a8 <_Heap_Resize_block>
<== NOT EXECUTED
400184f4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400184f8: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
break;
default:
return NULL;
}
switch ( status ) {
400184fc: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40018500: 02 80 00 12 be 40018548 <realloc+0xa0>
<== NOT EXECUTED
40018504: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
40018508: 80 a7 20 01 cmp %i4, 1
<== NOT EXECUTED
4001850c: 12 80 00 23 bne 40018598 <realloc+0xf0>
<== NOT EXECUTED
40018510: f8 07 bf f8 ld [ %fp + -8 ], %i4
<== NOT EXECUTED
new_ptr = malloc( new_size );
40018514: 7f ff b4 24 call 400055a4 <malloc>
<== NOT EXECUTED
40018518: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
if ( new_ptr == NULL ) {
4001851c: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
40018520: 02 80 00 0a be 40018548 <realloc+0xa0>
<== NOT EXECUTED
40018524: 80 a7 00 19 cmp %i4, %i1
<== NOT EXECUTED
memcpy( new_ptr, old_ptr, ( new_size < old_size ) ? new_size : old_size );
40018528: 08 80 00 03 bleu 40018534 <realloc+0x8c>
<== NOT EXECUTED
4001852c: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
40018530: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
40018534: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40018538: 7f ff da bd call 4000f02c <memcpy>
<== NOT EXECUTED
4001853c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
free( old_ptr );
40018540: 7f ff b3 0a call 40005168 <free>
<== NOT EXECUTED
40018544: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return new_alloc( ptr, size, old_size );
default:
errno = EINVAL;
return NULL;
}
}
40018548: 81 c7 e0 08 ret
<== NOT EXECUTED
4001854c: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40018550: 7f ff bc af call 4000780c <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40018554: 01 00 00 00 nop
<== NOT EXECUTED
_Malloc_Process_deferred_frees();
40018558: 7f ff b3 91 call 4000539c <_Malloc_Process_deferred_frees>
<== NOT EXECUTED
4001855c: 01 00 00 00 nop
<== NOT EXECUTED
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
40018560: 98 07 bf fc add %fp, -4, %o4
<== NOT EXECUTED
40018564: 96 07 bf f8 add %fp, -8, %o3
<== NOT EXECUTED
40018568: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001856c: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40018570: 40 00 00 4e call 400186a8 <_Heap_Resize_block>
<== NOT EXECUTED
40018574: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40018578: 7f ff bc aa call 40007820 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4001857c: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
break;
40018580: 10 bf ff e0 b 40018500 <realloc+0x58>
<== NOT EXECUTED
40018584: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
return malloc( size );
40018588: 7f ff b4 07 call 400055a4 <malloc>
<== NOT EXECUTED
4001858c: 91 e8 00 19 restore %g0, %i1, %o0
<== NOT EXECUTED
}
40018590: 81 c7 e0 08 ret
<== NOT EXECUTED
40018594: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
errno = EINVAL;
40018598: 7f ff d9 34 call 4000ea68 <__errno>
<== NOT EXECUTED
4001859c: ba 10 20 00 clr %i5
<== NOT EXECUTED
400185a0: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400185a4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
400185a8: 81 c7 e0 08 ret
<== NOT EXECUTED
400185ac: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
free( ptr );
400185b0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400185b4: 7f ff b2 ed call 40005168 <free>
<== NOT EXECUTED
400185b8: ba 10 20 00 clr %i5
<== NOT EXECUTED
return NULL;
400185bc: 30 bf ff e3 b,a 40018548 <realloc+0xa0>
<== NOT EXECUTED
4000e8c4 <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000e8c4: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
4000e8c8: 90 10 00 18 mov %i0, %o0
4000e8cc: 92 10 00 19 mov %i1, %o1
4000e8d0: 40 00 00 07 call 4000e8ec <rtems_assoc_ptr_by_remote>
4000e8d4: b0 10 20 00 clr %i0
if (nap)
4000e8d8: 80 a2 20 00 cmp %o0, 0
4000e8dc: 32 80 00 02 bne,a 4000e8e4 <rtems_assoc_local_by_remote+0x20>
<== ALWAYS TAKEN
4000e8e0: f0 02 20 04 ld [ %o0 + 4 ], %i0
return nap->local_value;
return 0;
}
4000e8e4: 81 c7 e0 08 ret
4000e8e8: 81 e8 00 00 restore
4000e878 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000e878: 9d e3 bf a0 save %sp, -96, %sp
4000e87c: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t local_value = 0;
4000e880: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1) {
4000e884: 10 80 00 04 b 4000e894 <rtems_assoc_local_by_remote_bitfield+0x1c>
4000e888: ba 10 20 01 mov 1, %i5
4000e88c: 02 80 00 0c be 4000e8bc <rtems_assoc_local_by_remote_bitfield+0x44>
4000e890: bb 2f 60 01 sll %i5, 1, %i5
if (b & remote_value)
4000e894: 80 8e 40 1d btst %i1, %i5
4000e898: 22 bf ff fd be,a 4000e88c <rtems_assoc_local_by_remote_bitfield+0x14>
<== ALWAYS TAKEN
4000e89c: b8 87 3f ff addcc %i4, -1, %i4
local_value |= rtems_assoc_local_by_remote(ap, b);
4000e8a0: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000e8a4: 40 00 00 08 call 4000e8c4 <rtems_assoc_local_by_remote>
<== NOT EXECUTED
4000e8a8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
for (b = 1; b; b <<= 1) {
4000e8ac: bb 2f 60 01 sll %i5, 1, %i5
<== NOT EXECUTED
4000e8b0: b8 87 3f ff addcc %i4, -1, %i4
<== NOT EXECUTED
4000e8b4: 12 bf ff f8 bne 4000e894 <rtems_assoc_local_by_remote_bitfield+0x1c>
<== NOT EXECUTED
4000e8b8: b6 16 c0 08 or %i3, %o0, %i3
<== NOT EXECUTED
}
return local_value;
}
4000e8bc: 81 c7 e0 08 ret
4000e8c0: 91 e8 00 1b restore %g0, %i3, %o0
4000e8ec <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000e8ec: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000e8f0: d0 06 00 00 ld [ %i0 ], %o0
{
4000e8f4: ba 10 00 18 mov %i0, %i5
if (rtems_assoc_is_default(ap))
4000e8f8: 80 a2 20 00 cmp %o0, 0
4000e8fc: 02 80 00 16 be 4000e954 <rtems_assoc_ptr_by_remote+0x68>
<== NEVER TAKEN
4000e900: b0 10 20 00 clr %i0
4000e904: 13 10 00 43 sethi %hi(0x40010c00), %o1
4000e908: 40 00 01 4e call 4000ee40 <strcmp>
4000e90c: 92 12 60 d0 or %o1, 0xd0, %o1 ! 40010cd0 <CSWTCH.1+0x10>
4000e910: 80 a2 20 00 cmp %o0, 0
4000e914: 22 80 00 12 be,a 4000e95c <rtems_assoc_ptr_by_remote+0x70>
<== NEVER TAKEN
4000e918: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
4000e91c: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000e920: 80 a6 40 01 cmp %i1, %g1
4000e924: 32 80 00 08 bne,a 4000e944 <rtems_assoc_ptr_by_remote+0x58>
4000e928: ba 07 60 0c add %i5, 0xc, %i5
for ( ; ap->name; ap++)
4000e92c: 81 c7 e0 08 ret
4000e930: 91 e8 00 1d restore %g0, %i5, %o0
if (ap->remote_value == remote_value)
4000e934: 80 a0 40 19 cmp %g1, %i1
4000e938: 22 80 00 07 be,a 4000e954 <rtems_assoc_ptr_by_remote+0x68>
<== ALWAYS TAKEN
4000e93c: b0 10 00 1d mov %i5, %i0
for ( ; ap->name; ap++)
4000e940: ba 07 60 0c add %i5, 0xc, %i5
<== NOT EXECUTED
4000e944: c2 07 40 00 ld [ %i5 ], %g1
4000e948: 80 a0 60 00 cmp %g1, 0
4000e94c: 32 bf ff fa bne,a 4000e934 <rtems_assoc_ptr_by_remote+0x48>
<== ALWAYS TAKEN
4000e950: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000e954: 81 c7 e0 08 ret
4000e958: 81 e8 00 00 restore
default_ap = ap++;
4000e95c: 82 07 60 0c add %i5, 0xc, %g1
<== NOT EXECUTED
for ( ; ap->name; ap++)
4000e960: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
4000e964: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000e968: 12 bf ff ed bne 4000e91c <rtems_assoc_ptr_by_remote+0x30>
<== NOT EXECUTED
4000e96c: ba 10 00 01 mov %g1, %i5
<== NOT EXECUTED
4000e970: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e974: 81 e8 00 00 restore
<== NOT EXECUTED
40004fb8 <rtems_current_user_env_get>:
{
40004fb8: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = pthread_getspecific(rtems_current_user_env_key);
40004fbc: 03 10 00 4e sethi %hi(0x40013800), %g1
40004fc0: 40 00 03 fb call 40005fac <pthread_getspecific>
40004fc4: d0 00 60 d4 ld [ %g1 + 0xd4 ], %o0 ! 400138d4 <rtems_current_user_env_key>
if (ptr == NULL) {
40004fc8: b0 92 20 00 orcc %o0, 0, %i0
40004fcc: 22 80 00 04 be,a 40004fdc <rtems_current_user_env_get+0x24>
<== ALWAYS TAKEN
40004fd0: 31 10 00 47 sethi %hi(0x40011c00), %i0
}
40004fd4: 81 c7 e0 08 ret
<== NOT EXECUTED
40004fd8: 81 e8 00 00 restore
<== NOT EXECUTED
40004fdc: 81 c7 e0 08 ret
40004fe0: 91 ee 23 50 restore %i0, 0x350, %o0
4000e044 <rtems_deviceio_close>:
int rtems_deviceio_close(
rtems_libio_t *iop,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e044: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
args.iop = iop;
args.flags = 0;
args.mode = 0;
status = rtems_io_close( major, minor, &args );
4000e048: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4000e04c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
args.iop = iop;
4000e050: f0 27 bf f4 st %i0, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_close( major, minor, &args );
4000e054: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
args.flags = 0;
4000e058: c0 27 bf f8 clr [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_close( major, minor, &args );
4000e05c: 40 00 00 ae call 4000e314 <rtems_io_close>
<== NOT EXECUTED
4000e060: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
return rtems_status_code_to_errno( status );
4000e064: 40 00 00 96 call 4000e2bc <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e068: 01 00 00 00 nop
<== NOT EXECUTED
}
4000e06c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e070: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e154 <rtems_deviceio_control>:
ioctl_command_t command,
void *buffer,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e154: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_ioctl_args_t args;
args.iop = iop;
4000e158: f0 27 bf f0 st %i0, [ %fp + -16 ]
<== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control( major, minor, &args );
4000e15c: 94 07 bf f0 add %fp, -16, %o2
<== NOT EXECUTED
args.command = command;
4000e160: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_control( major, minor, &args );
4000e164: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = buffer;
4000e168: f4 27 bf f8 st %i2, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_control( major, minor, &args );
4000e16c: 40 00 00 82 call 4000e374 <rtems_io_control>
<== NOT EXECUTED
4000e170: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000e174: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e178: 12 80 00 05 bne 4000e18c <rtems_deviceio_control+0x38>
<== NOT EXECUTED
4000e17c: 01 00 00 00 nop
<== NOT EXECUTED
return args.ioctl_return;
4000e180: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000e184: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e188: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno(status);
4000e18c: 40 00 00 4c call 4000e2bc <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e190: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000e194: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e198: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e010 <rtems_deviceio_open>:
int oflag,
mode_t mode,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e010: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_open_close_args_t args;
args.iop = iop;
args.flags = iop->flags;
4000e014: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.mode = mode;
status = rtems_io_open( major, minor, &args );
4000e018: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4000e01c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
args.iop = iop;
4000e020: f0 27 bf f4 st %i0, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_open( major, minor, &args );
4000e024: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
args.flags = iop->flags;
4000e028: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_open( major, minor, &args );
4000e02c: 40 00 01 01 call 4000e430 <rtems_io_open>
<== NOT EXECUTED
4000e030: f6 27 bf fc st %i3, [ %fp + -4 ]
<== NOT EXECUTED
return rtems_status_code_to_errno( status );
4000e034: 40 00 00 a2 call 4000e2bc <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e038: 01 00 00 00 nop
<== NOT EXECUTED
}
4000e03c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e040: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e074 <rtems_deviceio_read>:
void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e074: 9d e3 bf 80 save %sp, -128, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_rw_args_t args;
args.iop = iop;
args.offset = iop->offset;
4000e078: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
args.buffer = buf;
args.count = nbyte;
args.flags = iop->flags;
4000e07c: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.iop = iop;
4000e080: f0 27 bf e0 st %i0, [ %fp + -32 ]
<== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_read( major, minor, &args );
4000e084: 94 07 bf e0 add %fp, -32, %o2
<== NOT EXECUTED
args.offset = iop->offset;
4000e088: c4 3f bf e8 std %g2, [ %fp + -24 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000e08c: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = buf;
4000e090: f2 27 bf f0 st %i1, [ %fp + -16 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000e094: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
args.count = nbyte;
4000e098: f4 27 bf f4 st %i2, [ %fp + -12 ]
<== NOT EXECUTED
{
4000e09c: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
args.flags = iop->flags;
4000e0a0: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000e0a4: 40 00 00 fb call 4000e490 <rtems_io_read>
<== NOT EXECUTED
4000e0a8: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000e0ac: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e0b0: 12 80 00 09 bne 4000e0d4 <rtems_deviceio_read+0x60>
<== NOT EXECUTED
4000e0b4: 01 00 00 00 nop
<== NOT EXECUTED
iop->offset += args.bytes_moved;
4000e0b8: f4 1f 40 00 ldd [ %i5 ], %i2
<== NOT EXECUTED
4000e0bc: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000e0c0: 86 86 c0 18 addcc %i3, %i0, %g3
<== NOT EXECUTED
4000e0c4: 84 46 a0 00 addx %i2, 0, %g2
<== NOT EXECUTED
4000e0c8: c4 3f 40 00 std %g2, [ %i5 ]
<== NOT EXECUTED
return (ssize_t) args.bytes_moved;
4000e0cc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e0d0: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno( status );
4000e0d4: 40 00 00 7a call 4000e2bc <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e0d8: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000e0dc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e0e0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e0e4 <rtems_deviceio_write>:
const void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e0e4: 9d e3 bf 80 save %sp, -128, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_rw_args_t args;
args.iop = iop;
args.offset = iop->offset;
4000e0e8: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
args.buffer = RTEMS_DECONST( void *, buf );
args.count = nbyte;
args.flags = iop->flags;
4000e0ec: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.iop = iop;
4000e0f0: f0 27 bf e0 st %i0, [ %fp + -32 ]
<== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_write( major, minor, &args );
4000e0f4: 94 07 bf e0 add %fp, -32, %o2
<== NOT EXECUTED
args.offset = iop->offset;
4000e0f8: c4 3f bf e8 std %g2, [ %fp + -24 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000e0fc: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = RTEMS_DECONST( void *, buf );
4000e100: f2 27 bf f0 st %i1, [ %fp + -16 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000e104: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
args.count = nbyte;
4000e108: f4 27 bf f4 st %i2, [ %fp + -12 ]
<== NOT EXECUTED
{
4000e10c: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
args.flags = iop->flags;
4000e110: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000e114: 40 00 00 f7 call 4000e4f0 <rtems_io_write>
<== NOT EXECUTED
4000e118: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000e11c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e120: 12 80 00 09 bne 4000e144 <rtems_deviceio_write+0x60>
<== NOT EXECUTED
4000e124: 01 00 00 00 nop
<== NOT EXECUTED
iop->offset += args.bytes_moved;
4000e128: f4 1f 40 00 ldd [ %i5 ], %i2
<== NOT EXECUTED
4000e12c: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000e130: 86 86 c0 18 addcc %i3, %i0, %g3
<== NOT EXECUTED
4000e134: 84 46 a0 00 addx %i2, 0, %g2
<== NOT EXECUTED
4000e138: c4 3f 40 00 std %g2, [ %i5 ]
<== NOT EXECUTED
return (ssize_t) args.bytes_moved;
4000e13c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e140: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno( status );
4000e144: 40 00 00 5e call 4000e2bc <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e148: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000e14c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e150: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
40005044 <rtems_filesystem_check_access>:
int flags,
mode_t object_mode,
uid_t object_uid,
gid_t object_gid
)
{
40005044: 9d e3 bf a0 save %sp, -96, %sp
const rtems_user_env_t *uenv = rtems_current_user_env_get();
40005048: 7f ff ff dc call 40004fb8 <rtems_current_user_env_get>
4000504c: b0 0e 20 07 and %i0, 7, %i0
mode_t access_flags = flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = uenv->euid;
if (task_uid == 0 || task_uid == object_uid) {
40005050: c2 12 20 10 lduh [ %o0 + 0x10 ], %g1
40005054: 80 a0 60 00 cmp %g1, 0
40005058: 02 80 00 24 be 400050e8 <rtems_filesystem_check_access+0xa4>
<== ALWAYS TAKEN
4000505c: 80 a0 40 1a cmp %g1, %i2
40005060: 22 80 00 23 be,a 400050ec <rtems_filesystem_check_access+0xa8>
<== NOT EXECUTED
40005064: b1 2e 20 06 sll %i0, 6, %i0
<== NOT EXECUTED
access_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = uenv->egid;
if (
task_gid == 0
40005068: c2 12 20 12 lduh [ %o0 + 0x12 ], %g1
<== NOT EXECUTED
if (
4000506c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40005070: 02 80 00 18 be 400050d0 <rtems_filesystem_check_access+0x8c>
<== NOT EXECUTED
40005074: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
40005078: 22 80 00 17 be,a 400050d4 <rtems_filesystem_check_access+0x90>
<== NOT EXECUTED
4000507c: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
40005080: c6 02 20 24 ld [ %o0 + 0x24 ], %g3
<== NOT EXECUTED
40005084: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40005088: 22 80 00 14 be,a 400050d8 <rtems_filesystem_check_access+0x94>
<== NOT EXECUTED
4000508c: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
if (uenv->groups[i] == object_gid) {
40005090: c2 12 20 28 lduh [ %o0 + 0x28 ], %g1
<== NOT EXECUTED
40005094: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
40005098: 02 80 00 0e be 400050d0 <rtems_filesystem_check_access+0x8c>
<== NOT EXECUTED
4000509c: 90 02 20 2a add %o0, 0x2a, %o0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
400050a0: 10 80 00 06 b 400050b8 <rtems_filesystem_check_access+0x74>
<== NOT EXECUTED
400050a4: 82 10 20 00 clr %g1
<== NOT EXECUTED
if (uenv->groups[i] == object_gid) {
400050a8: c4 12 3f fe lduh [ %o0 + -2 ], %g2
<== NOT EXECUTED
400050ac: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
400050b0: 22 80 00 09 be,a 400050d4 <rtems_filesystem_check_access+0x90>
<== NOT EXECUTED
400050b4: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
400050b8: 82 00 60 01 inc %g1
<== NOT EXECUTED
400050bc: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
400050c0: 12 bf ff fa bne 400050a8 <rtems_filesystem_check_access+0x64>
<== NOT EXECUTED
400050c4: 90 02 20 02 add %o0, 2, %o0
<== NOT EXECUTED
} else {
access_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (access_flags & object_mode) == access_flags;
400050c8: 10 80 00 04 b 400050d8 <rtems_filesystem_check_access+0x94>
<== NOT EXECUTED
400050cc: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
access_flags <<= RTEMS_FS_GRP_SHIFT;
400050d0: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
return (access_flags & object_mode) == access_flags;
400050d4: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
}
400050d8: 80 a0 00 18 cmp %g0, %i0
<== NOT EXECUTED
400050dc: b0 60 3f ff subx %g0, -1, %i0
<== NOT EXECUTED
400050e0: 81 c7 e0 08 ret
<== NOT EXECUTED
400050e4: 81 e8 00 00 restore
<== NOT EXECUTED
access_flags <<= RTEMS_FS_USR_SHIFT;
400050e8: b1 2e 20 06 sll %i0, 6, %i0
return (access_flags & object_mode) == access_flags;
400050ec: b0 2e 00 19 andn %i0, %i1, %i0
}
400050f0: 80 a0 00 18 cmp %g0, %i0
400050f4: b0 60 3f ff subx %g0, -1, %i0
400050f8: 81 c7 e0 08 ret
400050fc: 81 e8 00 00 restore
40010510 <rtems_filesystem_default_pathconf>:
40010510: 00 00 00 05 00 00 00 80 00 00 00 07 00 00 00 ff ................
40010520: 00 00 00 ff 00 00 04 00 00 00 00 00 00 00 00 00 ................
40010530: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
40010540: 2e 00 00 00 00 00 00 00 2e 2e 00 00 ............
400058a8 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
400058a8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_lock();
400058ac: 7f ff fb 29 call 40004550 <rtems_libio_lock>
<== NOT EXECUTED
400058b0: 01 00 00 00 nop
<== NOT EXECUTED
next = the_node->next;
400058b4: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
previous = the_node->previous;
400058b8: c2 06 20 04 ld [ %i0 + 4 ], %g1
<== NOT EXECUTED
next->previous = previous;
400058bc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
rtems_libio_unlock();
400058c0: 7f ff fb 29 call 40004564 <rtems_libio_unlock>
<== NOT EXECUTED
400058c4: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
release_with_count(global_loc, 1);
400058c8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
<== NOT EXECUTED
400058cc: 40 00 00 14 call 4000591c <release_with_count>
<== NOT EXECUTED
400058d0: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_filesystem_mt_lock();
rtems_chain_extract_unprotected(&mt_entry->mt_node);
rtems_filesystem_mt_unlock();
rtems_filesystem_global_location_release(mt_entry->mt_point_node, false);
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
400058d4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
400058d8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
<== NOT EXECUTED
400058dc: 9f c0 40 00 call %g1
<== NOT EXECUTED
400058e0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (mt_entry->unmount_task != 0) {
400058e4: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
<== NOT EXECUTED
400058e8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400058ec: 02 80 00 07 be 40005908 <rtems_filesystem_do_unmount+0x60>
<== NOT EXECUTED
400058f0: 01 00 00 00 nop
<== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(
rtems_id id
)
{
return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT );
400058f4: 40 00 04 e1 call 40006c78 <rtems_event_system_send>
<== NOT EXECUTED
400058f8: 13 20 00 00 sethi %hi(0x80000000), %o1
<== NOT EXECUTED
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
400058fc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005900: 32 80 00 04 bne,a 40005910 <rtems_filesystem_do_unmount+0x68>
<== NOT EXECUTED
40005904: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
<== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
40005908: 7f ff fa 9e call 40004380 <free>
<== NOT EXECUTED
4000590c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
40005910: 40 00 05 e7 call 400070ac <rtems_fatal_error_occurred>
<== NOT EXECUTED
40005914: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
40005918: 01 00 00 00 nop
<== NOT EXECUTED
40005100 <rtems_filesystem_eval_path_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
40005100: 9d e3 bf a0 save %sp, -96, %sp
bool access_ok = rtems_filesystem_check_access(
40005104: 96 10 00 1c mov %i4, %o3
40005108: 94 10 00 1b mov %i3, %o2
4000510c: 92 10 00 1a mov %i2, %o1
40005110: 7f ff ff cd call 40005044 <rtems_filesystem_check_access>
40005114: 90 10 00 19 mov %i1, %o0
node_mode,
node_uid,
node_gid
);
if (!access_ok) {
40005118: ba 92 20 00 orcc %o0, 0, %i5
4000511c: 12 80 00 04 bne 4000512c <rtems_filesystem_eval_path_check_access+0x2c>
<== ALWAYS TAKEN
40005120: 92 10 20 0d mov 0xd, %o1
rtems_filesystem_eval_path_error(ctx, EACCES);
40005124: 40 00 00 98 call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005128: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
return access_ok;
}
4000512c: 81 c7 e0 08 ret
40005130: 91 e8 00 1d restore %g0, %i5, %o0
400054a4 <rtems_filesystem_eval_path_continue>:
{
400054a4: 9d e3 bf a0 save %sp, -96, %sp
while (ctx->pathlen > 0) {
400054a8: c2 06 20 04 ld [ %i0 + 4 ], %g1
400054ac: 80 a0 60 00 cmp %g1, 0
400054b0: 22 80 00 0c be,a 400054e0 <rtems_filesystem_eval_path_continue+0x3c>
<== NEVER TAKEN
400054b4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
400054b8: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
400054bc: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400054c0: c2 00 60 08 ld [ %g1 + 8 ], %g1
400054c4: 9f c0 40 00 call %g1
400054c8: 90 10 00 18 mov %i0, %o0
while (ctx->pathlen > 0) {
400054cc: c2 06 20 04 ld [ %i0 + 4 ], %g1
400054d0: 80 a0 60 00 cmp %g1, 0
400054d4: 32 bf ff fa bne,a 400054bc <rtems_filesystem_eval_path_continue+0x18>
<== NEVER TAKEN
400054d8: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
<== NOT EXECUTED
if (rtems_filesystem_eval_path_has_token(ctx)) {
400054dc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400054e0: 80 a0 60 00 cmp %g1, 0
400054e4: 02 80 00 07 be 40005500 <rtems_filesystem_eval_path_continue+0x5c>
400054e8: f2 06 20 10 ld [ %i0 + 0x10 ], %i1
if (make) {
400054ec: 80 8e 60 20 btst 0x20, %i1
400054f0: 02 80 00 08 be 40005510 <rtems_filesystem_eval_path_continue+0x6c>
<== NEVER TAKEN
400054f4: b2 10 20 02 mov 2, %i1
check_access(ctx, ctx->flags);
400054f8: 7f ff ff b9 call 400053dc <check_access>
400054fc: 81 e8 00 00 restore
if (!exclusive) {
40005500: 80 8e 60 40 btst 0x40, %i1
40005504: 02 bf ff fd be 400054f8 <rtems_filesystem_eval_path_continue+0x54>
<== ALWAYS TAKEN
40005508: 01 00 00 00 nop
rtems_filesystem_eval_path_error(ctx, EEXIST);
4000550c: b2 10 20 11 mov 0x11, %i1 ! 11 <_TLS_Alignment+0x10>
<== NOT EXECUTED
40005510: 7f ff ff 9d call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005514: 81 e8 00 00 restore
<== NOT EXECUTED
40005d20 <rtems_filesystem_eval_path_eat_delimiter>:
void rtems_filesystem_eval_path_eat_delimiter(
rtems_filesystem_eval_path_context_t *ctx
)
{
const char *current = ctx->path;
40005d20: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
const char *end = current + ctx->pathlen;
40005d24: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
40005d28: 86 00 40 02 add %g1, %g2, %g3
<== NOT EXECUTED
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40005d2c: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40005d30: 22 80 00 17 be,a 40005d8c <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
40005d34: 84 10 20 00 clr %g2
<== NOT EXECUTED
return c == '/' || c == '\\';
40005d38: c8 48 40 00 ldsb [ %g1 ], %g4
<== NOT EXECUTED
40005d3c: 80 a1 20 2f cmp %g4, 0x2f
<== NOT EXECUTED
40005d40: 02 80 00 04 be 40005d50 <rtems_filesystem_eval_path_eat_delimiter+0x30>
<== NOT EXECUTED
40005d44: 80 a1 20 5c cmp %g4, 0x5c
<== NOT EXECUTED
40005d48: 32 80 00 11 bne,a 40005d8c <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
40005d4c: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
++current;
40005d50: 82 00 60 01 inc %g1
<== NOT EXECUTED
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40005d54: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
40005d58: 02 80 00 0d be 40005d8c <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
40005d5c: 84 10 20 00 clr %g2
<== NOT EXECUTED
40005d60: c4 48 40 00 ldsb [ %g1 ], %g2
<== NOT EXECUTED
40005d64: 80 a0 a0 2f cmp %g2, 0x2f
<== NOT EXECUTED
40005d68: 02 bf ff fa be 40005d50 <rtems_filesystem_eval_path_eat_delimiter+0x30>
<== NOT EXECUTED
40005d6c: 80 a0 a0 5c cmp %g2, 0x5c
<== NOT EXECUTED
40005d70: 22 bf ff f9 be,a 40005d54 <rtems_filesystem_eval_path_eat_delimiter+0x34>
<== NOT EXECUTED
40005d74: 82 00 60 01 inc %g1
<== NOT EXECUTED
40005d78: 84 20 c0 01 sub %g3, %g1, %g2
<== NOT EXECUTED
++current;
40005d7c: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
40005d80: c4 22 20 04 st %g2, [ %o0 + 4 ]
<== NOT EXECUTED
}
40005d84: 81 c3 e0 08 retl
<== NOT EXECUTED
40005d88: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
ctx->path = current;
40005d8c: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
}
40005d90: 81 c3 e0 08 retl
<== NOT EXECUTED
40005d94: c4 22 20 04 st %g2, [ %o0 + 4 ]
<== NOT EXECUTED
40005384 <rtems_filesystem_eval_path_error>:
{
40005384: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
ctx->path = NULL;
40005388: c0 26 00 00 clr [ %i0 ]
<== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
4000538c: 03 10 00 41 sethi %hi(0x40010400), %g1
<== NOT EXECUTED
ctx->pathlen = 0;
40005390: c0 26 20 04 clr [ %i0 + 4 ]
<== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
40005394: 82 10 61 98 or %g1, 0x198, %g1
<== NOT EXECUTED
ctx->token = NULL;
40005398: c0 26 20 08 clr [ %i0 + 8 ]
<== NOT EXECUTED
ctx->tokenlen = 0;
4000539c: c0 26 20 0c clr [ %i0 + 0xc ]
<== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
400053a0: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
<== NOT EXECUTED
400053a4: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
400053a8: 02 80 00 0b be 400053d4 <rtems_filesystem_eval_path_error+0x50>
<== NOT EXECUTED
400053ac: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
if (eno != 0) {
400053b0: 12 80 00 04 bne 400053c0 <rtems_filesystem_eval_path_error+0x3c>
<== NOT EXECUTED
400053b4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_detach(&ctx->currentloc);
400053b8: 40 00 01 23 call 40005844 <rtems_filesystem_location_detach>
<== NOT EXECUTED
400053bc: 91 ee 20 18 restore %i0, 0x18, %o0
<== NOT EXECUTED
errno = eno;
400053c0: 40 00 25 ab call 4000ea6c <__errno>
<== NOT EXECUTED
400053c4: b0 06 20 18 add %i0, 0x18, %i0
<== NOT EXECUTED
400053c8: f2 22 00 00 st %i1, [ %o0 ]
<== NOT EXECUTED
rtems_filesystem_location_detach(&ctx->currentloc);
400053cc: 40 00 01 1e call 40005844 <rtems_filesystem_location_detach>
<== NOT EXECUTED
400053d0: 81 e8 00 00 restore
<== NOT EXECUTED
}
400053d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400053d8: 81 e8 00 00 restore
<== NOT EXECUTED
40005134 <rtems_filesystem_eval_path_generic>:
void rtems_filesystem_eval_path_generic(
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const rtems_filesystem_eval_path_generic_config *config
)
{
40005134: 9d e3 bf a0 save %sp, -96, %sp
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
40005138: 21 10 00 41 sethi %hi(0x40010400), %l0
{
4000513c: ba 10 00 18 mov %i0, %i5
return &ctx->currentloc;
40005140: a2 06 20 18 add %i0, 0x18, %l1
status = (*config->eval_token)(ctx, arg, "..", 2);
40005144: a0 14 21 48 or %l0, 0x148, %l0
status = (*config->eval_token)(ctx, arg, ".", 1);
40005148: 31 10 00 41 sethi %hi(0x40010400), %i0
4000514c: b0 16 21 40 or %i0, 0x140, %i0 ! 40010540 <rtems_filesystem_default_pathconf+0x30>
rtems_filesystem_eval_path_next_token(ctx);
40005150: 40 00 03 12 call 40005d98 <rtems_filesystem_eval_path_next_token>
40005154: 90 10 00 1d mov %i5, %o0
*tokenlen = ctx->tokenlen;
40005158: f8 07 60 0c ld [ %i5 + 0xc ], %i4
if (tokenlen > 0) {
4000515c: 80 a7 20 00 cmp %i4, 0
40005160: 02 80 00 19 be 400051c4 <rtems_filesystem_eval_path_generic+0x90>
<== NEVER TAKEN
40005164: f6 07 60 08 ld [ %i5 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
40005168: c2 06 80 00 ld [ %i2 ], %g1
4000516c: 92 10 00 19 mov %i1, %o1
40005170: 9f c0 40 00 call %g1
40005174: 90 10 00 1d mov %i5, %o0
40005178: 80 a2 20 00 cmp %o0, 0
4000517c: 02 80 00 60 be 400052fc <rtems_filesystem_eval_path_generic+0x1c8>
<== NEVER TAKEN
40005180: 80 a7 20 01 cmp %i4, 1
return tokenlen == 1 && token [0] == '.';
40005184: 02 80 00 12 be 400051cc <rtems_filesystem_eval_path_generic+0x98>
<== NEVER TAKEN
40005188: 80 a7 20 02 cmp %i4, 2
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
4000518c: 22 80 00 33 be,a 40005258 <rtems_filesystem_eval_path_generic+0x124>
<== NEVER TAKEN
40005190: c2 4e c0 00 ldsb [ %i3 ], %g1
<== NOT EXECUTED
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
40005194: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40005198: 96 10 00 1c mov %i4, %o3
4000519c: 94 10 00 1b mov %i3, %o2
400051a0: 92 10 00 19 mov %i1, %o1
400051a4: 9f c0 40 00 call %g1
400051a8: 90 10 00 1d mov %i5, %o0
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
400051ac: 80 a2 20 02 cmp %o0, 2
400051b0: 22 80 00 19 be,a 40005214 <rtems_filesystem_eval_path_generic+0xe0>
400051b4: c2 07 60 04 ld [ %i5 + 4 ], %g1
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
400051b8: 80 a2 20 00 cmp %o0, 0
400051bc: 02 bf ff e5 be 40005150 <rtems_filesystem_eval_path_generic+0x1c>
400051c0: 01 00 00 00 nop
400051c4: 81 c7 e0 08 ret
400051c8: 81 e8 00 00 restore
return tokenlen == 1 && token [0] == '.';
400051cc: c2 4e c0 00 ldsb [ %i3 ], %g1
<== NOT EXECUTED
400051d0: 80 a0 60 2e cmp %g1, 0x2e
<== NOT EXECUTED
400051d4: 32 bf ff f1 bne,a 40005198 <rtems_filesystem_eval_path_generic+0x64>
<== NOT EXECUTED
400051d8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
if (rtems_filesystem_eval_path_has_path(ctx)) {
400051dc: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
400051e0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400051e4: 22 80 00 40 be,a 400052e4 <rtems_filesystem_eval_path_generic+0x1b0>
<== NOT EXECUTED
400051e8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
status = (*config->eval_token)(ctx, arg, ".", 1);
400051ec: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
400051f0: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
400051f4: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
400051f8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400051fc: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005200: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
40005204: 80 a2 20 02 cmp %o0, 2
<== NOT EXECUTED
40005208: 12 bf ff ed bne 400051bc <rtems_filesystem_eval_path_generic+0x88>
<== NOT EXECUTED
4000520c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
if (rtems_filesystem_eval_path_has_path(ctx)) {
40005210: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40005214: 80 a0 60 00 cmp %g1, 0
40005218: 12 80 00 04 bne 40005228 <rtems_filesystem_eval_path_generic+0xf4>
<== NEVER TAKEN
4000521c: 01 00 00 00 nop
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
40005220: 81 c7 e0 08 ret
40005224: 81 e8 00 00 restore
rtems_filesystem_eval_path_eat_delimiter(ctx);
40005228: 40 00 02 be call 40005d20 <rtems_filesystem_eval_path_eat_delimiter>
<== NOT EXECUTED
4000522c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
40005230: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
if (
40005234: 80 88 60 80 btst 0x80, %g1
<== NOT EXECUTED
40005238: 02 80 00 06 be 40005250 <rtems_filesystem_eval_path_generic+0x11c>
<== NOT EXECUTED
4000523c: b2 10 20 02 mov 2, %i1
<== NOT EXECUTED
|| rtems_filesystem_eval_path_has_path(ctx)
40005240: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40005244: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40005248: 02 bf ff f6 be 40005220 <rtems_filesystem_eval_path_generic+0xec>
<== NOT EXECUTED
4000524c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOENT);
40005250: 40 00 00 4d call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005254: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
40005258: 80 a0 60 2e cmp %g1, 0x2e
<== NOT EXECUTED
4000525c: 32 bf ff cf bne,a 40005198 <rtems_filesystem_eval_path_generic+0x64>
<== NOT EXECUTED
40005260: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
40005264: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
<== NOT EXECUTED
40005268: 80 a0 60 2e cmp %g1, 0x2e
<== NOT EXECUTED
4000526c: 32 bf ff cb bne,a 40005198 <rtems_filesystem_eval_path_generic+0x64>
<== NOT EXECUTED
40005270: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40005274: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40005278: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
<== NOT EXECUTED
4000527c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
40005280: c6 02 60 14 ld [ %o1 + 0x14 ], %g3
<== NOT EXECUTED
40005284: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40005288: 12 80 00 0a bne 400052b0 <rtems_filesystem_eval_path_generic+0x17c>
<== NOT EXECUTED
4000528c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
40005290: 9f c0 80 00 call %g2
<== NOT EXECUTED
40005294: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
40005298: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000529c: 32 bf ff d5 bne,a 400051f0 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
400052a0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
400052a4: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
400052a8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
400052ac: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
400052b0: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
<== NOT EXECUTED
400052b4: 9f c0 80 00 call %g2
<== NOT EXECUTED
400052b8: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
} else if (is_fs_root(currentloc)) {
400052bc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400052c0: 12 80 00 12 bne 40005308 <rtems_filesystem_eval_path_generic+0x1d4>
<== NOT EXECUTED
400052c4: 96 10 20 02 mov 2, %o3
<== NOT EXECUTED
status = (*config->eval_token)(ctx, arg, "..", 2);
400052c8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
400052cc: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
400052d0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400052d4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400052d8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
400052dc: 10 bf ff b5 b 400051b0 <rtems_filesystem_eval_path_generic+0x7c>
<== NOT EXECUTED
400052e0: 80 a2 20 02 cmp %o0, 2
<== NOT EXECUTED
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
400052e4: 80 88 61 00 btst 0x100, %g1
<== NOT EXECUTED
400052e8: 22 bf ff c2 be,a 400051f0 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
400052ec: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, EINVAL);
400052f0: b2 10 20 16 mov 0x16, %i1
<== NOT EXECUTED
400052f4: 40 00 00 24 call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
400052f8: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
400052fc: b2 10 20 14 mov 0x14, %i1
<== NOT EXECUTED
40005300: 40 00 00 21 call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005304: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
if (currentloc->mt_entry->mt_point_node != NULL) {
40005308: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
4000530c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
<== NOT EXECUTED
40005310: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40005314: 22 bf ff b7 be,a 400051f0 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
40005318: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
size_t tokenlen = ctx->tokenlen;
4000531c: c8 07 60 0c ld [ %i5 + 0xc ], %g4
<== NOT EXECUTED
ctx->path -= tokenlen;
40005320: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
ctx->pathlen += tokenlen;
40005324: c4 07 60 04 ld [ %i5 + 4 ], %g2
<== NOT EXECUTED
ctx->path -= tokenlen;
40005328: 86 20 c0 04 sub %g3, %g4, %g3
<== NOT EXECUTED
ctx->pathlen += tokenlen;
4000532c: 84 00 80 04 add %g2, %g4, %g2
<== NOT EXECUTED
ctx->path -= tokenlen;
40005330: c6 27 40 00 st %g3, [ %i5 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_restart(
40005334: b2 00 60 20 add %g1, 0x20, %i1
<== NOT EXECUTED
ctx->pathlen += tokenlen;
40005338: c4 27 60 04 st %g2, [ %i5 + 4 ]
<== NOT EXECUTED
ctx->tokenlen = 0;
4000533c: c0 27 60 0c clr [ %i5 + 0xc ]
<== NOT EXECUTED
40005340: 40 00 00 e7 call 400056dc <rtems_filesystem_eval_path_restart>
<== NOT EXECUTED
40005344: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40005d98 <rtems_filesystem_eval_path_next_token>:
const char *current = ctx->path;
40005d98: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
40005d9c: c6 02 20 04 ld [ %o0 + 4 ], %g3
40005da0: 86 00 40 03 add %g1, %g3, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40005da4: 80 a0 40 03 cmp %g1, %g3
40005da8: 32 80 00 09 bne,a 40005dcc <rtems_filesystem_eval_path_next_token+0x34>
<== ALWAYS TAKEN
40005dac: c4 48 40 00 ldsb [ %g1 ], %g2
40005db0: 10 80 00 20 b 40005e30 <rtems_filesystem_eval_path_next_token+0x98>
<== NOT EXECUTED
40005db4: 9a 10 20 00 clr %o5
<== NOT EXECUTED
++current;
40005db8: 82 00 60 01 inc %g1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40005dbc: 80 a0 c0 01 cmp %g3, %g1
40005dc0: 22 80 00 22 be,a 40005e48 <rtems_filesystem_eval_path_next_token+0xb0>
<== NEVER TAKEN
40005dc4: 82 10 00 03 mov %g3, %g1
<== NOT EXECUTED
40005dc8: c4 48 40 00 ldsb [ %g1 ], %g2
40005dcc: 80 a0 a0 2f cmp %g2, 0x2f
40005dd0: 02 bf ff fa be 40005db8 <rtems_filesystem_eval_path_next_token+0x20>
40005dd4: 80 a0 a0 5c cmp %g2, 0x5c
40005dd8: 22 bf ff f9 be,a 40005dbc <rtems_filesystem_eval_path_next_token+0x24>
<== NEVER TAKEN
40005ddc: 82 00 60 01 inc %g1
<== NOT EXECUTED
ctx->path = current;
40005de0: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
40005de4: 9a 20 c0 01 sub %g3, %g1, %o5
40005de8: da 22 20 04 st %o5, [ %o0 + 4 ]
40005dec: c4 48 40 00 ldsb [ %g1 ], %g2
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40005df0: 80 a0 a0 5c cmp %g2, 0x5c
40005df4: 02 80 00 1f be 40005e70 <rtems_filesystem_eval_path_next_token+0xd8>
<== NEVER TAKEN
40005df8: 80 a0 a0 2f cmp %g2, 0x2f
40005dfc: 02 80 00 1e be 40005e74 <rtems_filesystem_eval_path_next_token+0xdc>
<== NEVER TAKEN
40005e00: 88 10 00 0d mov %o5, %g4
40005e04: 10 80 00 07 b 40005e20 <rtems_filesystem_eval_path_next_token+0x88>
40005e08: 84 10 00 01 mov %g1, %g2
40005e0c: 80 a1 20 2f cmp %g4, 0x2f
40005e10: 02 80 00 10 be 40005e50 <rtems_filesystem_eval_path_next_token+0xb8>
40005e14: 80 a1 20 5c cmp %g4, 0x5c
40005e18: 02 80 00 0f be 40005e54 <rtems_filesystem_eval_path_next_token+0xbc>
<== NEVER TAKEN
40005e1c: 88 20 c0 02 sub %g3, %g2, %g4
++current;
40005e20: 84 00 a0 01 inc %g2
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40005e24: 80 a0 80 03 cmp %g2, %g3
40005e28: 32 bf ff f9 bne,a 40005e0c <rtems_filesystem_eval_path_next_token+0x74>
40005e2c: c8 48 80 00 ldsb [ %g2 ], %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40005e30: 88 10 20 00 clr %g4
}
ctx->path = current;
40005e34: c6 22 00 00 st %g3, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
40005e38: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
40005e3c: c2 22 20 08 st %g1, [ %o0 + 8 ]
rtems_filesystem_eval_path_context_t *ctx
)
{
rtems_filesystem_eval_path_eat_delimiter(ctx);
next_token(ctx);
}
40005e40: 81 c3 e0 08 retl
40005e44: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40005e48: 10 bf ff fa b 40005e30 <rtems_filesystem_eval_path_next_token+0x98>
<== NOT EXECUTED
40005e4c: 9a 10 20 00 clr %o5
<== NOT EXECUTED
40005e50: 88 20 c0 02 sub %g3, %g2, %g4
40005e54: 9a 20 80 01 sub %g2, %g1, %o5
++current;
40005e58: 86 10 00 02 mov %g2, %g3
ctx->pathlen = (size_t) (end - current);
40005e5c: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->path = current;
40005e60: c6 22 00 00 st %g3, [ %o0 ]
ctx->token = begin;
40005e64: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
40005e68: 81 c3 e0 08 retl
40005e6c: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40005e70: 88 10 00 0d mov %o5, %g4
<== NOT EXECUTED
40005e74: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
40005e78: 10 bf ff ef b 40005e34 <rtems_filesystem_eval_path_next_token+0x9c>
<== NOT EXECUTED
40005e7c: 9a 10 20 00 clr %o5
<== NOT EXECUTED
40005740 <rtems_filesystem_eval_path_recursive>:
{
40005740: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if (pathlen > 0) {
40005744: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40005748: 02 80 00 22 be 400057d0 <rtems_filesystem_eval_path_recursive+0x90>
<== NOT EXECUTED
4000574c: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
40005750: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
40005754: 80 a0 60 1f cmp %g1, 0x1f
<== NOT EXECUTED
40005758: 14 80 00 20 bg 400057d8 <rtems_filesystem_eval_path_recursive+0x98>
<== NOT EXECUTED
4000575c: 01 00 00 00 nop
<== NOT EXECUTED
return c == '/' || c == '\\';
40005760: c4 4e 40 00 ldsb [ %i1 ], %g2
<== NOT EXECUTED
const char *saved_path = ctx->path;
40005764: f6 06 00 00 ld [ %i0 ], %i3
<== NOT EXECUTED
if (rtems_filesystem_is_delimiter(path [0])) {
40005768: 80 a0 a0 2f cmp %g2, 0x2f
<== NOT EXECUTED
4000576c: 02 80 00 1d be 400057e0 <rtems_filesystem_eval_path_recursive+0xa0>
<== NOT EXECUTED
40005770: f8 06 20 04 ld [ %i0 + 4 ], %i4
<== NOT EXECUTED
40005774: 80 a0 a0 5c cmp %g2, 0x5c
<== NOT EXECUTED
40005778: 02 80 00 1b be 400057e4 <rtems_filesystem_eval_path_recursive+0xa4>
<== NOT EXECUTED
4000577c: 92 07 60 30 add %i5, 0x30, %o1
<== NOT EXECUTED
++ctx->recursionlevel;
40005780: 82 00 60 01 inc %g1
<== NOT EXECUTED
ctx->path = path;
40005784: f2 27 40 00 st %i1, [ %i5 ]
<== NOT EXECUTED
ctx->pathlen = pathlen;
40005788: f4 27 60 04 st %i2, [ %i5 + 4 ]
<== NOT EXECUTED
++ctx->recursionlevel;
4000578c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
40005790: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40005794: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40005798: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
4000579c: 9f c0 40 00 call %g1
<== NOT EXECUTED
400057a0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
while (ctx->pathlen > 0) {
400057a4: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
400057a8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400057ac: 32 bf ff fa bne,a 40005794 <rtems_filesystem_eval_path_recursive+0x54>
<== NOT EXECUTED
400057b0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
--ctx->recursionlevel;
400057b4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
400057b8: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
ctx->path = saved_path;
400057bc: f6 27 40 00 st %i3, [ %i5 ]
<== NOT EXECUTED
--ctx->recursionlevel;
400057c0: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
ctx->pathlen = saved_pathlen;
400057c4: f8 27 60 04 st %i4, [ %i5 + 4 ]
<== NOT EXECUTED
}
400057c8: 81 c7 e0 08 ret
<== NOT EXECUTED
400057cc: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOENT);
400057d0: 7f ff fe ed call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
400057d4: 93 e8 20 02 restore %g0, 2, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ELOOP);
400057d8: 7f ff fe eb call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
400057dc: 93 e8 20 5c restore %g0, 0x5c, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
400057e0: 92 07 60 30 add %i5, 0x30, %o1
<== NOT EXECUTED
400057e4: 7f ff ff be call 400056dc <rtems_filesystem_eval_path_restart>
<== NOT EXECUTED
400057e8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400057ec: 10 bf ff e5 b 40005780 <rtems_filesystem_eval_path_recursive+0x40>
<== NOT EXECUTED
400057f0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
400056dc <rtems_filesystem_eval_path_restart>:
void rtems_filesystem_eval_path_restart(
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_global_location_t **newstartloc_ptr
)
{
400056dc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
400056e0: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
free_location(&ctx->currentloc);
400056e4: b0 06 20 18 add %i0, 0x18, %i0
<== NOT EXECUTED
400056e8: 7f ff ff 18 call 40005348 <free_location>
<== NOT EXECUTED
400056ec: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400056f0: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
400056f4: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
<== NOT EXECUTED
400056f8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
400056fc: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
40005700: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005704: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_instance_unlock(&ctx->startloc->location);
rtems_filesystem_global_location_assign(
40005708: 40 00 00 b1 call 400059cc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
4000570c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40005710: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
40005714: 40 00 01 02 call 40005b1c <rtems_filesystem_global_location_assign>
<== NOT EXECUTED
40005718: 90 07 60 34 add %i5, 0x34, %o0
<== NOT EXECUTED
4000571c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
40005720: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
40005724: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40005728: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4000572c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005730: 01 00 00 00 nop
<== NOT EXECUTED
&ctx->startloc,
rtems_filesystem_global_location_obtain(newstartloc_ptr)
);
rtems_filesystem_instance_lock(&ctx->startloc->location);
rtems_filesystem_location_clone(&ctx->currentloc, &ctx->startloc->location);
40005734: f2 07 60 34 ld [ %i5 + 0x34 ], %i1
<== NOT EXECUTED
40005738: 40 00 21 25 call 4000dbcc <rtems_filesystem_location_clone>
<== NOT EXECUTED
4000573c: 81 e8 00 00 restore
<== NOT EXECUTED
40005518 <rtems_filesystem_eval_path_start_with_root_and_current>:
{
40005518: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
4000551c: 94 10 20 30 mov 0x30, %o2
40005520: 92 10 20 00 clr %o1
40005524: 40 00 25 bc call 4000ec14 <memset>
40005528: 90 06 20 08 add %i0, 8, %o0
ctx->path = path;
4000552c: f2 26 00 00 st %i1, [ %i0 ]
if (ctx->pathlen > 0) {
40005530: 80 a6 a0 00 cmp %i2, 0
ctx->pathlen = pathlen;
40005534: f4 26 20 04 st %i2, [ %i0 + 4 ]
if (ctx->pathlen > 0) {
40005538: 02 80 00 1d be 400055ac <rtems_filesystem_eval_path_start_with_root_and_current+0x94>
<== NEVER TAKEN
4000553c: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
40005540: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
40005544: 40 00 01 22 call 400059cc <rtems_filesystem_global_location_obtain>
40005548: 90 10 00 1c mov %i4, %o0
return c == '/' || c == '\\';
4000554c: 83 2e e0 18 sll %i3, 0x18, %g1
40005550: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
40005554: 80 a0 60 2f cmp %g1, 0x2f
40005558: 02 80 00 2f be 40005614 <rtems_filesystem_eval_path_start_with_root_and_current+0xfc>
<== ALWAYS TAKEN
4000555c: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
40005560: 80 a0 60 5c cmp %g1, 0x5c
<== NOT EXECUTED
40005564: 22 80 00 2d be,a 40005618 <rtems_filesystem_eval_path_start_with_root_and_current+0x100>
<== NOT EXECUTED
40005568: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain(
4000556c: 40 00 01 18 call 400059cc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40005570: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40005574: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
<== NOT EXECUTED
40005578: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
4000557c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40005580: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
40005584: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005588: ba 06 20 18 add %i0, 0x18, %i5
<== NOT EXECUTED
rtems_filesystem_location_clone(
4000558c: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
<== NOT EXECUTED
40005590: 40 00 21 8f call 4000dbcc <rtems_filesystem_location_clone>
<== NOT EXECUTED
40005594: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_continue(ctx);
40005598: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000559c: 7f ff ff c2 call 400054a4 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
400055a0: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
400055a4: 81 c7 e0 08 ret
<== NOT EXECUTED
400055a8: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_global_location_t *global_loc = NULL;
400055ac: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
400055b0: 40 00 01 07 call 400059cc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
400055b4: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
400055b8: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
<== NOT EXECUTED
400055bc: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
400055c0: 40 00 01 03 call 400059cc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
400055c4: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain_null();
400055c8: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
<== NOT EXECUTED
errno = ENOENT;
400055cc: 40 00 25 28 call 4000ea6c <__errno>
<== NOT EXECUTED
400055d0: ba 06 20 18 add %i0, 0x18, %i5
<== NOT EXECUTED
400055d4: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
400055d8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400055dc: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
<== NOT EXECUTED
400055e0: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
400055e4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
400055e8: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
400055ec: 9f c0 40 00 call %g1
<== NOT EXECUTED
400055f0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_clone(
400055f4: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
<== NOT EXECUTED
400055f8: 40 00 21 75 call 4000dbcc <rtems_filesystem_location_clone>
<== NOT EXECUTED
400055fc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_continue(ctx);
40005600: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40005604: 7f ff ff a8 call 400054a4 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
40005608: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4000560c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005610: 81 e8 00 00 restore
<== NOT EXECUTED
++ctx->path;
40005614: c4 06 00 00 ld [ %i0 ], %g2
--ctx->pathlen;
40005618: c2 06 20 04 ld [ %i0 + 4 ], %g1
++ctx->path;
4000561c: 84 00 a0 01 inc %g2
--ctx->pathlen;
40005620: 82 00 7f ff add %g1, -1, %g1
++ctx->path;
40005624: c4 26 00 00 st %g2, [ %i0 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
40005628: 90 06 20 30 add %i0, 0x30, %o0
--ctx->pathlen;
4000562c: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
40005630: 40 00 00 e7 call 400059cc <rtems_filesystem_global_location_obtain>
40005634: ba 06 20 18 add %i0, 0x18, %i5
40005638: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
4000563c: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
40005640: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005644: c2 00 40 00 ld [ %g1 ], %g1
40005648: 9f c0 40 00 call %g1
4000564c: 01 00 00 00 nop
rtems_filesystem_location_clone(
40005650: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40005654: 40 00 21 5e call 4000dbcc <rtems_filesystem_location_clone>
40005658: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
4000565c: 90 10 00 18 mov %i0, %o0
40005660: 7f ff ff 91 call 400054a4 <rtems_filesystem_eval_path_continue>
40005664: b0 10 00 1d mov %i5, %i0
}
40005668: 81 c7 e0 08 ret
4000566c: 81 e8 00 00 restore
4000df30 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000df30: 9d e3 bf 98 save %sp, -104, %sp
4000df34: 82 10 00 18 mov %i0, %g1
find_arg fa = {
4000df38: c0 27 bf fc clr [ %fp + -4 ]
4000df3c: b0 10 20 00 clr %i0
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
4000df40: 80 a0 60 00 cmp %g1, 0
4000df44: 02 80 00 07 be 4000df60 <rtems_filesystem_get_mount_handler+0x30>
<== NEVER TAKEN
4000df48: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_filesystem_iterate( find_handler, &fa );
4000df4c: 92 07 bf f8 add %fp, -8, %o1
4000df50: 11 10 00 37 sethi %hi(0x4000dc00), %o0
4000df54: 7f ff ff cb call 4000de80 <rtems_filesystem_iterate>
4000df58: 90 12 22 4c or %o0, 0x24c, %o0 ! 4000de4c <find_handler>
4000df5c: f0 07 bf fc ld [ %fp + -4 ], %i0
}
return fa.mount_h;
}
4000df60: 81 c7 e0 08 ret
4000df64: 81 e8 00 00 restore
40005b1c <rtems_filesystem_global_location_assign>:
{
40005b1c: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005b20: 91 d0 20 09 ta 9
<== NOT EXECUTED
lhs_global_loc = *lhs_global_loc_ptr;
40005b24: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
*lhs_global_loc_ptr = rhs_global_loc;
40005b28: d2 20 80 00 st %o1, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005b2c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005b30: 01 00 00 00 nop
rtems_filesystem_global_location_release(lhs_global_loc, true);
40005b34: 92 10 20 01 mov 1, %o1 ! 1 <_TLS_Alignment>
40005b38: 82 13 c0 00 mov %o7, %g1
40005b3c: 7f ff ff de call 40005ab4 <rtems_filesystem_global_location_release>
40005b40: 9e 10 40 00 mov %g1, %o7
400059cc <rtems_filesystem_global_location_obtain>:
{
400059cc: 9d e3 bf 98 save %sp, -104, %sp
if (deferred_released_global_locations != NULL) {
400059d0: 3b 10 00 4b sethi %hi(0x40012c00), %i5
400059d4: c2 07 63 f4 ld [ %i5 + 0x3f4 ], %g1 ! 40012ff4 <deferred_released_global_locations>
400059d8: 80 a0 60 00 cmp %g1, 0
400059dc: 02 80 00 1e be 40005a54 <rtems_filesystem_global_location_obtain+0x88>
400059e0: 01 00 00 00 nop
400059e4: ba 17 63 f4 or %i5, 0x3f4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400059e8: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
400059ec: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
400059f0: 80 a2 20 00 cmp %o0, 0
400059f4: 02 80 00 07 be 40005a10 <rtems_filesystem_global_location_obtain+0x44>
<== NEVER TAKEN
400059f8: 92 10 20 00 clr %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
400059fc: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
<== NOT EXECUTED
count = current->deferred_released_count;
40005a00: d2 02 20 20 ld [ %o0 + 0x20 ], %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
40005a04: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
current->deferred_released_next = NULL;
40005a08: c0 22 20 1c clr [ %o0 + 0x1c ]
<== NOT EXECUTED
current->deferred_released_count = 0;
40005a0c: c0 22 20 20 clr [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005a10: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005a14: 01 00 00 00 nop
if (current != NULL) {
40005a18: 80 a2 20 00 cmp %o0, 0
40005a1c: 02 80 00 0e be 40005a54 <rtems_filesystem_global_location_obtain+0x88>
<== NEVER TAKEN
40005a20: 01 00 00 00 nop
release_with_count(current, count);
40005a24: 7f ff ff be call 4000591c <release_with_count>
40005a28: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005a2c: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
40005a30: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
40005a34: 80 a2 20 00 cmp %o0, 0
40005a38: 12 bf ff f1 bne 400059fc <rtems_filesystem_global_location_obtain+0x30>
<== NEVER TAKEN
40005a3c: 92 10 20 00 clr %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005a40: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005a44: 01 00 00 00 nop
if (current != NULL) {
40005a48: 80 a2 20 00 cmp %o0, 0
40005a4c: 12 bf ff f6 bne 40005a24 <rtems_filesystem_global_location_obtain+0x58>
<== NEVER TAKEN
40005a50: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005a54: 91 d0 20 09 ta 9
<== NOT EXECUTED
global_loc = *global_loc_ptr;
40005a58: f0 06 00 00 ld [ %i0 ], %i0
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
40005a5c: 80 a6 20 00 cmp %i0, 0
40005a60: 02 80 00 07 be 40005a7c <rtems_filesystem_global_location_obtain+0xb0>
<== NEVER TAKEN
40005a64: 01 00 00 00 nop
40005a68: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
40005a6c: c4 08 a0 28 ldub [ %g2 + 0x28 ], %g2
40005a70: 80 a0 a0 00 cmp %g2, 0
40005a74: 32 80 00 0a bne,a 40005a9c <rtems_filesystem_global_location_obtain+0xd0>
<== ALWAYS TAKEN
40005a78: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
errno = ENXIO;
40005a7c: 40 00 23 fc call 4000ea6c <__errno>
<== NOT EXECUTED
40005a80: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
40005a84: 84 10 20 06 mov 6, %g2
<== NOT EXECUTED
40005a88: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
global_loc = &rtems_filesystem_global_location_null;
40005a8c: 31 10 00 47 sethi %hi(0x40011c00), %i0
<== NOT EXECUTED
40005a90: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
40005a94: b0 16 23 98 or %i0, 0x398, %i0
<== NOT EXECUTED
++global_loc->reference_count;
40005a98: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
<== NOT EXECUTED
40005a9c: 84 00 a0 01 inc %g2
<== NOT EXECUTED
40005aa0: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005aa4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005aa8: 01 00 00 00 nop
}
40005aac: 81 c7 e0 08 ret
40005ab0: 81 e8 00 00 restore
40005ab4 <rtems_filesystem_global_location_release>:
if (!deferred) {
40005ab4: 80 a2 60 00 cmp %o1, 0
40005ab8: 22 80 00 16 be,a 40005b10 <rtems_filesystem_global_location_release+0x5c>
40005abc: 92 10 20 01 mov 1, %o1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005ac0: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (global_loc->deferred_released_count == 0) {
40005ac4: c6 02 20 20 ld [ %o0 + 0x20 ], %g3
40005ac8: 80 a0 e0 00 cmp %g3, 0
40005acc: 22 80 00 08 be,a 40005aec <rtems_filesystem_global_location_release+0x38>
40005ad0: 07 10 00 4b sethi %hi(0x40012c00), %g3
++global_loc->deferred_released_count;
40005ad4: 86 00 e0 01 inc %g3
<== NOT EXECUTED
40005ad8: c6 22 20 20 st %g3, [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005adc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ae0: 01 00 00 00 nop
}
40005ae4: 81 c3 e0 08 retl
40005ae8: 01 00 00 00 nop
rtems_filesystem_global_location_t *head =
40005aec: c8 00 e3 f4 ld [ %g3 + 0x3f4 ], %g4
<== NOT EXECUTED
global_loc->deferred_released_next = head;
40005af0: c8 22 20 1c st %g4, [ %o0 + 0x1c ]
<== NOT EXECUTED
global_loc->deferred_released_count = 1;
40005af4: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
deferred_released_global_locations = global_loc;
40005af8: d0 20 e3 f4 st %o0, [ %g3 + 0x3f4 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 1;
40005afc: c8 22 20 20 st %g4, [ %o0 + 0x20 ]
<== NOT EXECUTED
40005b00: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005b04: 01 00 00 00 nop
}
40005b08: 81 c3 e0 08 retl
40005b0c: 01 00 00 00 nop
release_with_count(global_loc, 1);
40005b10: 82 13 c0 00 mov %o7, %g1
40005b14: 7f ff ff 82 call 4000591c <release_with_count>
40005b18: 9e 10 40 00 mov %g1, %o7
40004280 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40004280: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40004284: 05 10 00 40 sethi %hi(0x40010000), %g2
40004288: 82 10 a1 5c or %g2, 0x15c, %g1 ! 4001015c <rtems_filesystem_root_configuration>
4000428c: d0 00 a1 5c ld [ %g2 + 0x15c ], %o0
40004290: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
40004294: d6 00 60 0c ld [ %g1 + 0xc ], %o3
40004298: d4 00 60 08 ld [ %g1 + 8 ], %o2
4000429c: 40 00 01 a4 call 4000492c <mount>
400042a0: d2 00 60 04 ld [ %g1 + 4 ], %o1
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
400042a4: 80 a2 20 00 cmp %o0, 0
400042a8: 12 80 00 0a bne 400042d0 <rtems_filesystem_initialize+0x50>
<== NEVER TAKEN
400042ac: 92 10 21 ed mov 0x1ed, %o1
* Traditionally RTEMS devices are under "/dev" so install this directory.
*
* If the mkdir() fails, we can't print anything so just fatal error.
*/
rv = mkdir( "/dev", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH );
400042b0: 11 10 00 41 sethi %hi(0x40010400), %o0
400042b4: 40 00 01 56 call 4000480c <mkdir>
400042b8: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400104a0 <IMFS_node_control_sym_link+0x14>
if ( rv != 0 )
400042bc: 80 a2 20 00 cmp %o0, 0
400042c0: 12 80 00 07 bne 400042dc <rtems_filesystem_initialize+0x5c>
<== NEVER TAKEN
400042c4: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
400042c8: 81 c7 e0 08 ret
400042cc: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xABCD0002 );
400042d0: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
<== NOT EXECUTED
400042d4: 40 00 0b 76 call 400070ac <rtems_fatal_error_occurred>
<== NOT EXECUTED
400042d8: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0x6b8d0002>
<== NOT EXECUTED
rtems_fatal_error_occurred( 0xABCD0003 );
400042dc: 40 00 0b 74 call 400070ac <rtems_fatal_error_occurred>
<== NOT EXECUTED
400042e0: 90 12 20 03 or %o0, 3, %o0
<== NOT EXECUTED
400042e4: 01 00 00 00 nop
<== NOT EXECUTED
4000de80 <rtems_filesystem_iterate>:
{
4000de80: 9d e3 bf a0 save %sp, -96, %sp
while ( table_entry->type && !stop ) {
4000de84: 3b 10 00 40 sethi %hi(0x40010000), %i5
4000de88: c2 07 61 d8 ld [ %i5 + 0x1d8 ], %g1 ! 400101d8 <rtems_filesystem_table>
4000de8c: 80 a0 60 00 cmp %g1, 0
4000de90: 12 80 00 06 bne 4000dea8 <rtems_filesystem_iterate+0x28>
<== ALWAYS TAKEN
4000de94: ba 17 61 d8 or %i5, 0x1d8, %i5
4000de98: 30 80 00 0f b,a 4000ded4 <rtems_filesystem_iterate+0x54>
<== NOT EXECUTED
4000de9c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000dea0: 32 80 00 22 bne,a 4000df28 <rtems_filesystem_iterate+0xa8>
<== NOT EXECUTED
4000dea4: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
stop = (*routine)( table_entry, routine_arg );
4000dea8: 90 10 00 1d mov %i5, %o0
4000deac: 9f c6 00 00 call %i0
4000deb0: 92 10 00 19 mov %i1, %o1
++table_entry;
4000deb4: ba 07 60 08 add %i5, 8, %i5
while ( table_entry->type && !stop ) {
4000deb8: c2 07 40 00 ld [ %i5 ], %g1
4000debc: 80 a0 60 00 cmp %g1, 0
4000dec0: 12 bf ff f7 bne 4000de9c <rtems_filesystem_iterate+0x1c>
<== NEVER TAKEN
4000dec4: b8 10 00 08 mov %o0, %i4
if ( !stop ) {
4000dec8: b8 8a 20 ff andcc %o0, 0xff, %i4
4000decc: 12 80 00 17 bne 4000df28 <rtems_filesystem_iterate+0xa8>
<== ALWAYS TAKEN
4000ded0: 01 00 00 00 nop
rtems_libio_lock();
4000ded4: 7f ff d9 9f call 40004550 <rtems_libio_lock>
<== NOT EXECUTED
4000ded8: 37 10 00 48 sethi %hi(0x40012000), %i3
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000dedc: fa 06 e1 70 ld [ %i3 + 0x170 ], %i5 ! 40012170 <filesystem_chain>
<== NOT EXECUTED
4000dee0: b6 16 e1 70 or %i3, 0x170, %i3
<== NOT EXECUTED
for (
4000dee4: b6 06 e0 04 add %i3, 4, %i3
<== NOT EXECUTED
4000dee8: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
4000deec: 12 80 00 06 bne 4000df04 <rtems_filesystem_iterate+0x84>
<== NOT EXECUTED
4000def0: b8 10 20 00 clr %i4
<== NOT EXECUTED
4000def4: 30 80 00 0b b,a 4000df20 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
!rtems_chain_is_tail( chain, node ) && !stop;
4000def8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000defc: 12 80 00 09 bne 4000df20 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
4000df00: 01 00 00 00 nop
<== NOT EXECUTED
stop = (*routine)( &fsn->entry, routine_arg );
4000df04: 90 07 60 08 add %i5, 8, %o0
<== NOT EXECUTED
4000df08: 9f c6 00 00 call %i0
<== NOT EXECUTED
4000df0c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000df10: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
for (
4000df14: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
4000df18: 12 bf ff f8 bne 4000def8 <rtems_filesystem_iterate+0x78>
<== NOT EXECUTED
4000df1c: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rtems_libio_unlock();
4000df20: 7f ff d9 91 call 40004564 <rtems_libio_unlock>
<== NOT EXECUTED
4000df24: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
}
4000df28: 81 c7 e0 08 ret
4000df2c: 91 e8 00 1c restore %g0, %i4, %o0
4000dbcc <rtems_filesystem_location_clone>:
void rtems_filesystem_location_clone(
rtems_filesystem_location_info_t *clone,
const rtems_filesystem_location_info_t *master
)
{
4000dbcc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
clone = rtems_filesystem_location_copy( clone, master );
4000dbd0: 92 10 00 19 mov %i1, %o1
4000dbd4: 7f ff df 08 call 400057f4 <rtems_filesystem_location_copy>
4000dbd8: 90 10 00 18 mov %i0, %o0
rv = (*clone->mt_entry->ops->clonenod_h)( clone );
4000dbdc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000dbe0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000dbe4: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
4000dbe8: 9f c0 40 00 call %g1
4000dbec: ba 10 00 08 mov %o0, %i5
if ( rv != 0 ) {
4000dbf0: 80 a2 20 00 cmp %o0, 0
4000dbf4: 12 80 00 04 bne 4000dc04 <rtems_filesystem_location_clone+0x38>
<== NEVER TAKEN
4000dbf8: 90 10 00 1d mov %i5, %o0
rtems_filesystem_location_remove_from_mt_entry( clone );
rtems_filesystem_location_initialize_to_null( clone );
}
}
4000dbfc: 81 c7 e0 08 ret
4000dc00: 81 e8 00 00 restore
return rtems_filesystem_location_copy(
4000dc04: 33 10 00 47 sethi %hi(0x40011c00), %i1
<== NOT EXECUTED
rtems_filesystem_location_remove_from_mt_entry( clone );
4000dc08: 7f ff df cf call 40005b44 <rtems_filesystem_location_remove_from_mt_entry>
<== NOT EXECUTED
4000dc0c: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
4000dc10: 7f ff de f9 call 400057f4 <rtems_filesystem_location_copy>
<== NOT EXECUTED
4000dc14: 93 ee 63 98 restore %i1, 0x398, %o1
<== NOT EXECUTED
400057f4 <rtems_filesystem_location_copy>:
rtems_filesystem_location_info_t *rtems_filesystem_location_copy(
rtems_filesystem_location_info_t *dst,
const rtems_filesystem_location_info_t *src
)
{
dst->node_access = src->node_access;
400057f4: da 02 60 08 ld [ %o1 + 8 ], %o5
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
400057f8: c8 02 60 0c ld [ %o1 + 0xc ], %g4
<== NOT EXECUTED
dst->handlers = src->handlers;
400057fc: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40005800: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
<== NOT EXECUTED
40005804: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40005808: da 22 20 08 st %o5, [ %o0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
4000580c: c8 22 20 0c st %g4, [ %o0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005810: c6 22 20 10 st %g3, [ %o0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005814: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
40005818: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
<== NOT EXECUTED
old_last = tail->previous;
4000581c: c8 00 e0 1c ld [ %g3 + 0x1c ], %g4
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005820: 9a 00 e0 18 add %g3, 0x18, %o5
<== NOT EXECUTED
the_node->next = tail;
40005824: da 22 00 00 st %o5, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005828: d0 20 e0 1c st %o0, [ %g3 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
4000582c: d0 21 00 00 st %o0, [ %g4 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005830: c8 22 20 04 st %g4, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005834: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005838: 01 00 00 00 nop
rtems_chain_initialize_node(&dst->mt_entry_node);
rtems_filesystem_location_add_to_mt_entry(dst);
return dst;
}
4000583c: 81 c3 e0 08 retl
40005840: 01 00 00 00 nop
40005bc8 <rtems_filesystem_location_copy_and_detach>:
{
40005bc8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
dst->node_access = src->node_access;
40005bcc: c8 06 60 08 ld [ %i1 + 8 ], %g4
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005bd0: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
dst->handlers = src->handlers;
40005bd4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40005bd8: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
<== NOT EXECUTED
40005bdc: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40005be0: c8 26 20 08 st %g4, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005be4: c6 26 20 0c st %g3, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005be8: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005bec: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
40005bf0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40005bf4: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005bf8: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40005bfc: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005c00: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005c04: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005c08: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005c0c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005c10: 01 00 00 00 nop
rtems_filesystem_location_remove_from_mt_entry(detach);
40005c14: 7f ff ff cc call 40005b44 <rtems_filesystem_location_remove_from_mt_entry>
40005c18: 90 10 00 19 mov %i1, %o0
dst->node_access = src->node_access;
40005c1c: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
40005c20: 82 10 63 98 or %g1, 0x398, %g1 ! 40011f98 <rtems_filesystem_global_location_null>
<== NOT EXECUTED
40005c24: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
40005c28: c4 26 60 08 st %g2, [ %i1 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005c2c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40005c30: c4 26 60 0c st %g2, [ %i1 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005c34: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40005c38: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
40005c3c: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005c40: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005c44: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005c48: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40005c4c: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005c50: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40005c54: c8 26 40 00 st %g4, [ %i1 ]
<== NOT EXECUTED
tail->previous = the_node;
40005c58: f2 20 a0 1c st %i1, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005c5c: f2 20 c0 00 st %i1, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005c60: c6 26 60 04 st %g3, [ %i1 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005c64: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005c68: 01 00 00 00 nop
}
40005c6c: 81 c7 e0 08 ret
40005c70: 81 e8 00 00 restore
40005844 <rtems_filesystem_location_detach>:
void rtems_filesystem_location_detach(
rtems_filesystem_location_info_t *detach
)
{
40005844: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_filesystem_location_free(detach);
40005848: 40 00 20 f4 call 4000dc18 <rtems_filesystem_location_free>
<== NOT EXECUTED
4000584c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
dst->node_access = src->node_access;
40005850: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
40005854: 82 10 63 98 or %g1, 0x398, %g1 ! 40011f98 <rtems_filesystem_global_location_null>
<== NOT EXECUTED
40005858: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
4000585c: c4 26 20 08 st %g2, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005860: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40005864: c4 26 20 0c st %g2, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005868: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
4000586c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
40005870: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005874: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005878: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000587c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40005880: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005884: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40005888: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
4000588c: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005890: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005894: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005898: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000589c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_initialize_to_null(detach);
}
400058a0: 81 c7 e0 08 ret
<== NOT EXECUTED
400058a4: 81 e8 00 00 restore
<== NOT EXECUTED
4000dc18 <rtems_filesystem_location_free>:
#endif
#include <rtems/libio_.h>
void rtems_filesystem_location_free( rtems_filesystem_location_info_t *loc )
{
4000dc18: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000dc1c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
4000dc20: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4000dc24: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4000dc28: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dc2c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_instance_lock( loc );
(*loc->mt_entry->ops->freenod_h)( loc );
4000dc30: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
4000dc34: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
4000dc38: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
<== NOT EXECUTED
4000dc3c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dc40: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000dc44: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
4000dc48: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4000dc4c: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4000dc50: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000dc54: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_instance_unlock( loc );
rtems_filesystem_location_remove_from_mt_entry( loc );
4000dc58: 7f ff df bb call 40005b44 <rtems_filesystem_location_remove_from_mt_entry>
<== NOT EXECUTED
4000dc5c: 81 e8 00 00 restore
<== NOT EXECUTED
40005b44 <rtems_filesystem_location_remove_from_mt_entry>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005b44: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous = the_node->previous;
40005b48: c6 02 20 04 ld [ %o0 + 4 ], %g3
next = the_node->next;
40005b4c: c8 02 00 00 ld [ %o0 ], %g4
next->previous = previous;
40005b50: c6 21 20 04 st %g3, [ %g4 + 4 ]
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
40005b54: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
previous->next = next;
40005b58: c8 20 c0 00 st %g4, [ %g3 ]
40005b5c: c6 08 a0 28 ldub [ %g2 + 0x28 ], %g3
40005b60: 80 a0 e0 00 cmp %g3, 0
40005b64: 12 80 00 07 bne 40005b80 <rtems_filesystem_location_remove_from_mt_entry+0x3c>
<== ALWAYS TAKEN
40005b68: 01 00 00 00 nop
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
40005b6c: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
<== NOT EXECUTED
40005b70: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
40005b74: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
40005b78: 22 80 00 06 be,a 40005b90 <rtems_filesystem_location_remove_from_mt_entry+0x4c>
<== NOT EXECUTED
40005b7c: c6 00 a0 24 ld [ %g2 + 0x24 ], %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005b80: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005b84: 01 00 00 00 nop
}
40005b88: 81 c3 e0 08 retl
40005b8c: 01 00 00 00 nop
&& mt_entry->mt_fs_root->reference_count == 1;
40005b90: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3
<== NOT EXECUTED
40005b94: 80 a0 e0 01 cmp %g3, 1
<== NOT EXECUTED
40005b98: 12 bf ff fa bne 40005b80 <rtems_filesystem_location_remove_from_mt_entry+0x3c>
<== NOT EXECUTED
40005b9c: 86 00 a0 14 add %g2, 0x14, %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005ba0: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
head->previous = NULL;
40005ba4: c0 20 a0 18 clr [ %g2 + 0x18 ]
<== NOT EXECUTED
head->next = tail;
40005ba8: c8 20 a0 14 st %g4, [ %g2 + 0x14 ]
<== NOT EXECUTED
tail->previous = head;
40005bac: c6 20 a0 1c st %g3, [ %g2 + 0x1c ]
<== NOT EXECUTED
40005bb0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005bb4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
40005bb8: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
40005bbc: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40005bc0: 7f ff ff 3a call 400058a8 <rtems_filesystem_do_unmount>
<== NOT EXECUTED
40005bc4: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40005c74 <rtems_filesystem_location_transform_to_global>:
{
40005c74: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
40005c78: 7f ff fa d1 call 400047bc <malloc>
<== NOT EXECUTED
40005c7c: 90 10 20 24 mov 0x24, %o0
<== NOT EXECUTED
if (global_loc != NULL) {
40005c80: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
40005c84: 02 80 00 1c be 40005cf4 <rtems_filesystem_location_transform_to_global+0x80>
<== NOT EXECUTED
40005c88: b8 10 20 01 mov 1, %i4
<== NOT EXECUTED
dst->node_access = src->node_access;
40005c8c: c8 06 20 08 ld [ %i0 + 8 ], %g4
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005c90: c6 06 20 0c ld [ %i0 + 0xc ], %g3
<== NOT EXECUTED
dst->handlers = src->handlers;
40005c94: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40005c98: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
global_loc->deferred_released_next = NULL;
40005c9c: c0 27 60 1c clr [ %i5 + 0x1c ]
<== NOT EXECUTED
global_loc->reference_count = 1;
40005ca0: f8 27 60 18 st %i4, [ %i5 + 0x18 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 0;
40005ca4: c0 27 60 20 clr [ %i5 + 0x20 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40005ca8: c8 27 60 08 st %g4, [ %i5 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005cac: c6 27 60 0c st %g3, [ %i5 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005cb0: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40005cb4: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005cb8: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005cbc: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40005cc0: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005cc4: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40005cc8: c8 27 40 00 st %g4, [ %i5 ]
<== NOT EXECUTED
tail->previous = the_node;
40005ccc: fa 20 a0 1c st %i5, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005cd0: fa 20 c0 00 st %i5, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005cd4: c6 27 60 04 st %g3, [ %i5 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005cd8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005cdc: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_remove_from_mt_entry(loc);
40005ce0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40005ce4: 7f ff ff 98 call 40005b44 <rtems_filesystem_location_remove_from_mt_entry>
<== NOT EXECUTED
40005ce8: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
40005cec: 81 c7 e0 08 ret
<== NOT EXECUTED
40005cf0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_location_free(loc);
40005cf4: 40 00 1f c9 call 4000dc18 <rtems_filesystem_location_free>
<== NOT EXECUTED
40005cf8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
40005cfc: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
40005d00: 7f ff ff 33 call 400059cc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40005d04: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
errno = ENOMEM;
40005d08: 40 00 23 59 call 4000ea6c <__errno>
<== NOT EXECUTED
40005d0c: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
40005d10: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40005d14: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40005d18: 81 c7 e0 08 ret
<== NOT EXECUTED
40005d1c: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40004828 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40004828: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
4000482c: 40 00 01 e3 call 40004fb8 <rtems_current_user_env_get>
40004830: 01 00 00 00 nop
40004834: d6 02 20 08 ld [ %o0 + 8 ], %o3
40004838: 96 2e c0 0b andn %i3, %o3, %o3
switch (mode & S_IFMT) {
4000483c: 03 00 00 3c sethi %hi(0xf000), %g1
40004840: 05 00 00 10 sethi %hi(0x4000), %g2
40004844: 82 0a c0 01 and %o3, %g1, %g1
40004848: 80 a0 40 02 cmp %g1, %g2
4000484c: 22 80 00 0c be,a 4000487c <rtems_filesystem_mknod+0x54>
40004850: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40004854: 08 80 00 14 bleu 400048a4 <rtems_filesystem_mknod+0x7c>
<== ALWAYS TAKEN
40004858: 05 00 00 04 sethi %hi(0x1000), %g2
4000485c: 05 00 00 18 sethi %hi(0x6000), %g2
<== NOT EXECUTED
40004860: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40004864: 02 80 00 05 be 40004878 <rtems_filesystem_mknod+0x50>
<== NOT EXECUTED
40004868: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
4000486c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40004870: 12 80 00 13 bne 400048bc <rtems_filesystem_mknod+0x94>
<== NOT EXECUTED
40004874: 01 00 00 00 nop
<== NOT EXECUTED
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
40004878: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
4000487c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40004880: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40004884: 98 10 00 1c mov %i4, %o4
40004888: 9a 10 00 1d mov %i5, %o5
4000488c: 94 10 00 1a mov %i2, %o2
40004890: 92 10 00 19 mov %i1, %o1
40004894: 9f c0 40 00 call %g1
40004898: 90 10 00 18 mov %i0, %o0
4000489c: 81 c7 e0 08 ret
400048a0: 91 e8 00 08 restore %g0, %o0, %o0
switch (mode & S_IFMT) {
400048a4: 80 a0 40 02 cmp %g1, %g2
400048a8: 02 bf ff f4 be 40004878 <rtems_filesystem_mknod+0x50>
<== NEVER TAKEN
400048ac: 05 00 00 08 sethi %hi(0x2000), %g2
400048b0: 80 a0 40 02 cmp %g1, %g2
400048b4: 22 bf ff f2 be,a 4000487c <rtems_filesystem_mknod+0x54>
<== ALWAYS TAKEN
400048b8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
errno = EINVAL;
400048bc: 40 00 28 6c call 4000ea6c <__errno>
<== NOT EXECUTED
400048c0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400048c4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400048c8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
return rv;
}
400048cc: 81 c7 e0 08 ret
<== NOT EXECUTED
400048d0: 81 e8 00 00 restore
<== NOT EXECUTED
40010598 <rtems_filesystem_null_handlers>:
40010598: 40 00 5e 80 40 00 d6 0c 40 00 d8 60 40 00 d8 f8 @.^.@...@..`@...
400105a8: 40 00 d6 94 40 00 d8 18 40 00 5e 88 40 00 d6 78 @...@...@.^.@..x
400105b8: 40 00 d6 38 40 00 d6 38 40 00 d6 28 40 00 d8 58 @..8@..8@..(@..X
400105c8: 40 00 d6 b0 40 00 d8 7c 40 00 d9 14 40 00 d8 34 @...@..|@...@..4
400105d8: 3f 00 00 00 00 00 00 00 52 54 45 4d 53 5f 53 55 ?.......RTEMS_SU
400105e8: 43 43 45 53 53 46 55 4c 00 00 00 00 00 00 00 00 CCESSFUL........
400105f8: 52 54 45 4d 53 5f 54 41 53 4b 5f 45 58 49 54 54 RTEMS_TASK_EXITT
40010608: 45 44 00 00 00 00 00 00 52 54 45 4d 53 5f 4d 50 ED......RTEMS_MP
40010618: 5f 4e 4f 54 5f 43 4f 4e 46 49 47 55 52 45 44 00 _NOT_CONFIGURED.
40010628: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 4e 41 RTEMS_INVALID_NA
40010638: 4d 45 00 00 00 00 00 00 52 54 45 4d 53 5f 49 4e ME......RTEMS_IN
40010648: 56 41 4c 49 44 5f 49 44 00 00 00 00 00 00 00 00 VALID_ID........
40010658: 52 54 45 4d 53 5f 54 4f 4f 5f 4d 41 4e 59 00 00 RTEMS_TOO_MANY..
40010668: 52 54 45 4d 53 5f 54 49 4d 45 4f 55 54 00 00 00 RTEMS_TIMEOUT...
40010678: 52 54 45 4d 53 5f 4f 42 4a 45 43 54 5f 57 41 53 RTEMS_OBJECT_WAS
40010688: 5f 44 45 4c 45 54 45 44 00 00 00 00 00 00 00 00 _DELETED........
40010698: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 53 49 RTEMS_INVALID_SI
400106a8: 5a 45 00 00 00 00 00 00 52 54 45 4d 53 5f 49 4e ZE......RTEMS_IN
400106b8: 56 41 4c 49 44 5f 41 44 44 52 45 53 53 00 00 00 VALID_ADDRESS...
400106c8: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 4e 55 RTEMS_INVALID_NU
400106d8: 4d 42 45 52 00 00 00 00 52 54 45 4d 53 5f 4e 4f MBER....RTEMS_NO
400106e8: 54 5f 44 45 46 49 4e 45 44 00 00 00 00 00 00 00 T_DEFINED.......
400106f8: 52 54 45 4d 53 5f 52 45 53 4f 55 52 43 45 5f 49 RTEMS_RESOURCE_I
40010708: 4e 5f 55 53 45 00 00 00 52 54 45 4d 53 5f 55 4e N_USE...RTEMS_UN
40010718: 53 41 54 49 53 46 49 45 44 00 00 00 00 00 00 00 SATISFIED.......
40010728: 52 54 45 4d 53 5f 49 4e 43 4f 52 52 45 43 54 5f RTEMS_INCORRECT_
40010738: 53 54 41 54 45 00 00 00 52 54 45 4d 53 5f 41 4c STATE...RTEMS_AL
40010748: 52 45 41 44 59 5f 53 55 53 50 45 4e 44 45 44 00 READY_SUSPENDED.
40010758: 52 54 45 4d 53 5f 49 4c 4c 45 47 41 4c 5f 4f 4e RTEMS_ILLEGAL_ON
40010768: 5f 53 45 4c 46 00 00 00 52 54 45 4d 53 5f 49 4c _SELF...RTEMS_IL
40010778: 4c 45 47 41 4c 5f 4f 4e 5f 52 45 4d 4f 54 45 5f LEGAL_ON_REMOTE_
40010788: 4f 42 4a 45 43 54 00 00 52 54 45 4d 53 5f 43 41 OBJECT..RTEMS_CA
40010798: 4c 4c 45 44 5f 46 52 4f 4d 5f 49 53 52 00 00 00 LLED_FROM_ISR...
400107a8: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 50 52 RTEMS_INVALID_PR
400107b8: 49 4f 52 49 54 59 00 00 52 54 45 4d 53 5f 49 4e IORITY..RTEMS_IN
400107c8: 56 41 4c 49 44 5f 43 4c 4f 43 4b 00 00 00 00 00 VALID_CLOCK.....
400107d8: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 4e 4f RTEMS_INVALID_NO
400107e8: 44 45 00 00 00 00 00 00 52 54 45 4d 53 5f 4e 4f DE......RTEMS_NO
400107f8: 54 5f 43 4f 4e 46 49 47 55 52 45 44 00 00 00 00 T_CONFIGURED....
40010808: 52 54 45 4d 53 5f 4e 4f 54 5f 4f 57 4e 45 52 5f RTEMS_NOT_OWNER_
40010818: 4f 46 5f 52 45 53 4f 55 52 43 45 00 00 00 00 00 OF_RESOURCE.....
40010828: 52 54 45 4d 53 5f 4e 4f 54 5f 49 4d 50 4c 45 4d RTEMS_NOT_IMPLEM
40010838: 45 4e 54 45 44 00 00 00 52 54 45 4d 53 5f 49 4e ENTED...RTEMS_IN
40010848: 54 45 52 4e 41 4c 5f 45 52 52 4f 52 00 00 00 00 TERNAL_ERROR....
40010858: 52 54 45 4d 53 5f 4e 4f 5f 4d 45 4d 4f 52 59 00 RTEMS_NO_MEMORY.
40010868: 52 54 45 4d 53 5f 49 4f 5f 45 52 52 4f 52 00 00 RTEMS_IO_ERROR..
40010878: 52 54 45 4d 53 5f 50 52 4f 58 59 5f 42 4c 4f 43 RTEMS_PROXY_BLOC
40010888: 4b 49 4e 47 00 00 00 00 KING....
40004618 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
40004618: 9d e3 bf a0 save %sp, -96, %sp
4000461c: 03 10 00 4e sethi %hi(0x40013800), %g1
40004620: c2 00 61 b0 ld [ %g1 + 0x1b0 ], %g1 ! 400139b0 <_System_state_Current>
Heap_Control *heap = RTEMS_Malloc_Heap;
40004624: 05 10 00 47 sethi %hi(0x40011c00), %g2
if ( _System_state_Is_up( state ) ) {
40004628: 80 a0 60 02 cmp %g1, 2
4000462c: 02 80 00 21 be 400046b0 <rtems_heap_allocate_aligned_with_boundary+0x98>
40004630: f8 00 a3 0c ld [ %g2 + 0x30c ], %i4
} else if ( _System_state_Is_before_multitasking( state ) ) {
40004634: 80 a0 60 01 cmp %g1, 1
40004638: 02 80 00 22 be 400046c0 <rtems_heap_allocate_aligned_with_boundary+0xa8>
4000463c: 96 10 00 1a mov %i2, %o3
boundary
);
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
p = _Heap_Allocate_aligned_with_boundary(
40004640: 94 10 00 19 mov %i1, %o2
40004644: 92 10 00 18 mov %i0, %o1
40004648: 40 00 0b 46 call 40007360 <_Heap_Allocate_aligned_with_boundary>
4000464c: 90 10 00 1c mov %i4, %o0
40004650: ba 10 00 08 mov %o0, %i5
* Do not attempt to allocate memory if not in correct system state.
*/
return NULL;
}
if ( p == NULL && alignment == 0 && boundary == 0 ) {
40004654: 80 a7 60 00 cmp %i5, 0
40004658: 12 80 00 0b bne 40004684 <rtems_heap_allocate_aligned_with_boundary+0x6c>
<== ALWAYS TAKEN
4000465c: 80 a6 60 00 cmp %i1, 0
40004660: 12 80 00 09 bne 40004684 <rtems_heap_allocate_aligned_with_boundary+0x6c>
<== NOT EXECUTED
40004664: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40004668: 12 80 00 23 bne 400046f4 <rtems_heap_allocate_aligned_with_boundary+0xdc>
<== NOT EXECUTED
4000466c: 03 10 00 40 sethi %hi(0x40010000), %g1
<== NOT EXECUTED
p = (*rtems_malloc_extend_handler)( heap, size );
40004670: c2 00 61 04 ld [ %g1 + 0x104 ], %g1 ! 40010104 <rtems_malloc_extend_handler>
<== NOT EXECUTED
40004674: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40004678: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000467c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40004680: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( p != NULL && rtems_malloc_dirty_helper != NULL )
40004684: 80 a7 60 00 cmp %i5, 0
40004688: 02 80 00 1b be 400046f4 <rtems_heap_allocate_aligned_with_boundary+0xdc>
<== NEVER TAKEN
4000468c: 03 10 00 48 sethi %hi(0x40012000), %g1
40004690: c2 00 63 58 ld [ %g1 + 0x358 ], %g1 ! 40012358 <rtems_malloc_dirty_helper>
40004694: 80 a0 60 00 cmp %g1, 0
40004698: 02 80 00 04 be 400046a8 <rtems_heap_allocate_aligned_with_boundary+0x90>
<== ALWAYS TAKEN
4000469c: 92 10 00 18 mov %i0, %o1
(*rtems_malloc_dirty_helper)( p, size );
400046a0: 9f c0 40 00 call %g1
<== NOT EXECUTED
400046a4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return p;
}
400046a8: 81 c7 e0 08 ret
400046ac: 91 e8 00 1d restore %g0, %i5, %o0
400046b0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
if ( _Thread_Dispatch_is_enabled() ) {
400046b4: 80 a0 60 00 cmp %g1, 0
400046b8: 32 80 00 10 bne,a 400046f8 <rtems_heap_allocate_aligned_with_boundary+0xe0>
<== NEVER TAKEN
400046bc: ba 10 20 00 clr %i5
<== NOT EXECUTED
_RTEMS_Lock_allocator();
400046c0: 40 00 0a 96 call 40007118 <_RTEMS_Lock_allocator>
400046c4: 01 00 00 00 nop
_Malloc_Process_deferred_frees();
400046c8: 7f ff ff bb call 400045b4 <_Malloc_Process_deferred_frees>
400046cc: 01 00 00 00 nop
p = _Heap_Allocate_aligned_with_boundary(
400046d0: 96 10 00 1a mov %i2, %o3
400046d4: 94 10 00 19 mov %i1, %o2
400046d8: 92 10 00 18 mov %i0, %o1
400046dc: 40 00 0b 21 call 40007360 <_Heap_Allocate_aligned_with_boundary>
400046e0: 90 10 00 1c mov %i4, %o0
_RTEMS_Unlock_allocator();
400046e4: 40 00 0a 92 call 4000712c <_RTEMS_Unlock_allocator>
400046e8: ba 10 00 08 mov %o0, %i5
break;
400046ec: 10 bf ff db b 40004658 <rtems_heap_allocate_aligned_with_boundary+0x40>
400046f0: 80 a7 60 00 cmp %i5, 0
return NULL;
400046f4: ba 10 20 00 clr %i5
<== NOT EXECUTED
}
400046f8: 81 c7 e0 08 ret
<== NOT EXECUTED
400046fc: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
4000500c <rtems_heap_null_extend>:
Heap_Control *heap RTEMS_UNUSED,
size_t alloc_size RTEMS_UNUSED
)
{
return NULL;
}
4000500c: 81 c3 e0 08 retl
<== NOT EXECUTED
40005010: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
4000ddb8 <rtems_libio_allocate>:
return fcntl_flags;
}
rtems_libio_t *rtems_libio_allocate( void )
{
4000ddb8: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_lock();
4000ddbc: 7f ff d9 e5 call 40004550 <rtems_libio_lock>
4000ddc0: 01 00 00 00 nop
iop = rtems_libio_iop_free_head;
4000ddc4: 03 10 00 4e sethi %hi(0x40013800), %g1
4000ddc8: f0 00 60 d0 ld [ %g1 + 0xd0 ], %i0 ! 400138d0 <rtems_libio_iop_free_head>
if ( iop != NULL ) {
4000ddcc: 80 a6 20 00 cmp %i0, 0
4000ddd0: 02 80 00 06 be 4000dde8 <rtems_libio_allocate+0x30>
<== NEVER TAKEN
4000ddd4: 86 10 60 d0 or %g1, 0xd0, %g3
void *next;
next = iop->data1;
4000ddd8: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
rtems_libio_iop_free_head = next;
if ( next == NULL ) {
4000dddc: 80 a0 a0 00 cmp %g2, 0
4000dde0: 02 80 00 06 be 4000ddf8 <rtems_libio_allocate+0x40>
4000dde4: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ]
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
}
}
rtems_libio_unlock();
4000dde8: 7f ff d9 df call 40004564 <rtems_libio_unlock>
4000ddec: 01 00 00 00 nop
return iop;
}
4000ddf0: 81 c7 e0 08 ret
4000ddf4: 81 e8 00 00 restore
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
4000ddf8: 03 10 00 47 sethi %hi(0x40011c00), %g1
rtems_libio_unlock();
4000ddfc: 7f ff d9 da call 40004564 <rtems_libio_unlock>
4000de00: c6 20 63 18 st %g3, [ %g1 + 0x318 ] ! 40011f18 <rtems_libio_iop_free_tail>
}
4000de04: 81 c7 e0 08 ret
4000de08: 81 e8 00 00 restore
4000dd64 <rtems_libio_exit>:
#include <unistd.h>
#include <rtems/libio.h>
void rtems_libio_exit(void)
{
4000dd64: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
(void)close(0);
4000dd68: 40 00 03 04 call 4000e978 <close>
<== NOT EXECUTED
4000dd6c: 90 10 20 00 clr %o0
<== NOT EXECUTED
(void)close(1);
(void)close(2);
4000dd70: b0 10 20 02 mov 2, %i0
<== NOT EXECUTED
(void)close(1);
4000dd74: 40 00 03 01 call 4000e978 <close>
<== NOT EXECUTED
4000dd78: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
(void)close(2);
4000dd7c: 40 00 02 ff call 4000e978 <close>
<== NOT EXECUTED
4000dd80: 81 e8 00 00 restore
<== NOT EXECUTED
4000de0c <rtems_libio_free>:
void rtems_libio_free(
rtems_libio_t *iop
)
{
4000de0c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_filesystem_location_free( &iop->pathinfo );
4000de10: 7f ff ff 82 call 4000dc18 <rtems_filesystem_location_free>
<== NOT EXECUTED
4000de14: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
rtems_libio_lock();
4000de18: 7f ff d9 ce call 40004550 <rtems_libio_lock>
<== NOT EXECUTED
4000de1c: 01 00 00 00 nop
<== NOT EXECUTED
iop = memset( iop, 0, sizeof( *iop ) );
4000de20: 94 10 20 30 mov 0x30, %o2 ! 30 <_TLS_Alignment+0x2f>
<== NOT EXECUTED
4000de24: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000de28: 40 00 03 7b call 4000ec14 <memset>
<== NOT EXECUTED
4000de2c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
*rtems_libio_iop_free_tail = iop;
4000de30: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
4000de34: c4 00 63 18 ld [ %g1 + 0x318 ], %g2 ! 40011f18 <rtems_libio_iop_free_tail>
<== NOT EXECUTED
4000de38: d0 20 80 00 st %o0, [ %g2 ]
<== NOT EXECUTED
rtems_libio_iop_free_tail = &iop->data1;
4000de3c: 90 02 20 28 add %o0, 0x28, %o0
<== NOT EXECUTED
4000de40: d0 20 63 18 st %o0, [ %g1 + 0x318 ]
<== NOT EXECUTED
rtems_libio_unlock();
4000de44: 7f ff d9 c8 call 40004564 <rtems_libio_unlock>
<== NOT EXECUTED
4000de48: 81 e8 00 00 restore
<== NOT EXECUTED
40004fe4 <rtems_libio_free_user_env>:
if (!uses_global_env) {
40004fe4: 03 10 00 47 sethi %hi(0x40011c00), %g1
<== NOT EXECUTED
40004fe8: 82 10 63 50 or %g1, 0x350, %g1 ! 40011f50 <rtems_global_user_env>
<== NOT EXECUTED
40004fec: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
40004ff0: 02 80 00 05 be 40005004 <rtems_libio_free_user_env+0x20>
<== NOT EXECUTED
40004ff4: 01 00 00 00 nop
<== NOT EXECUTED
40004ff8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40004ffc: 7f ff ff e6 call 40004f94 <rtems_libio_free_user_env.part.1>
<== NOT EXECUTED
40005000: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
}
}
40005004: 81 c3 e0 08 retl
<== NOT EXECUTED
40005008: 01 00 00 00 nop
<== NOT EXECUTED
40004cd4 <rtems_libio_post_driver>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void rtems_libio_post_driver(void)
{
40004cd4: 9d e3 bf a0 save %sp, -96, %sp
/*
* Attempt to open /dev/console.
*/
if ( open( CONSOLE_DEVICE_NAME, O_RDONLY, 0 ) != STDIN_FILENO ) {
40004cd8: 94 10 20 00 clr %o2
40004cdc: 92 10 20 00 clr %o1
40004ce0: 3b 10 00 41 sethi %hi(0x40010400), %i5
40004ce4: 40 00 00 1a call 40004d4c <open>
40004ce8: 90 17 60 a8 or %i5, 0xa8, %o0 ! 400104a8 <IMFS_node_control_sym_link+0x1c>
40004cec: 80 a2 20 00 cmp %o0, 0
40004cf0: 02 80 00 04 be 40004d00 <rtems_libio_post_driver+0x2c>
<== ALWAYS TAKEN
40004cf4: 94 10 20 00 clr %o2
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
}
atexit(rtems_libio_exit);
}
40004cf8: 81 c7 e0 08 ret
<== NOT EXECUTED
40004cfc: 81 e8 00 00 restore
<== NOT EXECUTED
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDOUT_FILENO ) {
40004d00: 92 10 20 01 mov 1, %o1
40004d04: 40 00 00 12 call 40004d4c <open>
40004d08: 90 17 60 a8 or %i5, 0xa8, %o0
40004d0c: 80 a2 20 01 cmp %o0, 1
40004d10: 12 80 00 0a bne 40004d38 <rtems_libio_post_driver+0x64>
<== NEVER TAKEN
40004d14: 94 10 20 00 clr %o2
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
40004d18: 92 10 20 01 mov 1, %o1
40004d1c: 40 00 00 0c call 40004d4c <open>
40004d20: 90 17 60 a8 or %i5, 0xa8, %o0
40004d24: 80 a2 20 02 cmp %o0, 2
40004d28: 12 80 00 06 bne 40004d40 <rtems_libio_post_driver+0x6c>
<== NEVER TAKEN
40004d2c: 31 10 00 37 sethi %hi(0x4000dc00), %i0
<== NOT EXECUTED
atexit(rtems_libio_exit);
40004d30: 40 00 27 48 call 4000ea50 <atexit>
<== NOT EXECUTED
40004d34: 91 ee 21 64 restore %i0, 0x164, %o0
_Internal_error( INTERNAL_ERROR_LIBIO_STDOUT_FD_OPEN_FAILED );
40004d38: 40 00 0b 31 call 400079fc <_Internal_error>
<== NOT EXECUTED
40004d3c: 90 10 20 24 mov 0x24, %o0
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
40004d40: 40 00 0b 2f call 400079fc <_Internal_error>
<== NOT EXECUTED
40004d44: 90 10 20 25 mov 0x25, %o0
<== NOT EXECUTED
40004d48: 01 00 00 00 nop
<== NOT EXECUTED
4000dfc0 <rtems_printf>:
int rtems_printf(
const rtems_printer *printer,
const char *format,
...
)
{
4000dfc0: 9d e3 bf 98 save %sp, -104, %sp
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
va_list ap;
va_start( ap, format );
4000dfc4: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
{
4000dfc8: 82 10 00 18 mov %i0, %g1
va_start( ap, format );
4000dfcc: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int len = 0;
4000dfd0: b0 10 20 00 clr %i0
va_start( ap, format );
4000dfd4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000dfd8: 80 a0 60 00 cmp %g1, 0
4000dfdc: 02 80 00 0b be 4000e008 <rtems_printf+0x48>
<== NEVER TAKEN
4000dfe0: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
4000dfe4: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000dfe8: 80 a0 a0 00 cmp %g2, 0
4000dfec: 02 80 00 07 be 4000e008 <rtems_printf+0x48>
<== NEVER TAKEN
4000dff0: 94 07 a0 4c add %fp, 0x4c, %o2
len = printer->printer( printer->context, format, ap );
4000dff4: d0 00 40 00 ld [ %g1 ], %o0
4000dff8: 92 10 00 19 mov %i1, %o1
4000dffc: 9f c0 80 00 call %g2
4000e000: d4 27 bf fc st %o2, [ %fp + -4 ]
4000e004: b0 10 00 08 mov %o0, %i0
va_end( ap );
}
return len;
}
4000e008: 81 c7 e0 08 ret
4000e00c: 81 e8 00 00 restore
4000df84 <rtems_vprintf>:
int rtems_vprintf(
const rtems_printer *printer,
const char *format,
va_list ap
)
{
4000df84: 9d e3 bf a0 save %sp, -96, %sp
4000df88: 82 10 00 18 mov %i0, %g1
*
* @return true The printer is valid else false is returned.
*/
static inline bool rtems_print_printer_valid(const rtems_printer *printer)
{
return printer != NULL && printer->printer != NULL;
4000df8c: 80 a0 60 00 cmp %g1, 0
4000df90: 02 80 00 0a be 4000dfb8 <rtems_vprintf+0x34>
<== NEVER TAKEN
4000df94: b0 10 20 00 clr %i0
4000df98: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000df9c: 80 a0 a0 00 cmp %g2, 0
4000dfa0: 02 80 00 06 be 4000dfb8 <rtems_vprintf+0x34>
<== NEVER TAKEN
4000dfa4: 94 10 00 1a mov %i2, %o2
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
len = printer->printer( printer->context, format, ap );
4000dfa8: d0 00 40 00 ld [ %g1 ], %o0
4000dfac: 9f c0 80 00 call %g2
4000dfb0: 92 10 00 19 mov %i1, %o1
4000dfb4: b0 10 00 08 mov %o0, %i0
}
return len;
}
4000dfb8: 81 c7 e0 08 ret
4000dfbc: 81 e8 00 00 restore
400185c0 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
400185c0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
400185c4: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
400185c8: 02 80 00 32 be 40018690 <write+0xd0>
<== NOT EXECUTED
400185cc: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
rtems_libio_check_count( count );
400185d0: 02 80 00 22 be 40018658 <write+0x98>
<== NOT EXECUTED
400185d4: 84 10 20 00 clr %g2
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
400185d8: 03 10 00 64 sethi %hi(0x40019000), %g1
<== NOT EXECUTED
400185dc: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 40019158 <rtems_libio_number_iops>
<== NOT EXECUTED
400185e0: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
400185e4: 1a 80 00 25 bcc 40018678 <write+0xb8>
<== NOT EXECUTED
400185e8: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
400185ec: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400185f0: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
400185f4: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400185f8: b0 16 20 c0 or %i0, 0xc0, %i0
<== NOT EXECUTED
400185fc: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018600: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40018604: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40018608: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4001860c: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018610: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018614: 01 00 00 00 nop
<== NOT EXECUTED
40018618: 84 08 a1 04 and %g2, 0x104, %g2
<== NOT EXECUTED
4001861c: 80 a0 a1 04 cmp %g2, 0x104
<== NOT EXECUTED
40018620: 12 80 00 10 bne 40018660 <write+0xa0>
<== NOT EXECUTED
40018624: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
/*
* Now process the write() request.
*/
n = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
40018628: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4001862c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40018630: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40018634: 9f c0 40 00 call %g1
<== NOT EXECUTED
40018638: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001863c: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018640: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40018644: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
40018648: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
4001864c: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018650: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018654: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
return n;
}
40018658: 81 c7 e0 08 ret
<== NOT EXECUTED
4001865c: 91 e8 00 02 restore %g0, %g2, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018660: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018664: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40018668: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4001866c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018670: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018674: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40018678: 7f ff d8 fc call 4000ea68 <__errno>
<== NOT EXECUTED
4001867c: 01 00 00 00 nop
<== NOT EXECUTED
40018680: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
40018684: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40018688: 10 bf ff f4 b 40018658 <write+0x98>
<== NOT EXECUTED
4001868c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_libio_check_buffer( buffer );
40018690: 7f ff d8 f6 call 4000ea68 <__errno>
<== NOT EXECUTED
40018694: 01 00 00 00 nop
<== NOT EXECUTED
40018698: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
4001869c: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
400186a0: 10 bf ff ee b 40018658 <write+0x98>
<== NOT EXECUTED
400186a4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED