RTEMS-5
Annotated Report
Fri Aug 10 12:46:46 2018
40005234 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
40005234: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
if ( !rtems_configuration_get_unified_work_area() ) {
40005238: 03 10 00 63 sethi %hi(0x40018c00), %g1
4000523c: c2 08 61 19 ldub [ %g1 + 0x119 ], %g1 ! 40018d19 <Configuration+0x31>
40005240: 80 a0 60 00 cmp %g1, 0
40005244: 12 80 00 19 bne 400052a8 <RTEMS_Malloc_Initialize+0x74>
<== NEVER TAKEN
40005248: 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) {
4000524c: 02 80 00 19 be 400052b0 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
40005250: 03 10 00 6c sethi %hi(0x4001b000), %g1
Heap_Control *heap = RTEMS_Malloc_Heap;
40005254: f8 00 63 a4 ld [ %g1 + 0x3a4 ], %i4 ! 4001b3a4 <RTEMS_Malloc_Heap>
40005258: b3 2e 60 03 sll %i1, 3, %i1
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
4000525c: 37 10 00 1d sethi %hi(0x40007400), %i3
40005260: b2 06 00 19 add %i0, %i1, %i1
40005264: b6 16 e1 80 or %i3, 0x180, %i3
40005268: ba 10 00 1b mov %i3, %i5
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
4000526c: d4 06 20 04 ld [ %i0 + 4 ], %o2
40005270: d2 06 00 00 ld [ %i0 ], %o1
40005274: 96 10 20 08 mov 8, %o3
40005278: 9f c7 40 00 call %i5
4000527c: 90 10 00 1c mov %i4, %o0
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
40005280: 80 a2 20 00 cmp %o0, 0
40005284: 32 80 00 02 bne,a 4000528c <RTEMS_Malloc_Initialize+0x58>
<== ALWAYS TAKEN
40005288: ba 10 00 1a mov %i2, %i5
4000528c: b0 06 20 08 add %i0, 8, %i0
for (i = 0; i < area_count; ++i) {
40005290: 80 a6 00 19 cmp %i0, %i1
40005294: 32 bf ff f7 bne,a 40005270 <RTEMS_Malloc_Initialize+0x3c>
<== NEVER TAKEN
40005298: d4 06 20 04 ld [ %i0 + 4 ], %o2
<== NOT EXECUTED
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
4000529c: 80 a7 40 1b cmp %i5, %i3
400052a0: 02 80 00 04 be 400052b0 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
400052a4: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
}
}
}
400052a8: 81 c7 e0 08 ret
400052ac: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
400052b0: 40 00 09 7d call 400078a4 <_Internal_error>
<== NOT EXECUTED
400052b4: 90 10 20 17 mov 0x17, %o0
<== NOT EXECUTED
400052b8: 01 00 00 00 nop
<== NOT EXECUTED
40004e40 <_Console_simple_Read>:
ssize_t _Console_simple_Read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
40004e40: 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 ) {
40004e44: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40004e48: 04 80 00 0c ble 40004e78 <_Console_simple_Read+0x38>
<== NOT EXECUTED
40004e4c: ba 10 20 00 clr %i5
<== NOT EXECUTED
int c;
do {
c = getchark();
40004e50: 40 00 00 22 call 40004ed8 <getchark>
<== NOT EXECUTED
40004e54: 01 00 00 00 nop
<== NOT EXECUTED
} while (c == -1);
40004e58: 80 a2 3f ff cmp %o0, -1
<== NOT EXECUTED
40004e5c: 02 bf ff fd be 40004e50 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004e60: 01 00 00 00 nop
<== NOT EXECUTED
buf[ i ] = (char) c;
40004e64: d0 2e 40 1d stb %o0, [ %i1 + %i5 ]
<== NOT EXECUTED
for ( i = 0; i < n; ++i ) {
40004e68: ba 07 60 01 inc %i5
<== NOT EXECUTED
40004e6c: 80 a6 80 1d cmp %i2, %i5
<== NOT EXECUTED
40004e70: 12 bf ff f8 bne 40004e50 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004e74: 01 00 00 00 nop
<== NOT EXECUTED
}
return n;
}
40004e78: 81 c7 e0 08 ret
<== NOT EXECUTED
40004e7c: 91 e8 00 1a restore %g0, %i2, %o0
<== NOT EXECUTED
40005200 <_Malloc_Deferred_free>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005200: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
40005204: 05 10 00 6c sethi %hi(0x4001b000), %g2
<== NOT EXECUTED
40005208: 84 10 a3 d0 or %g2, 0x3d0, %g2 ! 4001b3d0 <_Malloc_GC_list>
<== NOT EXECUTED
4000520c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
40005210: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
40005214: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005218: d0 20 a0 08 st %o0, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000521c: d0 20 c0 00 st %o0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005220: c6 22 20 04 st %g3, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005224: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005228: 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 );
}
4000522c: 81 c3 e0 08 retl
<== NOT EXECUTED
40005230: 01 00 00 00 nop
<== NOT EXECUTED
400050b4 <_Malloc_Process_deferred_frees>:
return p;
}
void _Malloc_Process_deferred_frees( void )
{
400050b4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400050b8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400050bc: 3b 10 00 6c sethi %hi(0x4001b000), %i5
400050c0: d0 07 63 d0 ld [ %i5 + 0x3d0 ], %o0 ! 4001b3d0 <_Malloc_GC_list>
400050c4: ba 17 63 d0 or %i5, 0x3d0, %i5
if ( !_Chain_Is_empty(the_chain))
400050c8: b8 07 60 04 add %i5, 4, %i4
400050cc: 80 a2 00 1c cmp %o0, %i4
400050d0: 02 80 00 0e be 40005108 <_Malloc_Process_deferred_frees+0x54>
<== ALWAYS TAKEN
400050d4: 01 00 00 00 nop
new_first = old_first->next;
400050d8: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
head->next = new_first;
400050dc: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
new_first->previous = head;
400050e0: fa 20 a0 04 st %i5, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400050e4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400050e8: 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 );
400050ec: 7f ff ff 65 call 40004e80 <free>
<== NOT EXECUTED
400050f0: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400050f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400050f8: d0 07 40 00 ld [ %i5 ], %o0
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
400050fc: 80 a2 00 1c cmp %o0, %i4
<== NOT EXECUTED
40005100: 32 bf ff f7 bne,a 400050dc <_Malloc_Process_deferred_frees+0x28>
<== NOT EXECUTED
40005104: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005108: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000510c: 01 00 00 00 nop
}
}
40005110: 81 c7 e0 08 ret
40005114: 81 e8 00 00 restore
40005078 <_Malloc_System_state>:
40005078: 03 10 00 7d sethi %hi(0x4001f400), %g1
<== NOT EXECUTED
4000507c: c2 00 61 38 ld [ %g1 + 0x138 ], %g1 ! 4001f538 <_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 ) ) {
40005080: 84 18 60 01 xor %g1, 1, %g2
<== NOT EXECUTED
return MALLOC_SYSTEM_STATE_NORMAL;
} else {
return MALLOC_SYSTEM_STATE_NO_PROTECTION;
40005084: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
40005088: 90 40 20 00 addx %g0, 0, %o0
<== NOT EXECUTED
if ( _System_state_Is_up( state ) ) {
4000508c: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
40005090: 02 80 00 04 be 400050a0 <_Malloc_System_state+0x28>
<== NOT EXECUTED
40005094: 01 00 00 00 nop
<== NOT EXECUTED
}
}
40005098: 81 c3 e0 08 retl
<== NOT EXECUTED
4000509c: 01 00 00 00 nop
<== NOT EXECUTED
ISR_Level level;
_ISR_Local_disable( level );
#endif
enabled = _Thread_Dispatch_disable_level == 0;
400050a0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return MALLOC_SYSTEM_STATE_NO_ALLOCATION;
400050a4: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
400050a8: 90 40 20 00 addx %g0, 0, %o0
<== NOT EXECUTED
}
400050ac: 81 c3 e0 08 retl
<== NOT EXECUTED
400050b0: 91 2a 20 01 sll %o0, 1, %o0
<== NOT EXECUTED
4000ead0 <_close_r>:
int _close_r(
struct _reent *ptr RTEMS_UNUSED,
int fd
)
{
return close( fd );
4000ead0: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
4000ead4: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000ead8: 7f ff ff c8 call 4000e9f8 <close>
<== NOT EXECUTED
4000eadc: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400184e8 <_free_r>:
struct _reent *ignored,
void *ptr
)
{
(void) ignored;
free( ptr );
400184e8: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
400184ec: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400184f0: 7f ff b2 64 call 40004e80 <free>
<== NOT EXECUTED
400184f4: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400185e0 <_fstat_r>:
int _fstat_r(
struct _reent *ptr RTEMS_UNUSED,
int fd,
struct stat *buf
)
{
400185e0: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
return fstat( fd, buf );
400185e4: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
400185e8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400185ec: 7f ff ff c3 call 400184f8 <fstat>
<== NOT EXECUTED
400185f0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40004f70 <_gettimeofday_r>:
int _gettimeofday_r(
struct _reent *ignored_reentrancy_stuff RTEMS_UNUSED,
struct timeval *tp,
void *__tz
)
{
40004f70: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !tp )
40004f74: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40004f78: 02 80 00 06 be 40004f90 <_gettimeofday_r+0x20>
<== NOT EXECUTED
40004f7c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40004f80: 40 00 0e 97 call 400089dc <_Timecounter_Microtime>
<== NOT EXECUTED
40004f84: b0 10 20 00 clr %i0
<== NOT EXECUTED
struct timezone *tzp = __tz;
return gettimeofday( tp, tzp );
}
40004f88: 81 c7 e0 08 ret
<== NOT EXECUTED
40004f8c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
40004f90: 40 00 26 ef call 4000eb4c <__errno>
<== NOT EXECUTED
40004f94: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004f98: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
40004f9c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004fa0: 81 c7 e0 08 ret
<== NOT EXECUTED
40004fa4: 81 e8 00 00 restore
<== NOT EXECUTED
400185f4 <_isatty_r>:
struct _reent *ptr,
int fd
)
{
(void) ptr;
return isatty( fd );
400185f4: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
400185f8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400185fc: 40 00 01 55 call 40018b50 <isatty>
<== NOT EXECUTED
40018600: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400186c4 <_lseek_r>:
struct _reent *ptr RTEMS_UNUSED,
int fd,
off_t offset,
int whence
)
{
400186c4: 86 10 00 0b mov %o3, %g3
<== NOT EXECUTED
return lseek( fd, offset, whence );
400186c8: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
400186cc: 96 10 00 0c mov %o4, %o3
<== NOT EXECUTED
400186d0: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
400186d4: 94 10 00 03 mov %g3, %o2
<== NOT EXECUTED
400186d8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400186dc: 7f ff ff ca call 40018604 <lseek>
<== NOT EXECUTED
400186e0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400186e4 <_malloc_r>:
struct _reent *ignored,
size_t size
)
{
(void) ignored;
return malloc( size );
400186e4: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
400186e8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400186ec: 7f ff b2 f4 call 400052bc <malloc>
<== NOT EXECUTED
400186f0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400187dc <_read_r>:
struct _reent *ptr RTEMS_UNUSED,
int fd,
void *buf,
size_t nbytes
)
{
400187dc: 82 10 00 0a mov %o2, %g1
<== NOT EXECUTED
return read( fd, buf, nbytes );
400187e0: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
400187e4: 94 10 00 0b mov %o3, %o2
<== NOT EXECUTED
400187e8: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
400187ec: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400187f0: 7f ff ff c1 call 400186f4 <read>
<== NOT EXECUTED
400187f4: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400187f8 <_realloc_r>:
void *_realloc_r(
struct _reent *ignored,
void *ptr,
size_t size
)
{
400187f8: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
(void) ignored;
return realloc( ptr, size );
400187fc: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
40018800: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40018804: 40 00 00 09 call 40018828 <realloc>
<== NOT EXECUTED
40018808: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4001880c <_write_r>:
struct _reent *ptr RTEMS_UNUSED,
int fd,
const void *buf,
size_t nbytes
)
{
4001880c: 82 10 00 0a mov %o2, %g1
<== NOT EXECUTED
return write( fd, buf, nbytes );
40018810: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
40018814: 94 10 00 0b mov %o3, %o2
<== NOT EXECUTED
40018818: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
4001881c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40018820: 40 00 00 48 call 40018940 <write>
<== NOT EXECUTED
40018824: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000e9f8 <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
4000e9f8: 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 ) {
4000e9fc: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4000ea00: c2 00 62 a8 ld [ %g1 + 0x2a8 ], %g1 ! 40018ea8 <rtems_libio_number_iops>
<== NOT EXECUTED
4000ea04: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
4000ea08: 1a 80 00 1b bcc 4000ea74 <close+0x7c>
<== NOT EXECUTED
4000ea0c: 01 00 00 00 nop
<== NOT EXECUTED
4000ea10: b7 2e 20 01 sll %i0, 1, %i3
<== NOT EXECUTED
4000ea14: b0 06 c0 18 add %i3, %i0, %i0
<== NOT EXECUTED
4000ea18: 37 10 00 72 sethi %hi(0x4001c800), %i3
<== NOT EXECUTED
4000ea1c: b9 2e 20 04 sll %i0, 4, %i4
<== NOT EXECUTED
4000ea20: b6 16 e1 48 or %i3, 0x148, %i3
<== NOT EXECUTED
4000ea24: b8 06 c0 1c add %i3, %i4, %i4
<== NOT EXECUTED
4000ea28: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
unsigned int actual;
(void) succ;
(void) fail;
_ISR_Local_disable( level );
actual = *obj;
4000ea2c: 10 80 00 0f b 4000ea68 <close+0x70>
<== NOT EXECUTED
4000ea30: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ea34: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000ea38: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
success = ( actual == *expected );
if ( success ) {
4000ea3c: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
4000ea40: 12 80 00 03 bne 4000ea4c <close+0x54>
<== NOT EXECUTED
4000ea44: 84 08 ae ff and %g2, 0xeff, %g2
<== NOT EXECUTED
*obj = desired;
4000ea48: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ea4c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ea50: 01 00 00 00 nop
<== NOT EXECUTED
desired,
ATOMIC_ORDER_ACQ_REL,
ATOMIC_ORDER_RELAXED
);
if ( success ) {
4000ea54: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
4000ea58: 02 80 00 0d be 4000ea8c <close+0x94>
<== NOT EXECUTED
4000ea5c: 80 88 f0 00 btst -4096, %g3
<== NOT EXECUTED
break;
}
if ( ( flags & ~( LIBIO_FLAGS_REFERENCE_INC - 1U ) ) != 0 ) {
4000ea60: 12 80 00 16 bne 4000eab8 <close+0xc0>
<== NOT EXECUTED
4000ea64: 84 10 00 03 mov %g3, %g2
<== NOT EXECUTED
if ( ( flags & LIBIO_FLAGS_OPEN ) == 0 ) {
4000ea68: 80 88 a1 00 btst 0x100, %g2
<== NOT EXECUTED
4000ea6c: 12 bf ff f2 bne 4000ea34 <close+0x3c>
<== NOT EXECUTED
4000ea70: 88 08 af ff and %g2, 0xfff, %g4
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
4000ea74: 40 00 00 36 call 4000eb4c <__errno>
<== NOT EXECUTED
4000ea78: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000ea7c: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4000ea80: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000ea84: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ea88: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
}
}
rc = (*iop->pathinfo.handlers->close_h)( iop );
4000ea8c: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
4000ea90: b6 06 c0 18 add %i3, %i0, %i3
<== NOT EXECUTED
4000ea94: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
<== NOT EXECUTED
4000ea98: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4000ea9c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000eaa0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000eaa4: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
rtems_libio_free( iop );
4000eaa8: 7f ff fa 4e call 4000d3e0 <rtems_libio_free>
<== NOT EXECUTED
4000eaac: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return rc;
}
4000eab0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eab4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
4000eab8: 40 00 00 25 call 4000eb4c <__errno>
<== NOT EXECUTED
4000eabc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000eac0: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000eac4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000eac8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eacc: 81 e8 00 00 restore
<== NOT EXECUTED
40004e80 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40004e80: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !ptr )
40004e84: ba 96 20 00 orcc %i0, 0, %i5
<== NOT EXECUTED
40004e88: 02 80 00 0d be 40004ebc <free+0x3c>
<== NOT EXECUTED
40004e8c: 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 ) {
40004e90: 40 00 00 7a call 40005078 <_Malloc_System_state>
<== NOT EXECUTED
40004e94: 01 00 00 00 nop
<== NOT EXECUTED
40004e98: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40004e9c: 12 80 00 0a bne 40004ec4 <free+0x44>
<== NOT EXECUTED
40004ea0: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
_Malloc_Deferred_free(ptr);
return;
}
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
40004ea4: d0 00 63 a4 ld [ %g1 + 0x3a4 ], %o0 ! 4001b3a4 <RTEMS_Malloc_Heap>
<== NOT EXECUTED
40004ea8: 40 00 11 0f call 400092e4 <_Protected_heap_Free>
<== NOT EXECUTED
40004eac: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
40004eb0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40004eb4: 02 80 00 06 be 40004ecc <free+0x4c>
<== NOT EXECUTED
40004eb8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
rtems_fatal( RTEMS_FATAL_SOURCE_INVALID_HEAP_FREE, (rtems_fatal_code) ptr );
}
}
40004ebc: 81 c7 e0 08 ret
<== NOT EXECUTED
40004ec0: 81 e8 00 00 restore
<== NOT EXECUTED
_Malloc_Deferred_free(ptr);
40004ec4: 40 00 00 cf call 40005200 <_Malloc_Deferred_free>
<== NOT EXECUTED
40004ec8: 81 e8 00 00 restore
<== NOT EXECUTED
40004ecc: 40 00 0a 63 call 40007858 <_Terminate>
<== NOT EXECUTED
40004ed0: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
40004ed4: 01 00 00 00 nop
<== NOT EXECUTED
400184f8 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
400184f8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
400184fc: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40018500: 02 80 00 32 be 400185c8 <fstat+0xd0>
<== NOT EXECUTED
40018504: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
LIBIO_GET_IOP( fd, iop );
40018508: c2 00 62 a8 ld [ %g1 + 0x2a8 ], %g1 ! 40018ea8 <rtems_libio_number_iops>
<== NOT EXECUTED
4001850c: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
40018510: 1a 80 00 28 bcc 400185b0 <fstat+0xb8>
<== NOT EXECUTED
40018514: 91 2e 20 01 sll %i0, 1, %o0
<== NOT EXECUTED
40018518: 39 10 00 72 sethi %hi(0x4001c800), %i4
<== NOT EXECUTED
4001851c: b0 02 00 18 add %o0, %i0, %i0
<== NOT EXECUTED
40018520: b8 17 21 48 or %i4, 0x148, %i4
<== NOT EXECUTED
40018524: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
40018528: ba 06 00 1c add %i0, %i4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001852c: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40018530: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40018534: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40018538: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001853c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018540: 01 00 00 00 nop
<== NOT EXECUTED
40018544: 80 88 a1 00 btst 0x100, %g2
<== NOT EXECUTED
40018548: 02 80 00 14 be 40018598 <fstat+0xa0>
<== NOT EXECUTED
4001854c: 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) );
40018550: 92 10 20 00 clr %o1
<== NOT EXECUTED
40018554: 7f ff db 2b call 4000f200 <memset>
<== NOT EXECUTED
40018558: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
4001855c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
40018560: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
<== NOT EXECUTED
40018564: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
40018568: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4001856c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40018570: 90 07 00 08 add %i4, %o0, %o0
<== NOT EXECUTED
40018574: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018578: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4001857c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40018580: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018584: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018588: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001858c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
return rv;
}
40018590: 81 c7 e0 08 ret
<== NOT EXECUTED
40018594: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018598: 91 d0 20 09 ta 9
<== NOT EXECUTED
4001859c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400185a0: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400185a4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400185a8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400185ac: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
400185b0: 7f ff d9 67 call 4000eb4c <__errno>
<== NOT EXECUTED
400185b4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
400185b8: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
400185bc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400185c0: 81 c7 e0 08 ret
<== NOT EXECUTED
400185c4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
400185c8: 7f ff d9 61 call 4000eb4c <__errno>
<== NOT EXECUTED
400185cc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400185d0: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
400185d4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400185d8: 81 c7 e0 08 ret
<== NOT EXECUTED
400185dc: 81 e8 00 00 restore
<== NOT EXECUTED
4000d234 <ftruncate>:
#include <unistd.h>
#include <rtems/libio_.h>
int ftruncate( int fd, off_t length )
{
4000d234: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
if ( length >= 0 ) {
4000d238: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000d23c: 06 80 00 39 bl 4000d320 <ftruncate+0xec>
<== NOT EXECUTED
4000d240: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
rtems_libio_t *iop;
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
4000d244: c2 00 62 a8 ld [ %g1 + 0x2a8 ], %g1 ! 40018ea8 <rtems_libio_number_iops>
<== NOT EXECUTED
4000d248: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
4000d24c: 1a 80 00 1f bcc 4000d2c8 <ftruncate+0x94>
<== NOT EXECUTED
4000d250: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
4000d254: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
4000d258: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
4000d25c: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
4000d260: b0 16 21 48 or %i0, 0x148, %i0
<== NOT EXECUTED
4000d264: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000d268: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000d26c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4000d270: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4000d274: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000d278: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000d27c: 01 00 00 00 nop
<== NOT EXECUTED
4000d280: 82 08 a1 04 and %g2, 0x104, %g1
<== NOT EXECUTED
4000d284: 80 a0 61 04 cmp %g1, 0x104
<== NOT EXECUTED
4000d288: 12 80 00 16 bne 4000d2e0 <ftruncate+0xac>
<== NOT EXECUTED
4000d28c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
rv = (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
4000d290: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000d294: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4000d298: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000d29c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000d2a0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000d2a4: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000d2a8: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000d2ac: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000d2b0: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000d2b4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000d2b8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000d2bc: 01 00 00 00 nop
<== NOT EXECUTED
4000d2c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d2c4: 81 e8 00 00 restore
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
4000d2c8: 40 00 06 21 call 4000eb4c <__errno>
<== NOT EXECUTED
4000d2cc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000d2d0: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4000d2d4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000d2d8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d2dc: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000d2e0: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000d2e4: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
4000d2e8: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
4000d2ec: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000d2f0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000d2f4: 01 00 00 00 nop
<== NOT EXECUTED
4000d2f8: 84 08 a1 00 and %g2, 0x100, %g2
<== NOT EXECUTED
4000d2fc: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
4000d300: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000d304: 40 00 06 12 call 4000eb4c <__errno>
<== NOT EXECUTED
4000d308: ba 60 20 00 subx %g0, 0, %i5
<== NOT EXECUTED
4000d30c: ba 0f 60 0d and %i5, 0xd, %i5
<== NOT EXECUTED
4000d310: ba 07 60 09 add %i5, 9, %i5
<== NOT EXECUTED
4000d314: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
4000d318: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d31c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
} else {
errno = EINVAL;
4000d320: 40 00 06 0b call 4000eb4c <__errno>
<== NOT EXECUTED
4000d324: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000d328: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000d32c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
4000d330: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d334: 81 e8 00 00 restore
<== NOT EXECUTED
40004ed8 <getchark>:
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
40004ed8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( BSP_poll_char )
40004edc: 03 10 00 6e sethi %hi(0x4001b800), %g1
<== NOT EXECUTED
40004ee0: d0 00 61 14 ld [ %g1 + 0x114 ], %o0 ! 4001b914 <BSP_poll_char>
<== NOT EXECUTED
40004ee4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40004ee8: 02 80 00 06 be 40004f00 <getchark+0x28>
<== NOT EXECUTED
40004eec: 01 00 00 00 nop
<== NOT EXECUTED
return (*BSP_poll_char)();
40004ef0: 9f c2 00 00 call %o0
<== NOT EXECUTED
40004ef4: 01 00 00 00 nop
<== NOT EXECUTED
40004ef8: 81 c7 e0 08 ret
<== NOT EXECUTED
40004efc: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
return -1;
}
40004f00: 81 c7 e0 08 ret
<== NOT EXECUTED
40004f04: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40004f38 <gettimeofday>:
*/
int gettimeofday(
struct timeval *__restrict tp,
void *__restrict __tz RTEMS_UNUSED
)
{
40004f38: 9d e3 bf a0 save %sp, -96, %sp
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
40004f3c: 80 a6 20 00 cmp %i0, 0
40004f40: 02 80 00 06 be 40004f58 <gettimeofday+0x20>
<== NEVER TAKEN
40004f44: 90 10 00 18 mov %i0, %o0
RTEMS_INLINE_ROUTINE void _TOD_Get_timeval(
struct timeval *time
)
{
_Timecounter_Microtime( time );
40004f48: 40 00 0e a5 call 400089dc <_Timecounter_Microtime>
40004f4c: 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;
}
40004f50: 81 c7 e0 08 ret
40004f54: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EFAULT );
40004f58: 40 00 26 fd call 4000eb4c <__errno>
<== NOT EXECUTED
40004f5c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004f60: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
40004f64: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004f68: 81 c7 e0 08 ret
<== NOT EXECUTED
40004f6c: 81 e8 00 00 restore
<== NOT EXECUTED
40018604 <lseek>:
#include <unistd.h>
#include <rtems/libio_.h>
off_t lseek( int fd, off_t offset, int whence )
{
40018604: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_t *iop;
off_t rv;
LIBIO_GET_IOP( fd, iop );
40018608: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4001860c: c2 00 62 a8 ld [ %g1 + 0x2a8 ], %g1 ! 40018ea8 <rtems_libio_number_iops>
<== NOT EXECUTED
40018610: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
40018614: 1a 80 00 26 bcc 400186ac <lseek+0xa8>
<== NOT EXECUTED
40018618: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
4001861c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40018620: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
40018624: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40018628: b0 16 21 48 or %i0, 0x148, %i0
<== NOT EXECUTED
4001862c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018630: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40018634: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40018638: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4001863c: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018640: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018644: 01 00 00 00 nop
<== NOT EXECUTED
40018648: 80 88 a1 00 btst 0x100, %g2
<== NOT EXECUTED
4001864c: 02 80 00 12 be 40018694 <lseek+0x90>
<== NOT EXECUTED
40018650: 96 10 00 1b mov %i3, %o3
<== NOT EXECUTED
rv = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
40018654: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
40018658: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
4001865c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40018660: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40018664: 9f c0 40 00 call %g1
<== NOT EXECUTED
40018668: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4001866c: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
40018670: b2 10 00 09 mov %o1, %i1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018674: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40018678: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4001867c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018680: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018684: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018688: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
return rv;
}
4001868c: 81 c7 e0 08 ret
<== NOT EXECUTED
40018690: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018694: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018698: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4001869c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400186a0: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400186a4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400186a8: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
400186ac: 7f ff d9 28 call 4000eb4c <__errno>
<== NOT EXECUTED
400186b0: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
400186b4: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
400186b8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400186bc: 81 c7 e0 08 ret
<== NOT EXECUTED
400186c0: 93 e8 3f ff restore %g0, -1, %o1
<== NOT EXECUTED
400052bc <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
400052bc: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Validate the parameters
*/
if ( !size )
400052c0: 80 a6 20 00 cmp %i0, 0
400052c4: 02 80 00 0a be 400052ec <malloc+0x30>
<== NEVER TAKEN
400052c8: 90 10 00 18 mov %i0, %o0
return (void *) 0;
return_this = rtems_heap_allocate_aligned_with_boundary( size, 0, 0 );
400052cc: 94 10 20 00 clr %o2
400052d0: 7f ff ff 92 call 40005118 <rtems_heap_allocate_aligned_with_boundary>
400052d4: 92 10 20 00 clr %o1
if ( !return_this ) {
400052d8: b0 92 20 00 orcc %o0, 0, %i0
400052dc: 02 80 00 06 be 400052f4 <malloc+0x38>
<== NEVER TAKEN
400052e0: 01 00 00 00 nop
errno = ENOMEM;
return (void *) 0;
}
return return_this;
}
400052e4: 81 c7 e0 08 ret
400052e8: 81 e8 00 00 restore
400052ec: 81 c7 e0 08 ret
<== NOT EXECUTED
400052f0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
errno = ENOMEM;
400052f4: 40 00 26 16 call 4000eb4c <__errno>
<== NOT EXECUTED
400052f8: 01 00 00 00 nop
<== NOT EXECUTED
400052fc: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
40005300: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return (void *) 0;
40005304: 81 c7 e0 08 ret
<== NOT EXECUTED
40005308: 81 e8 00 00 restore
<== NOT EXECUTED
400053d4 <mknod>:
* This routine is not defined in the POSIX 1003.1b standard but is
* commonly supported on most UNIX and POSIX systems. It is the
* foundation for creating file system objects.
*/
int mknod( const char *path, mode_t mode, dev_t dev )
{
400053d4: 9d e3 bf 68 save %sp, -152, %sp
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK
| RTEMS_FS_MAKE
| RTEMS_FS_EXCLUSIVE
| (S_ISDIR(mode) ? RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS : 0);
400053d8: 03 00 00 3c sethi %hi(0xf000), %g1
400053dc: 05 00 00 10 sethi %hi(0x4000), %g2
400053e0: 82 0e 40 01 and %i1, %g1, %g1
400053e4: 80 a0 40 02 cmp %g1, %g2
400053e8: 02 80 00 03 be 400053f4 <mknod+0x20>
<== ALWAYS TAKEN
400053ec: 94 10 20 f8 mov 0xf8, %o2
400053f0: 94 10 20 78 mov 0x78, %o2
<== NOT EXECUTED
const rtems_filesystem_location_info_t *currentloc =
400053f4: 92 10 00 18 mov %i0, %o1
400053f8: 40 00 03 8a call 40006220 <rtems_filesystem_eval_path_start>
400053fc: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rv = rtems_filesystem_mknod(
40005400: d4 07 bf d4 ld [ %fp + -44 ], %o2
40005404: d2 07 bf d0 ld [ %fp + -48 ], %o1
40005408: 98 10 00 1a mov %i2, %o4
4000540c: 9a 10 00 1b mov %i3, %o5
40005410: 7f ff ff c6 call 40005328 <rtems_filesystem_mknod>
40005414: 96 10 00 19 mov %i1, %o3
40005418: b0 10 00 08 mov %o0, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
dev
);
rtems_filesystem_eval_path_cleanup( &ctx );
4000541c: 40 00 03 8d call 40006250 <rtems_filesystem_eval_path_cleanup>
40005420: 90 07 bf c8 add %fp, -56, %o0
return rv;
}
40005424: 81 c7 e0 08 ret
40005428: 81 e8 00 00 restore
4000542c <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
4000542c: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
40005430: 80 a6 e0 01 cmp %i3, 1
40005434: 18 80 00 b2 bgu 400056fc <mount+0x2d0>
<== NEVER TAKEN
40005438: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
4000543c: 40 00 20 32 call 4000d504 <rtems_filesystem_get_mount_handler>
40005440: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
40005444: a2 92 20 00 orcc %o0, 0, %l1
40005448: 02 80 00 ad be 400056fc <mount+0x2d0>
<== NEVER TAKEN
4000544c: 80 a6 60 00 cmp %i1, 0
const char *target = target_or_null != NULL ? target_or_null : "/";
40005450: 02 80 00 78 be 40005630 <mount+0x204>
<== ALWAYS TAKEN
40005454: 90 10 00 19 mov %i1, %o0
40005458: 40 00 28 9b call 4000f6c4 <strlen>
<== NOT EXECUTED
4000545c: a6 10 00 19 mov %i1, %l3
<== NOT EXECUTED
40005460: a4 02 20 01 add %o0, 1, %l2
<== NOT EXECUTED
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40005464: 40 00 28 98 call 4000f6c4 <strlen>
40005468: 90 10 00 1a mov %i2, %o0
strlen( source_or_null ) + 1 : 0;
4000546c: 80 a6 20 00 cmp %i0, 0
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40005470: a8 02 20 01 add %o0, 1, %l4
strlen( source_or_null ) + 1 : 0;
40005474: 02 80 00 61 be 400055f8 <mount+0x1cc>
<== ALWAYS TAKEN
40005478: ba 02 20 65 add %o0, 0x65, %i5
4000547c: 40 00 28 92 call 4000f6c4 <strlen>
<== NOT EXECUTED
40005480: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
40005484: 92 07 40 12 add %i5, %l2, %o1
<== NOT EXECUTED
strlen( source_or_null ) + 1 : 0;
40005488: a0 02 20 01 add %o0, 1, %l0
<== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
4000548c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
40005490: 7f ff fe 31 call 40004d54 <calloc>
<== NOT EXECUTED
40005494: 92 02 40 10 add %o1, %l0, %o1
<== NOT EXECUTED
if ( mt_entry != NULL ) {
40005498: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4000549c: 12 80 00 08 bne 400054bc <mount+0x90>
<== NOT EXECUTED
400054a0: 84 07 60 64 add %i5, 0x64, %g2
<== NOT EXECUTED
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
400054a4: 40 00 25 aa call 4000eb4c <__errno>
<== NOT EXECUTED
400054a8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400054ac: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
400054b0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400054b4: 81 c7 e0 08 ret
<== NOT EXECUTED
400054b8: 81 e8 00 00 restore
<== NOT EXECUTED
memcpy( str, filesystemtype, filesystemtype_size );
400054bc: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
400054c0: 94 10 00 14 mov %l4, %o2
<== NOT EXECUTED
400054c4: 40 00 27 13 call 4000f110 <memcpy>
<== NOT EXECUTED
400054c8: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
mt_entry->type = str;
400054cc: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
<== NOT EXECUTED
str += filesystemtype_size;
400054d0: 84 02 00 14 add %o0, %l4, %g2
<== NOT EXECUTED
memcpy( str, source_or_null, source_size );
400054d4: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
400054d8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400054dc: 40 00 27 0d call 4000f110 <memcpy>
<== NOT EXECUTED
400054e0: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
mt_entry->dev = str;
400054e4: d0 27 60 38 st %o0, [ %i5 + 0x38 ]
<== NOT EXECUTED
rtems_filesystem_global_location_t *mt_fs_root =
400054e8: b4 07 60 40 add %i5, 0x40, %i2
<== NOT EXECUTED
str += source_size;
400054ec: a0 02 00 10 add %o0, %l0, %l0
<== NOT EXECUTED
memcpy( str, target, target_size );
400054f0: 94 10 00 12 mov %l2, %o2
400054f4: 92 10 00 13 mov %l3, %o1
400054f8: 40 00 27 06 call 4000f110 <memcpy>
400054fc: 90 10 00 10 mov %l0, %o0
mt_entry->mounted = true;
40005500: 82 10 20 01 mov 1, %g1
40005504: c2 2f 60 28 stb %g1, [ %i5 + 0x28 ]
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40005508: 03 10 00 65 sethi %hi(0x40019400), %g1
4000550c: 82 10 63 f8 or %g1, 0x3f8, %g1 ! 400197f8 <rtems_filesystem_default_pathconf>
mt_entry->target = str;
40005510: e0 27 60 30 st %l0, [ %i5 + 0x30 ]
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize(
40005514: 96 10 20 24 mov 0x24, %o3
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40005518: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->reference_count = 1;
4000551c: 82 10 20 01 mov 1, %g1
mt_entry->mt_fs_root = mt_fs_root;
40005520: f4 27 60 24 st %i2, [ %i5 + 0x24 ]
40005524: 94 10 20 01 mov 1, %o2
mt_fs_root->reference_count = 1;
40005528: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
4000552c: 92 10 00 1a mov %i2, %o1
mt_fs_root->location.mt_entry = mt_entry;
40005530: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
40005534: 90 07 60 14 add %i5, 0x14, %o0
40005538: 40 00 06 eb call 400070e4 <_Chain_Initialize>
4000553c: b6 0e e0 01 and %i3, 1, %i3
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
40005540: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
40005544: 92 10 00 1c mov %i4, %o1
40005548: 9f c4 40 00 call %l1
4000554c: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40005550: b0 92 20 00 orcc %o0, 0, %i0
40005554: 12 80 00 25 bne 400055e8 <mount+0x1bc>
<== NEVER TAKEN
40005558: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
4000555c: 02 80 00 48 be 4000567c <mount+0x250>
<== ALWAYS TAKEN
40005560: 94 10 20 1f mov 0x1f, %o2
rtems_filesystem_location_info_t *currentloc =
40005564: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40005568: 40 00 03 2e call 40006220 <rtems_filesystem_eval_path_start>
<== NOT EXECUTED
4000556c: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40005570: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
return (*mt_entry->ops->are_nodes_equal_h)(
40005574: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40005578: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
4000557c: 9f c0 80 00 call %g2
<== NOT EXECUTED
40005580: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
<== NOT EXECUTED
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
40005584: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005588: 12 80 00 63 bne 40005714 <mount+0x2e8>
<== NOT EXECUTED
4000558c: 92 07 bf e0 add %fp, -32, %o1
<== NOT EXECUTED
rtems_filesystem_location_copy_and_detach(
40005590: 40 00 04 7a call 40006778 <rtems_filesystem_location_copy_and_detach>
<== NOT EXECUTED
40005594: 90 07 bf b0 add %fp, -80, %o0
<== NOT EXECUTED
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40005598: 40 00 04 a3 call 40006824 <rtems_filesystem_location_transform_to_global>
<== NOT EXECUTED
4000559c: 90 07 bf b0 add %fp, -80, %o0
<== NOT EXECUTED
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
400055a0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
400055a4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
mt_entry->mt_point_node = mt_point_node;
400055a8: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
<== NOT EXECUTED
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
400055ac: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
400055b0: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
<== NOT EXECUTED
400055b4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400055b8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
400055bc: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
400055c0: 02 80 00 20 be 40005640 <mount+0x214>
<== NOT EXECUTED
400055c4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
rtems_filesystem_global_location_release( mt_point_node, true );
400055c8: 40 00 04 27 call 40006664 <rtems_filesystem_global_location_release>
<== NOT EXECUTED
400055cc: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
400055d0: 40 00 03 20 call 40006250 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
400055d4: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
400055d8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
400055dc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
<== NOT EXECUTED
400055e0: 9f c0 40 00 call %g1
<== NOT EXECUTED
400055e4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
free( mt_entry );
400055e8: 7f ff fe 26 call 40004e80 <free>
<== NOT EXECUTED
400055ec: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
errno = EINVAL;
rv = -1;
}
return rv;
}
400055f0: 81 c7 e0 08 ret
<== NOT EXECUTED
400055f4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
400055f8: 92 07 40 12 add %i5, %l2, %o1
400055fc: 7f ff fd d6 call 40004d54 <calloc>
40005600: 90 10 20 01 mov 1, %o0
if ( mt_entry != NULL ) {
40005604: ba 92 20 00 orcc %o0, 0, %i5
40005608: 02 bf ff a7 be 400054a4 <mount+0x78>
<== NEVER TAKEN
4000560c: 84 07 60 64 add %i5, 0x64, %g2
memcpy( str, filesystemtype, filesystemtype_size );
40005610: 92 10 00 1a mov %i2, %o1
40005614: 94 10 00 14 mov %l4, %o2
40005618: 90 10 00 02 mov %g2, %o0
4000561c: 40 00 26 bd call 4000f110 <memcpy>
40005620: b4 07 60 40 add %i5, 0x40, %i2
str += filesystemtype_size;
40005624: a0 02 00 14 add %o0, %l4, %l0
mt_entry->type = str;
40005628: 10 bf ff b2 b 400054f0 <mount+0xc4>
4000562c: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
const char *target = target_or_null != NULL ? target_or_null : "/";
40005630: 27 10 00 63 sethi %hi(0x40018c00), %l3
40005634: a4 10 20 02 mov 2, %l2
40005638: 10 bf ff 8b b 40005464 <mount+0x38>
4000563c: a6 14 e2 18 or %l3, 0x218, %l3
rtems_libio_lock();
40005640: 7f ff fe 84 call 40005050 <rtems_libio_lock>
<== NOT EXECUTED
40005644: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
40005648: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
4000564c: 82 10 63 dc or %g1, 0x3dc, %g1 ! 4001b3dc <rtems_filesystem_mount_table>
<== NOT EXECUTED
40005650: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
the_node->next = tail;
40005654: 86 00 60 04 add %g1, 4, %g3
<== NOT EXECUTED
tail->previous = the_node;
40005658: fa 20 60 08 st %i5, [ %g1 + 8 ]
<== NOT EXECUTED
the_node->next = tail;
4000565c: c6 27 40 00 st %g3, [ %i5 ]
<== NOT EXECUTED
old_last->next = the_node;
40005660: fa 20 80 00 st %i5, [ %g2 ]
<== NOT EXECUTED
rtems_libio_unlock();
40005664: 7f ff fe 80 call 40005064 <rtems_libio_unlock>
<== NOT EXECUTED
40005668: c4 27 60 04 st %g2, [ %i5 + 4 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
4000566c: 40 00 02 f9 call 40006250 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40005670: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
40005674: 81 c7 e0 08 ret
<== NOT EXECUTED
40005678: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_libio_lock();
4000567c: 7f ff fe 75 call 40005050 <rtems_libio_lock>
40005680: 01 00 00 00 nop
return _Chain_Immutable_head( the_chain )->next;
40005684: 03 10 00 6c sethi %hi(0x4001b000), %g1
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
40005688: c4 00 63 dc ld [ %g1 + 0x3dc ], %g2 ! 4001b3dc <rtems_filesystem_mount_table>
4000568c: 82 10 63 dc or %g1, 0x3dc, %g1
40005690: 86 00 60 04 add %g1, 4, %g3
40005694: 80 a0 80 03 cmp %g2, %g3
40005698: 12 80 00 27 bne 40005734 <mount+0x308>
<== NEVER TAKEN
4000569c: 01 00 00 00 nop
old_last = tail->previous;
400056a0: c6 00 60 08 ld [ %g1 + 8 ], %g3
the_node->next = tail;
400056a4: c4 27 40 00 st %g2, [ %i5 ]
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
400056a8: b8 07 60 24 add %i5, 0x24, %i4
tail->previous = the_node;
400056ac: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
400056b0: fa 20 c0 00 st %i5, [ %g3 ]
rtems_libio_unlock();
400056b4: 7f ff fe 6c call 40005064 <rtems_libio_unlock>
400056b8: c6 27 60 04 st %g3, [ %i5 + 4 ]
rtems_filesystem_global_location_t *new_fs_root =
400056bc: 40 00 03 b0 call 4000657c <rtems_filesystem_global_location_obtain>
400056c0: 90 10 00 1c mov %i4, %o0
400056c4: b6 10 00 08 mov %o0, %i3
rtems_filesystem_global_location_t *new_fs_current =
400056c8: 40 00 03 ad call 4000657c <rtems_filesystem_global_location_obtain>
400056cc: 90 10 00 1c mov %i4, %o0
&rtems_filesystem_root,
400056d0: 40 00 01 26 call 40005b68 <rtems_current_user_env_get>
400056d4: ba 10 00 08 mov %o0, %i5
rtems_filesystem_global_location_assign(
400056d8: 92 10 00 1b mov %i3, %o1
400056dc: 40 00 03 fc call 400066cc <rtems_filesystem_global_location_assign>
400056e0: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_current,
400056e4: 40 00 01 21 call 40005b68 <rtems_current_user_env_get>
400056e8: 01 00 00 00 nop
rtems_filesystem_global_location_assign(
400056ec: 40 00 03 f8 call 400066cc <rtems_filesystem_global_location_assign>
400056f0: 92 10 00 1d mov %i5, %o1
400056f4: 81 c7 e0 08 ret
400056f8: 81 e8 00 00 restore
errno = EINVAL;
400056fc: 40 00 25 14 call 4000eb4c <__errno>
<== NOT EXECUTED
40005700: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005704: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40005708: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return rv;
4000570c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005710: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_eval_path_error( &ctx, EBUSY );
40005714: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
40005718: 40 00 02 07 call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
4000571c: 92 10 20 10 mov 0x10, %o1
<== NOT EXECUTED
rv = -1;
40005720: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40005724: 40 00 02 cb call 40006250 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40005728: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
4000572c: 10 bf ff ac b 400055dc <mount+0x1b0>
<== NOT EXECUTED
40005730: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
errno = EINVAL;
40005734: 40 00 25 06 call 4000eb4c <__errno>
<== NOT EXECUTED
40005738: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000573c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40005740: 7f ff fe 49 call 40005064 <rtems_libio_unlock>
<== NOT EXECUTED
40005744: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40005748: 10 bf ff a5 b 400055dc <mount+0x1b0>
<== NOT EXECUTED
4000574c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
400057c4 <newlib_terminate_hook>:
void newlib_terminate_hook(
rtems_tcb *current_task
)
{
_reclaim_reent(current_task->libc_reent);
400057c4: d0 02 21 54 ld [ %o0 + 0x154 ], %o0
<== NOT EXECUTED
400057c8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400057cc: 40 00 26 e0 call 4000f34c <_reclaim_reent>
<== NOT EXECUTED
400057d0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000584c <open>:
/**
* POSIX 1003.1 5.3.1 - Open a File
*/
int open( const char *path, int oflag, ... )
{
4000584c: 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 );
40005850: 82 07 a0 50 add %fp, 0x50, %g1
va_start( ap, oflag );
40005854: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
40005858: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
4000585c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40005860: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
iop = rtems_libio_allocate();
40005864: 40 00 1e ca call 4000d38c <rtems_libio_allocate>
40005868: c2 27 bf 64 st %g1, [ %fp + -156 ]
if ( iop != NULL ) {
4000586c: ba 92 20 00 orcc %o0, 0, %i5
40005870: 02 80 00 76 be 40005a48 <open+0x1fc>
<== NEVER TAKEN
40005874: 82 06 60 01 add %i1, 1, %g1
bool make = (oflag & O_CREAT) == O_CREAT;
40005878: 86 0e 62 00 and %i1, 0x200, %g3
bool read_access = (rwflag & _FREAD) == _FREAD;
4000587c: 94 08 60 01 and %g1, 1, %o2
bool exclusive = (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
40005880: 84 0e 6a 00 and %i1, 0xa00, %g2
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40005884: 94 02 bf ff add %o2, -1, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40005888: b8 88 60 02 andcc %g1, 2, %i4
| (read_access ? RTEMS_FS_PERMS_READ : 0)
4000588c: 94 0a bf fc and %o2, -4, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40005890: 02 80 00 03 be 4000589c <open+0x50>
40005894: 94 02 a0 1c add %o2, 0x1c, %o2
40005898: 94 12 a0 02 or %o2, 2, %o2
| (make ? RTEMS_FS_MAKE : 0)
4000589c: 80 a0 e0 00 cmp %g3, 0
400058a0: 32 80 00 02 bne,a 400058a8 <open+0x5c>
<== NEVER TAKEN
400058a4: 94 12 a0 20 or %o2, 0x20, %o2
<== NOT EXECUTED
| (exclusive ? RTEMS_FS_EXCLUSIVE : 0);
400058a8: 80 a0 aa 00 cmp %g2, 0xa00
400058ac: 22 80 00 02 be,a 400058b4 <open+0x68>
<== NEVER TAKEN
400058b0: 94 12 a0 40 or %o2, 0x40, %o2
<== NOT EXECUTED
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
400058b4: 92 10 00 18 mov %i0, %o1
400058b8: 40 00 02 5a call 40006220 <rtems_filesystem_eval_path_start>
400058bc: 90 07 bf 68 add %fp, -152, %o0
400058c0: f6 07 bf 74 ld [ %fp + -140 ], %i3
if ( rtems_filesystem_eval_path_has_token( &ctx ) ) {
400058c4: 80 a6 e0 00 cmp %i3, 0
400058c8: 12 80 00 45 bne 400059dc <open+0x190>
<== NEVER TAKEN
400058cc: 80 a7 20 00 cmp %i4, 0
if ( write_access ) {
400058d0: 02 80 00 0e be 40005908 <open+0xbc>
400058d4: c2 07 bf 90 ld [ %fp + -112 ], %g1
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
400058d8: c0 27 bf ac clr [ %fp + -84 ]
(void) ( *loc->handlers->fstat_h )( loc, &st );
400058dc: 92 07 bf a0 add %fp, -96, %o1
400058e0: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
400058e4: 9f c0 40 00 call %g1
400058e8: 90 07 bf 80 add %fp, -128, %o0
if ( S_ISDIR( type ) ) {
400058ec: 05 00 00 3c sethi %hi(0xf000), %g2
400058f0: c2 07 bf ac ld [ %fp + -84 ], %g1
400058f4: 82 08 40 02 and %g1, %g2, %g1
400058f8: 05 00 00 10 sethi %hi(0x4000), %g2
400058fc: 80 a0 40 02 cmp %g1, %g2
40005900: 02 80 00 4e be 40005a38 <open+0x1ec>
<== NEVER TAKEN
40005904: 92 10 20 15 mov 0x15, %o1
rtems_filesystem_location_copy_and_detach(
40005908: 92 07 bf 80 add %fp, -128, %o1
4000590c: 40 00 03 9b call 40006778 <rtems_filesystem_location_copy_and_detach>
40005910: 90 07 60 0c add %i5, 0xc, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
40005914: 40 00 02 4f call 40006250 <rtems_filesystem_eval_path_cleanup>
40005918: 90 07 bf 68 add %fp, -152, %o0
_Atomic_Store_uint(
4000591c: 40 00 1e 8f call 4000d358 <rtems_libio_fcntl_flags>
40005920: 90 10 00 19 mov %i1, %o0
rv = (*iop->pathinfo.handlers->open_h)( iop, path, oflag, mode );
40005924: 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;
40005928: d0 27 60 08 st %o0, [ %i5 + 8 ]
4000592c: 92 10 00 18 mov %i0, %o1
40005930: c2 00 40 00 ld [ %g1 ], %g1
40005934: 96 10 00 1a mov %i2, %o3
40005938: 94 10 00 19 mov %i1, %o2
4000593c: 9f c0 40 00 call %g1
40005940: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40005944: b0 92 20 00 orcc %o0, 0, %i0
40005948: 12 80 00 13 bne 40005994 <open+0x148>
<== NEVER TAKEN
4000594c: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
int fd = rtems_libio_iop_to_descriptor( iop );
40005950: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
40005954: 03 2a aa aa sethi %hi(0xaaaaa800), %g1
<== NOT EXECUTED
40005958: b0 16 21 48 or %i0, 0x148, %i0
<== NOT EXECUTED
4000595c: 82 10 62 ab or %g1, 0x2ab, %g1
<== NOT EXECUTED
40005960: b0 27 40 18 sub %i5, %i0, %i0
<== NOT EXECUTED
40005964: b1 3e 20 04 sra %i0, 4, %i0
<== NOT EXECUTED
40005968: b0 5e 00 01 smul %i0, %g1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000596c: 91 d0 20 09 ta 9
<== NOT EXECUTED
ISR_Level level;
(void) order;
_ISR_Local_disable( level );
val = *obj;
*obj = val | arg;
40005970: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005974: 84 10 a1 00 or %g2, 0x100, %g2
<== NOT EXECUTED
40005978: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000597c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005980: 01 00 00 00 nop
if ( truncate ) {
40005984: 80 8e 64 00 btst 0x400, %i1
40005988: 12 80 00 07 bne 400059a4 <open+0x158>
<== NEVER TAKEN
4000598c: 92 10 20 00 clr %o1
if ( rv < 0 ) {
40005990: 80 a6 20 00 cmp %i0, 0
40005994: 06 80 00 0e bl 400059cc <open+0x180>
<== NEVER TAKEN
40005998: 01 00 00 00 nop
}
va_end( ap );
return rv;
}
4000599c: 81 c7 e0 08 ret
400059a0: 81 e8 00 00 restore
rv = ftruncate( fd, 0 );
400059a4: 94 10 20 00 clr %o2
<== NOT EXECUTED
400059a8: 40 00 1e 23 call 4000d234 <ftruncate>
<== NOT EXECUTED
400059ac: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( rv != 0 ) {
400059b0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400059b4: 02 bf ff f7 be 40005990 <open+0x144>
<== NOT EXECUTED
400059b8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
(*iop->pathinfo.handlers->close_h)( iop );
400059bc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
400059c0: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
400059c4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400059c8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_libio_free( iop );
400059cc: 40 00 1e 85 call 4000d3e0 <rtems_libio_free>
<== NOT EXECUTED
400059d0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400059d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400059d8: 81 e8 00 00 restore
<== NOT EXECUTED
400059dc: e0 07 bf 70 ld [ %fp + -144 ], %l0
<== NOT EXECUTED
rv = rtems_filesystem_mknod(
400059e0: 98 10 20 00 clr %o4
<== NOT EXECUTED
400059e4: 9a 10 20 00 clr %o5
<== NOT EXECUTED
400059e8: 17 00 00 20 sethi %hi(0x8000), %o3
<== NOT EXECUTED
400059ec: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
400059f0: 96 16 80 0b or %i2, %o3, %o3
<== NOT EXECUTED
400059f4: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
400059f8: 7f ff fe 4c call 40005328 <rtems_filesystem_mknod>
<== NOT EXECUTED
400059fc: 90 07 bf 80 add %fp, -128, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
40005a00: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005a04: 02 80 00 06 be 40005a1c <open+0x1d0>
<== NOT EXECUTED
40005a08: 92 10 20 00 clr %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error( ctx, 0 );
40005a0c: 40 00 01 4a call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005a10: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
if ( write_access ) {
40005a14: 10 bf ff af b 400058d0 <open+0x84>
<== NOT EXECUTED
40005a18: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
ctx->flags = flags;
40005a1c: c0 27 bf 78 clr [ %fp + -136 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_continue( ctx );
40005a20: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
ctx->path = path;
40005a24: e0 27 bf 68 st %l0, [ %fp + -152 ]
<== NOT EXECUTED
40005a28: 40 00 01 8b call 40006054 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
40005a2c: f6 27 bf 6c st %i3, [ %fp + -148 ]
<== NOT EXECUTED
if ( write_access ) {
40005a30: 10 bf ff a8 b 400058d0 <open+0x84>
<== NOT EXECUTED
40005a34: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
rtems_filesystem_eval_path_error( &ctx, EISDIR );
40005a38: 40 00 01 3f call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005a3c: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
rtems_filesystem_location_copy_and_detach(
40005a40: 10 bf ff b3 b 4000590c <open+0xc0>
<== NOT EXECUTED
40005a44: 92 07 bf 80 add %fp, -128, %o1
<== NOT EXECUTED
errno = ENFILE;
40005a48: 40 00 24 41 call 4000eb4c <__errno>
<== NOT EXECUTED
40005a4c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005a50: 82 10 20 17 mov 0x17, %g1
<== NOT EXECUTED
40005a54: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40005a58: 81 c7 e0 08 ret
<== NOT EXECUTED
40005a5c: 81 e8 00 00 restore
<== NOT EXECUTED
40005b10 <printk>:
/**
* Kernel printf function requiring minimal infrastructure.
*/
int printk(const char *fmt, ...)
{
40005b10: 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 */
40005b14: 82 07 a0 48 add %fp, 0x48, %g1
<== NOT EXECUTED
40005b18: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
40005b1c: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
40005b20: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
40005b24: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
40005b28: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
<== NOT EXECUTED
40005b2c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
<== NOT EXECUTED
40005b30: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
40005b34: 40 00 03 e6 call 40006acc <vprintk>
<== NOT EXECUTED
40005b38: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
va_end(ap); /* clean up when done */
return len;
}
40005b3c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005b40: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
400186f4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
400186f4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
400186f8: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
400186fc: 02 80 00 32 be 400187c4 <read+0xd0>
<== NOT EXECUTED
40018700: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
rtems_libio_check_count( count );
40018704: 02 80 00 22 be 4001878c <read+0x98>
<== NOT EXECUTED
40018708: 84 10 20 00 clr %g2
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
4001870c: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
40018710: c2 00 62 a8 ld [ %g1 + 0x2a8 ], %g1 ! 40018ea8 <rtems_libio_number_iops>
<== NOT EXECUTED
40018714: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
40018718: 1a 80 00 25 bcc 400187ac <read+0xb8>
<== NOT EXECUTED
4001871c: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
40018720: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40018724: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
40018728: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
4001872c: b0 16 21 48 or %i0, 0x148, %i0
<== NOT EXECUTED
40018730: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018734: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40018738: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4001873c: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40018740: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018744: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018748: 01 00 00 00 nop
<== NOT EXECUTED
4001874c: 84 08 a1 02 and %g2, 0x102, %g2
<== NOT EXECUTED
40018750: 80 a0 a1 02 cmp %g2, 0x102
<== NOT EXECUTED
40018754: 12 80 00 10 bne 40018794 <read+0xa0>
<== NOT EXECUTED
40018758: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
/*
* Now process the read().
*/
n = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
4001875c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
40018760: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
40018764: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40018768: 9f c0 40 00 call %g1
<== NOT EXECUTED
4001876c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40018770: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018774: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40018778: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
4001877c: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
40018780: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018784: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018788: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
return n;
}
4001878c: 81 c7 e0 08 ret
<== NOT EXECUTED
40018790: 91 e8 00 02 restore %g0, %g2, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018794: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018798: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4001879c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400187a0: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400187a4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400187a8: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
400187ac: 7f ff d8 e8 call 4000eb4c <__errno>
<== NOT EXECUTED
400187b0: 01 00 00 00 nop
<== NOT EXECUTED
400187b4: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
400187b8: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
400187bc: 10 bf ff f4 b 4001878c <read+0x98>
<== NOT EXECUTED
400187c0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_libio_check_buffer( buffer );
400187c4: 7f ff d8 e2 call 4000eb4c <__errno>
<== NOT EXECUTED
400187c8: 01 00 00 00 nop
<== NOT EXECUTED
400187cc: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
400187d0: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
400187d4: 10 bf ff ee b 4001878c <read+0x98>
<== NOT EXECUTED
400187d8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40018828 <realloc>:
return new_ptr;
}
void *realloc( void *ptr, size_t size )
{
40018828: 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 ) {
4001882c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40018830: 02 80 00 40 be 40018930 <realloc+0x108>
<== NOT EXECUTED
40018834: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
free( ptr );
return NULL;
}
if ( ptr == NULL ) {
40018838: 02 80 00 34 be 40018908 <realloc+0xe0>
<== NOT EXECUTED
4001883c: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
return malloc( size );
}
heap = RTEMS_Malloc_Heap;
switch ( _Malloc_System_state() ) {
40018840: 7f ff b2 0e call 40005078 <_Malloc_System_state>
<== NOT EXECUTED
40018844: fa 00 63 a4 ld [ %g1 + 0x3a4 ], %i5 ! 4001b3a4 <RTEMS_Malloc_Heap>
<== NOT EXECUTED
40018848: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4001884c: 02 80 00 21 be 400188d0 <realloc+0xa8>
<== NOT EXECUTED
40018850: 01 00 00 00 nop
<== NOT EXECUTED
40018854: 80 a2 20 01 cmp %o0, 1
<== NOT EXECUTED
40018858: 32 80 00 2e bne,a 40018910 <realloc+0xe8>
<== NOT EXECUTED
4001885c: 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 );
40018860: 98 07 bf fc add %fp, -4, %o4
<== NOT EXECUTED
40018864: 96 07 bf f8 add %fp, -8, %o3
<== NOT EXECUTED
40018868: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4001886c: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40018870: 40 00 00 6e call 40018a28 <_Heap_Resize_block>
<== NOT EXECUTED
40018874: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40018878: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
break;
default:
return NULL;
}
switch ( status ) {
4001887c: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40018880: 02 80 00 12 be 400188c8 <realloc+0xa0>
<== NOT EXECUTED
40018884: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
40018888: 80 a7 20 01 cmp %i4, 1
<== NOT EXECUTED
4001888c: 12 80 00 23 bne 40018918 <realloc+0xf0>
<== NOT EXECUTED
40018890: f8 07 bf f8 ld [ %fp + -8 ], %i4
<== NOT EXECUTED
new_ptr = malloc( new_size );
40018894: 7f ff b2 8a call 400052bc <malloc>
<== NOT EXECUTED
40018898: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
if ( new_ptr == NULL ) {
4001889c: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
400188a0: 02 80 00 0a be 400188c8 <realloc+0xa0>
<== NOT EXECUTED
400188a4: 80 a7 00 19 cmp %i4, %i1
<== NOT EXECUTED
memcpy( new_ptr, old_ptr, ( new_size < old_size ) ? new_size : old_size );
400188a8: 08 80 00 03 bleu 400188b4 <realloc+0x8c>
<== NOT EXECUTED
400188ac: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
400188b0: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
400188b4: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400188b8: 7f ff da 16 call 4000f110 <memcpy>
<== NOT EXECUTED
400188bc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
free( old_ptr );
400188c0: 7f ff b1 70 call 40004e80 <free>
<== NOT EXECUTED
400188c4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return new_alloc( ptr, size, old_size );
default:
errno = EINVAL;
return NULL;
}
}
400188c8: 81 c7 e0 08 ret
<== NOT EXECUTED
400188cc: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
_RTEMS_Lock_allocator();
400188d0: 7f ff b9 e3 call 4000705c <_RTEMS_Lock_allocator>
<== NOT EXECUTED
400188d4: 01 00 00 00 nop
<== NOT EXECUTED
_Malloc_Process_deferred_frees();
400188d8: 7f ff b1 f7 call 400050b4 <_Malloc_Process_deferred_frees>
<== NOT EXECUTED
400188dc: 01 00 00 00 nop
<== NOT EXECUTED
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
400188e0: 98 07 bf fc add %fp, -4, %o4
<== NOT EXECUTED
400188e4: 96 07 bf f8 add %fp, -8, %o3
<== NOT EXECUTED
400188e8: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
400188ec: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400188f0: 40 00 00 4e call 40018a28 <_Heap_Resize_block>
<== NOT EXECUTED
400188f4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
400188f8: 7f ff b9 de call 40007070 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
400188fc: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
break;
40018900: 10 bf ff e0 b 40018880 <realloc+0x58>
<== NOT EXECUTED
40018904: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
return malloc( size );
40018908: 7f ff b2 6d call 400052bc <malloc>
<== NOT EXECUTED
4001890c: 91 e8 00 19 restore %g0, %i1, %o0
<== NOT EXECUTED
}
40018910: 81 c7 e0 08 ret
<== NOT EXECUTED
40018914: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
errno = EINVAL;
40018918: 7f ff d8 8d call 4000eb4c <__errno>
<== NOT EXECUTED
4001891c: ba 10 20 00 clr %i5
<== NOT EXECUTED
40018920: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40018924: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40018928: 81 c7 e0 08 ret
<== NOT EXECUTED
4001892c: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
free( ptr );
40018930: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40018934: 7f ff b1 53 call 40004e80 <free>
<== NOT EXECUTED
40018938: ba 10 20 00 clr %i5
<== NOT EXECUTED
return NULL;
4001893c: 30 bf ff e3 b,a 400188c8 <realloc+0xa0>
<== NOT EXECUTED
4000e944 <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000e944: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
4000e948: 90 10 00 18 mov %i0, %o0
4000e94c: 92 10 00 19 mov %i1, %o1
4000e950: 40 00 00 07 call 4000e96c <rtems_assoc_ptr_by_remote>
4000e954: b0 10 20 00 clr %i0
if (nap)
4000e958: 80 a2 20 00 cmp %o0, 0
4000e95c: 32 80 00 02 bne,a 4000e964 <rtems_assoc_local_by_remote+0x20>
<== ALWAYS TAKEN
4000e960: f0 02 20 04 ld [ %o0 + 4 ], %i0
return nap->local_value;
return 0;
}
4000e964: 81 c7 e0 08 ret
4000e968: 81 e8 00 00 restore
4000e8f8 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000e8f8: 9d e3 bf a0 save %sp, -96, %sp
4000e8fc: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t local_value = 0;
4000e900: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1) {
4000e904: 10 80 00 04 b 4000e914 <rtems_assoc_local_by_remote_bitfield+0x1c>
4000e908: ba 10 20 01 mov 1, %i5
4000e90c: 02 80 00 0c be 4000e93c <rtems_assoc_local_by_remote_bitfield+0x44>
4000e910: bb 2f 60 01 sll %i5, 1, %i5
if (b & remote_value)
4000e914: 80 8e 40 1d btst %i1, %i5
4000e918: 22 bf ff fd be,a 4000e90c <rtems_assoc_local_by_remote_bitfield+0x14>
<== ALWAYS TAKEN
4000e91c: b8 87 3f ff addcc %i4, -1, %i4
local_value |= rtems_assoc_local_by_remote(ap, b);
4000e920: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000e924: 40 00 00 08 call 4000e944 <rtems_assoc_local_by_remote>
<== NOT EXECUTED
4000e928: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
for (b = 1; b; b <<= 1) {
4000e92c: bb 2f 60 01 sll %i5, 1, %i5
<== NOT EXECUTED
4000e930: b8 87 3f ff addcc %i4, -1, %i4
<== NOT EXECUTED
4000e934: 12 bf ff f8 bne 4000e914 <rtems_assoc_local_by_remote_bitfield+0x1c>
<== NOT EXECUTED
4000e938: b6 16 c0 08 or %i3, %o0, %i3
<== NOT EXECUTED
}
return local_value;
}
4000e93c: 81 c7 e0 08 ret
4000e940: 91 e8 00 1b restore %g0, %i3, %o0
4000e96c <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000e96c: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000e970: d0 06 00 00 ld [ %i0 ], %o0
{
4000e974: ba 10 00 18 mov %i0, %i5
if (rtems_assoc_is_default(ap))
4000e978: 80 a2 20 00 cmp %o0, 0
4000e97c: 02 80 00 16 be 4000e9d4 <rtems_assoc_ptr_by_remote+0x68>
<== NEVER TAKEN
4000e980: b0 10 20 00 clr %i0
4000e984: 13 10 00 67 sethi %hi(0x40019c00), %o1
4000e988: 40 00 02 f4 call 4000f558 <strcmp>
4000e98c: 92 12 60 78 or %o1, 0x78, %o1 ! 40019c78 <status_code_to_errno+0xa8>
4000e990: 80 a2 20 00 cmp %o0, 0
4000e994: 22 80 00 12 be,a 4000e9dc <rtems_assoc_ptr_by_remote+0x70>
<== NEVER TAKEN
4000e998: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
4000e99c: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000e9a0: 80 a6 40 01 cmp %i1, %g1
4000e9a4: 32 80 00 08 bne,a 4000e9c4 <rtems_assoc_ptr_by_remote+0x58>
4000e9a8: ba 07 60 0c add %i5, 0xc, %i5
for ( ; ap->name; ap++)
4000e9ac: 81 c7 e0 08 ret
4000e9b0: 91 e8 00 1d restore %g0, %i5, %o0
if (ap->remote_value == remote_value)
4000e9b4: 80 a0 40 19 cmp %g1, %i1
4000e9b8: 22 80 00 07 be,a 4000e9d4 <rtems_assoc_ptr_by_remote+0x68>
<== ALWAYS TAKEN
4000e9bc: b0 10 00 1d mov %i5, %i0
for ( ; ap->name; ap++)
4000e9c0: ba 07 60 0c add %i5, 0xc, %i5
<== NOT EXECUTED
4000e9c4: c2 07 40 00 ld [ %i5 ], %g1
4000e9c8: 80 a0 60 00 cmp %g1, 0
4000e9cc: 32 bf ff fa bne,a 4000e9b4 <rtems_assoc_ptr_by_remote+0x48>
<== ALWAYS TAKEN
4000e9d0: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000e9d4: 81 c7 e0 08 ret
4000e9d8: 81 e8 00 00 restore
default_ap = ap++;
4000e9dc: 82 07 60 0c add %i5, 0xc, %g1
<== NOT EXECUTED
for ( ; ap->name; ap++)
4000e9e0: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
4000e9e4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000e9e8: 12 bf ff ed bne 4000e99c <rtems_assoc_ptr_by_remote+0x30>
<== NOT EXECUTED
4000e9ec: ba 10 00 01 mov %g1, %i5
<== NOT EXECUTED
4000e9f0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e9f4: 81 e8 00 00 restore
<== NOT EXECUTED
40005b68 <rtems_current_user_env_get>:
{
40005b68: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = pthread_getspecific(rtems_current_user_env_key);
40005b6c: 03 10 00 7d sethi %hi(0x4001f400), %g1
40005b70: 40 00 03 fb call 40006b5c <pthread_getspecific>
40005b74: d0 00 60 e0 ld [ %g1 + 0xe0 ], %o0 ! 4001f4e0 <rtems_current_user_env_key>
if (ptr == NULL) {
40005b78: b0 92 20 00 orcc %o0, 0, %i0
40005b7c: 22 80 00 04 be,a 40005b8c <rtems_current_user_env_get+0x24>
<== ALWAYS TAKEN
40005b80: 31 10 00 6c sethi %hi(0x4001b000), %i0
}
40005b84: 81 c7 e0 08 ret
<== NOT EXECUTED
40005b88: 81 e8 00 00 restore
<== NOT EXECUTED
40005b8c: 81 c7 e0 08 ret
40005b90: 91 ee 23 e8 restore %i0, 0x3e8, %o0
4000d618 <rtems_deviceio_close>:
int rtems_deviceio_close(
rtems_libio_t *iop,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000d618: 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 );
4000d61c: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4000d620: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
args.iop = iop;
4000d624: f0 27 bf f4 st %i0, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_close( major, minor, &args );
4000d628: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
args.flags = 0;
4000d62c: c0 27 bf f8 clr [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_close( major, minor, &args );
4000d630: 40 00 01 19 call 4000da94 <rtems_io_close>
<== NOT EXECUTED
4000d634: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
return rtems_status_code_to_errno( status );
4000d638: 40 00 00 96 call 4000d890 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000d63c: 01 00 00 00 nop
<== NOT EXECUTED
}
4000d640: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d644: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000d728 <rtems_deviceio_control>:
ioctl_command_t command,
void *buffer,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000d728: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_ioctl_args_t args;
args.iop = iop;
4000d72c: f0 27 bf f0 st %i0, [ %fp + -16 ]
<== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control( major, minor, &args );
4000d730: 94 07 bf f0 add %fp, -16, %o2
<== NOT EXECUTED
args.command = command;
4000d734: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_control( major, minor, &args );
4000d738: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = buffer;
4000d73c: f4 27 bf f8 st %i2, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_control( major, minor, &args );
4000d740: 40 00 00 ed call 4000daf4 <rtems_io_control>
<== NOT EXECUTED
4000d744: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000d748: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000d74c: 12 80 00 05 bne 4000d760 <rtems_deviceio_control+0x38>
<== NOT EXECUTED
4000d750: 01 00 00 00 nop
<== NOT EXECUTED
return args.ioctl_return;
4000d754: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000d758: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d75c: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno(status);
4000d760: 40 00 00 4c call 4000d890 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000d764: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000d768: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d76c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000d5e4 <rtems_deviceio_open>:
int oflag,
mode_t mode,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000d5e4: 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;
4000d5e8: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.mode = mode;
status = rtems_io_open( major, minor, &args );
4000d5ec: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4000d5f0: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
args.iop = iop;
4000d5f4: f0 27 bf f4 st %i0, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_open( major, minor, &args );
4000d5f8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
args.flags = iop->flags;
4000d5fc: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_open( major, minor, &args );
4000d600: 40 00 01 6c call 4000dbb0 <rtems_io_open>
<== NOT EXECUTED
4000d604: f6 27 bf fc st %i3, [ %fp + -4 ]
<== NOT EXECUTED
return rtems_status_code_to_errno( status );
4000d608: 40 00 00 a2 call 4000d890 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000d60c: 01 00 00 00 nop
<== NOT EXECUTED
}
4000d610: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d614: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000d648 <rtems_deviceio_read>:
void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000d648: 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;
4000d64c: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
args.buffer = buf;
args.count = nbyte;
args.flags = iop->flags;
4000d650: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.iop = iop;
4000d654: f0 27 bf e0 st %i0, [ %fp + -32 ]
<== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_read( major, minor, &args );
4000d658: 94 07 bf e0 add %fp, -32, %o2
<== NOT EXECUTED
args.offset = iop->offset;
4000d65c: c4 3f bf e8 std %g2, [ %fp + -24 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000d660: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = buf;
4000d664: f2 27 bf f0 st %i1, [ %fp + -16 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000d668: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
args.count = nbyte;
4000d66c: f4 27 bf f4 st %i2, [ %fp + -12 ]
<== NOT EXECUTED
{
4000d670: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
args.flags = iop->flags;
4000d674: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000d678: 40 00 01 66 call 4000dc10 <rtems_io_read>
<== NOT EXECUTED
4000d67c: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000d680: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000d684: 12 80 00 09 bne 4000d6a8 <rtems_deviceio_read+0x60>
<== NOT EXECUTED
4000d688: 01 00 00 00 nop
<== NOT EXECUTED
iop->offset += args.bytes_moved;
4000d68c: f4 1f 40 00 ldd [ %i5 ], %i2
<== NOT EXECUTED
4000d690: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000d694: 86 86 c0 18 addcc %i3, %i0, %g3
<== NOT EXECUTED
4000d698: 84 46 a0 00 addx %i2, 0, %g2
<== NOT EXECUTED
4000d69c: c4 3f 40 00 std %g2, [ %i5 ]
<== NOT EXECUTED
return (ssize_t) args.bytes_moved;
4000d6a0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d6a4: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno( status );
4000d6a8: 40 00 00 7a call 4000d890 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000d6ac: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000d6b0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d6b4: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000d6b8 <rtems_deviceio_write>:
const void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000d6b8: 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;
4000d6bc: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
args.buffer = RTEMS_DECONST( void *, buf );
args.count = nbyte;
args.flags = iop->flags;
4000d6c0: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.iop = iop;
4000d6c4: f0 27 bf e0 st %i0, [ %fp + -32 ]
<== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_write( major, minor, &args );
4000d6c8: 94 07 bf e0 add %fp, -32, %o2
<== NOT EXECUTED
args.offset = iop->offset;
4000d6cc: c4 3f bf e8 std %g2, [ %fp + -24 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000d6d0: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = RTEMS_DECONST( void *, buf );
4000d6d4: f2 27 bf f0 st %i1, [ %fp + -16 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000d6d8: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
args.count = nbyte;
4000d6dc: f4 27 bf f4 st %i2, [ %fp + -12 ]
<== NOT EXECUTED
{
4000d6e0: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
args.flags = iop->flags;
4000d6e4: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000d6e8: 40 00 01 62 call 4000dc70 <rtems_io_write>
<== NOT EXECUTED
4000d6ec: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000d6f0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000d6f4: 12 80 00 09 bne 4000d718 <rtems_deviceio_write+0x60>
<== NOT EXECUTED
4000d6f8: 01 00 00 00 nop
<== NOT EXECUTED
iop->offset += args.bytes_moved;
4000d6fc: f4 1f 40 00 ldd [ %i5 ], %i2
<== NOT EXECUTED
4000d700: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000d704: 86 86 c0 18 addcc %i3, %i0, %g3
<== NOT EXECUTED
4000d708: 84 46 a0 00 addx %i2, 0, %g2
<== NOT EXECUTED
4000d70c: c4 3f 40 00 std %g2, [ %i5 ]
<== NOT EXECUTED
return (ssize_t) args.bytes_moved;
4000d710: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d714: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno( status );
4000d718: 40 00 00 5e call 4000d890 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000d71c: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000d720: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d724: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
40005bf4 <rtems_filesystem_check_access>:
int flags,
mode_t object_mode,
uid_t object_uid,
gid_t object_gid
)
{
40005bf4: 9d e3 bf a0 save %sp, -96, %sp
const rtems_user_env_t *uenv = rtems_current_user_env_get();
40005bf8: 7f ff ff dc call 40005b68 <rtems_current_user_env_get>
40005bfc: 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) {
40005c00: c2 12 20 10 lduh [ %o0 + 0x10 ], %g1
40005c04: 80 a0 60 00 cmp %g1, 0
40005c08: 02 80 00 24 be 40005c98 <rtems_filesystem_check_access+0xa4>
<== ALWAYS TAKEN
40005c0c: 80 a0 40 1a cmp %g1, %i2
40005c10: 22 80 00 23 be,a 40005c9c <rtems_filesystem_check_access+0xa8>
<== NOT EXECUTED
40005c14: 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
40005c18: c2 12 20 12 lduh [ %o0 + 0x12 ], %g1
<== NOT EXECUTED
if (
40005c1c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40005c20: 02 80 00 18 be 40005c80 <rtems_filesystem_check_access+0x8c>
<== NOT EXECUTED
40005c24: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
40005c28: 22 80 00 17 be,a 40005c84 <rtems_filesystem_check_access+0x90>
<== NOT EXECUTED
40005c2c: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
40005c30: c6 02 20 24 ld [ %o0 + 0x24 ], %g3
<== NOT EXECUTED
40005c34: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40005c38: 22 80 00 14 be,a 40005c88 <rtems_filesystem_check_access+0x94>
<== NOT EXECUTED
40005c3c: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
if (uenv->groups[i] == object_gid) {
40005c40: c2 12 20 28 lduh [ %o0 + 0x28 ], %g1
<== NOT EXECUTED
40005c44: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
40005c48: 02 80 00 0e be 40005c80 <rtems_filesystem_check_access+0x8c>
<== NOT EXECUTED
40005c4c: 90 02 20 2a add %o0, 0x2a, %o0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
40005c50: 10 80 00 06 b 40005c68 <rtems_filesystem_check_access+0x74>
<== NOT EXECUTED
40005c54: 82 10 20 00 clr %g1
<== NOT EXECUTED
if (uenv->groups[i] == object_gid) {
40005c58: c4 12 3f fe lduh [ %o0 + -2 ], %g2
<== NOT EXECUTED
40005c5c: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
40005c60: 22 80 00 09 be,a 40005c84 <rtems_filesystem_check_access+0x90>
<== NOT EXECUTED
40005c64: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
40005c68: 82 00 60 01 inc %g1
<== NOT EXECUTED
40005c6c: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40005c70: 12 bf ff fa bne 40005c58 <rtems_filesystem_check_access+0x64>
<== NOT EXECUTED
40005c74: 90 02 20 02 add %o0, 2, %o0
<== NOT EXECUTED
} else {
access_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (access_flags & object_mode) == access_flags;
40005c78: 10 80 00 04 b 40005c88 <rtems_filesystem_check_access+0x94>
<== NOT EXECUTED
40005c7c: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
access_flags <<= RTEMS_FS_GRP_SHIFT;
40005c80: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
return (access_flags & object_mode) == access_flags;
40005c84: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
}
40005c88: 80 a0 00 18 cmp %g0, %i0
<== NOT EXECUTED
40005c8c: b0 60 3f ff subx %g0, -1, %i0
<== NOT EXECUTED
40005c90: 81 c7 e0 08 ret
<== NOT EXECUTED
40005c94: 81 e8 00 00 restore
<== NOT EXECUTED
access_flags <<= RTEMS_FS_USR_SHIFT;
40005c98: b1 2e 20 06 sll %i0, 6, %i0
return (access_flags & object_mode) == access_flags;
40005c9c: b0 2e 00 19 andn %i0, %i1, %i0
}
40005ca0: 80 a0 00 18 cmp %g0, %i0
40005ca4: b0 60 3f ff subx %g0, -1, %i0
40005ca8: 81 c7 e0 08 ret
40005cac: 81 e8 00 00 restore
400197f8 <rtems_filesystem_default_pathconf>:
400197f8: 00 00 00 05 00 00 00 80 00 00 00 07 00 00 00 ff ................
40019808: 00 00 00 ff 00 00 04 00 00 00 00 00 00 00 00 00 ................
40019818: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
40019828: 2e 00 00 00 00 00 00 00 2e 2e 00 00 ............
40006458 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40006458: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_lock();
4000645c: 7f ff fa fd call 40005050 <rtems_libio_lock>
<== NOT EXECUTED
40006460: 01 00 00 00 nop
<== NOT EXECUTED
next = the_node->next;
40006464: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
previous = the_node->previous;
40006468: c2 06 20 04 ld [ %i0 + 4 ], %g1
<== NOT EXECUTED
next->previous = previous;
4000646c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
rtems_libio_unlock();
40006470: 7f ff fa fd call 40005064 <rtems_libio_unlock>
<== NOT EXECUTED
40006474: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
release_with_count(global_loc, 1);
40006478: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
<== NOT EXECUTED
4000647c: 40 00 00 14 call 400064cc <release_with_count>
<== NOT EXECUTED
40006480: 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);
40006484: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
40006488: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
<== NOT EXECUTED
4000648c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40006490: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (mt_entry->unmount_task != 0) {
40006494: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
<== NOT EXECUTED
40006498: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000649c: 02 80 00 07 be 400064b8 <rtems_filesystem_do_unmount+0x60>
<== NOT EXECUTED
400064a0: 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 );
400064a4: 40 00 02 35 call 40006d78 <rtems_event_system_send>
<== NOT EXECUTED
400064a8: 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) {
400064ac: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400064b0: 32 80 00 04 bne,a 400064c0 <rtems_filesystem_do_unmount+0x68>
<== NOT EXECUTED
400064b4: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
<== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
400064b8: 7f ff fa 72 call 40004e80 <free>
<== NOT EXECUTED
400064bc: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
400064c0: 40 00 02 9e call 40006f38 <rtems_fatal_error_occurred>
<== NOT EXECUTED
400064c4: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
400064c8: 01 00 00 00 nop
<== NOT EXECUTED
40005cb0 <rtems_filesystem_eval_path_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
40005cb0: 9d e3 bf a0 save %sp, -96, %sp
bool access_ok = rtems_filesystem_check_access(
40005cb4: 96 10 00 1c mov %i4, %o3
40005cb8: 94 10 00 1b mov %i3, %o2
40005cbc: 92 10 00 1a mov %i2, %o1
40005cc0: 7f ff ff cd call 40005bf4 <rtems_filesystem_check_access>
40005cc4: 90 10 00 19 mov %i1, %o0
node_mode,
node_uid,
node_gid
);
if (!access_ok) {
40005cc8: ba 92 20 00 orcc %o0, 0, %i5
40005ccc: 12 80 00 04 bne 40005cdc <rtems_filesystem_eval_path_check_access+0x2c>
<== ALWAYS TAKEN
40005cd0: 92 10 20 0d mov 0xd, %o1
rtems_filesystem_eval_path_error(ctx, EACCES);
40005cd4: 40 00 00 98 call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005cd8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
return access_ok;
}
40005cdc: 81 c7 e0 08 ret
40005ce0: 91 e8 00 1d restore %g0, %i5, %o0
40006054 <rtems_filesystem_eval_path_continue>:
{
40006054: 9d e3 bf a0 save %sp, -96, %sp
while (ctx->pathlen > 0) {
40006058: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000605c: 80 a0 60 00 cmp %g1, 0
40006060: 22 80 00 0c be,a 40006090 <rtems_filesystem_eval_path_continue+0x3c>
<== NEVER TAKEN
40006064: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
40006068: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
4000606c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40006070: c2 00 60 08 ld [ %g1 + 8 ], %g1
40006074: 9f c0 40 00 call %g1
40006078: 90 10 00 18 mov %i0, %o0
while (ctx->pathlen > 0) {
4000607c: c2 06 20 04 ld [ %i0 + 4 ], %g1
40006080: 80 a0 60 00 cmp %g1, 0
40006084: 32 bf ff fa bne,a 4000606c <rtems_filesystem_eval_path_continue+0x18>
<== NEVER TAKEN
40006088: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
<== NOT EXECUTED
if (rtems_filesystem_eval_path_has_token(ctx)) {
4000608c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40006090: 80 a0 60 00 cmp %g1, 0
40006094: 02 80 00 07 be 400060b0 <rtems_filesystem_eval_path_continue+0x5c>
40006098: f2 06 20 10 ld [ %i0 + 0x10 ], %i1
if (make) {
4000609c: 80 8e 60 20 btst 0x20, %i1
400060a0: 02 80 00 08 be 400060c0 <rtems_filesystem_eval_path_continue+0x6c>
<== NEVER TAKEN
400060a4: b2 10 20 02 mov 2, %i1
check_access(ctx, ctx->flags);
400060a8: 7f ff ff b9 call 40005f8c <check_access>
400060ac: 81 e8 00 00 restore
if (!exclusive) {
400060b0: 80 8e 60 40 btst 0x40, %i1
400060b4: 02 bf ff fd be 400060a8 <rtems_filesystem_eval_path_continue+0x54>
<== ALWAYS TAKEN
400060b8: 01 00 00 00 nop
rtems_filesystem_eval_path_error(ctx, EEXIST);
400060bc: b2 10 20 11 mov 0x11, %i1 ! 11 <_TLS_Alignment+0x10>
<== NOT EXECUTED
400060c0: 7f ff ff 9d call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
400060c4: 81 e8 00 00 restore
<== NOT EXECUTED
400068d0 <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;
400068d0: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
const char *end = current + ctx->pathlen;
400068d4: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
400068d8: 86 00 40 02 add %g1, %g2, %g3
<== NOT EXECUTED
while (current != end && rtems_filesystem_is_delimiter(*current)) {
400068dc: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
400068e0: 22 80 00 17 be,a 4000693c <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
400068e4: 84 10 20 00 clr %g2
<== NOT EXECUTED
return c == '/' || c == '\\';
400068e8: c8 48 40 00 ldsb [ %g1 ], %g4
<== NOT EXECUTED
400068ec: 80 a1 20 2f cmp %g4, 0x2f
<== NOT EXECUTED
400068f0: 02 80 00 04 be 40006900 <rtems_filesystem_eval_path_eat_delimiter+0x30>
<== NOT EXECUTED
400068f4: 80 a1 20 5c cmp %g4, 0x5c
<== NOT EXECUTED
400068f8: 32 80 00 11 bne,a 4000693c <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
400068fc: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
++current;
40006900: 82 00 60 01 inc %g1
<== NOT EXECUTED
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006904: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
40006908: 02 80 00 0d be 4000693c <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
4000690c: 84 10 20 00 clr %g2
<== NOT EXECUTED
40006910: c4 48 40 00 ldsb [ %g1 ], %g2
<== NOT EXECUTED
40006914: 80 a0 a0 2f cmp %g2, 0x2f
<== NOT EXECUTED
40006918: 02 bf ff fa be 40006900 <rtems_filesystem_eval_path_eat_delimiter+0x30>
<== NOT EXECUTED
4000691c: 80 a0 a0 5c cmp %g2, 0x5c
<== NOT EXECUTED
40006920: 22 bf ff f9 be,a 40006904 <rtems_filesystem_eval_path_eat_delimiter+0x34>
<== NOT EXECUTED
40006924: 82 00 60 01 inc %g1
<== NOT EXECUTED
40006928: 84 20 c0 01 sub %g3, %g1, %g2
<== NOT EXECUTED
++current;
4000692c: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
40006930: c4 22 20 04 st %g2, [ %o0 + 4 ]
<== NOT EXECUTED
}
40006934: 81 c3 e0 08 retl
<== NOT EXECUTED
40006938: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
ctx->path = current;
4000693c: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
}
40006940: 81 c3 e0 08 retl
<== NOT EXECUTED
40006944: c4 22 20 04 st %g2, [ %o0 + 4 ]
<== NOT EXECUTED
40005f34 <rtems_filesystem_eval_path_error>:
{
40005f34: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
ctx->path = NULL;
40005f38: c0 26 00 00 clr [ %i0 ]
<== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
40005f3c: 03 10 00 66 sethi %hi(0x40019800), %g1
<== NOT EXECUTED
ctx->pathlen = 0;
40005f40: c0 26 20 04 clr [ %i0 + 4 ]
<== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
40005f44: 82 10 60 80 or %g1, 0x80, %g1
<== NOT EXECUTED
ctx->token = NULL;
40005f48: c0 26 20 08 clr [ %i0 + 8 ]
<== NOT EXECUTED
ctx->tokenlen = 0;
40005f4c: c0 26 20 0c clr [ %i0 + 0xc ]
<== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
40005f50: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
<== NOT EXECUTED
40005f54: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
40005f58: 02 80 00 0b be 40005f84 <rtems_filesystem_eval_path_error+0x50>
<== NOT EXECUTED
40005f5c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
if (eno != 0) {
40005f60: 12 80 00 04 bne 40005f70 <rtems_filesystem_eval_path_error+0x3c>
<== NOT EXECUTED
40005f64: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_detach(&ctx->currentloc);
40005f68: 40 00 01 23 call 400063f4 <rtems_filesystem_location_detach>
<== NOT EXECUTED
40005f6c: 91 ee 20 18 restore %i0, 0x18, %o0
<== NOT EXECUTED
errno = eno;
40005f70: 40 00 22 f7 call 4000eb4c <__errno>
<== NOT EXECUTED
40005f74: b0 06 20 18 add %i0, 0x18, %i0
<== NOT EXECUTED
40005f78: f2 22 00 00 st %i1, [ %o0 ]
<== NOT EXECUTED
rtems_filesystem_location_detach(&ctx->currentloc);
40005f7c: 40 00 01 1e call 400063f4 <rtems_filesystem_location_detach>
<== NOT EXECUTED
40005f80: 81 e8 00 00 restore
<== NOT EXECUTED
}
40005f84: 81 c7 e0 08 ret
<== NOT EXECUTED
40005f88: 81 e8 00 00 restore
<== NOT EXECUTED
40005ce4 <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
)
{
40005ce4: 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);
40005ce8: 21 10 00 66 sethi %hi(0x40019800), %l0
{
40005cec: ba 10 00 18 mov %i0, %i5
return &ctx->currentloc;
40005cf0: a2 06 20 18 add %i0, 0x18, %l1
status = (*config->eval_token)(ctx, arg, "..", 2);
40005cf4: a0 14 20 30 or %l0, 0x30, %l0
status = (*config->eval_token)(ctx, arg, ".", 1);
40005cf8: 31 10 00 66 sethi %hi(0x40019800), %i0
40005cfc: b0 16 20 28 or %i0, 0x28, %i0 ! 40019828 <rtems_filesystem_default_pathconf+0x30>
rtems_filesystem_eval_path_next_token(ctx);
40005d00: 40 00 03 12 call 40006948 <rtems_filesystem_eval_path_next_token>
40005d04: 90 10 00 1d mov %i5, %o0
*tokenlen = ctx->tokenlen;
40005d08: f8 07 60 0c ld [ %i5 + 0xc ], %i4
if (tokenlen > 0) {
40005d0c: 80 a7 20 00 cmp %i4, 0
40005d10: 02 80 00 19 be 40005d74 <rtems_filesystem_eval_path_generic+0x90>
<== NEVER TAKEN
40005d14: f6 07 60 08 ld [ %i5 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
40005d18: c2 06 80 00 ld [ %i2 ], %g1
40005d1c: 92 10 00 19 mov %i1, %o1
40005d20: 9f c0 40 00 call %g1
40005d24: 90 10 00 1d mov %i5, %o0
40005d28: 80 a2 20 00 cmp %o0, 0
40005d2c: 02 80 00 60 be 40005eac <rtems_filesystem_eval_path_generic+0x1c8>
<== NEVER TAKEN
40005d30: 80 a7 20 01 cmp %i4, 1
return tokenlen == 1 && token [0] == '.';
40005d34: 02 80 00 12 be 40005d7c <rtems_filesystem_eval_path_generic+0x98>
<== NEVER TAKEN
40005d38: 80 a7 20 02 cmp %i4, 2
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
40005d3c: 22 80 00 33 be,a 40005e08 <rtems_filesystem_eval_path_generic+0x124>
<== NEVER TAKEN
40005d40: c2 4e c0 00 ldsb [ %i3 ], %g1
<== NOT EXECUTED
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
40005d44: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40005d48: 96 10 00 1c mov %i4, %o3
40005d4c: 94 10 00 1b mov %i3, %o2
40005d50: 92 10 00 19 mov %i1, %o1
40005d54: 9f c0 40 00 call %g1
40005d58: 90 10 00 1d mov %i5, %o0
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
40005d5c: 80 a2 20 02 cmp %o0, 2
40005d60: 22 80 00 19 be,a 40005dc4 <rtems_filesystem_eval_path_generic+0xe0>
40005d64: c2 07 60 04 ld [ %i5 + 4 ], %g1
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
40005d68: 80 a2 20 00 cmp %o0, 0
40005d6c: 02 bf ff e5 be 40005d00 <rtems_filesystem_eval_path_generic+0x1c>
40005d70: 01 00 00 00 nop
40005d74: 81 c7 e0 08 ret
40005d78: 81 e8 00 00 restore
return tokenlen == 1 && token [0] == '.';
40005d7c: c2 4e c0 00 ldsb [ %i3 ], %g1
<== NOT EXECUTED
40005d80: 80 a0 60 2e cmp %g1, 0x2e
<== NOT EXECUTED
40005d84: 32 bf ff f1 bne,a 40005d48 <rtems_filesystem_eval_path_generic+0x64>
<== NOT EXECUTED
40005d88: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
if (rtems_filesystem_eval_path_has_path(ctx)) {
40005d8c: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40005d90: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40005d94: 22 80 00 40 be,a 40005e94 <rtems_filesystem_eval_path_generic+0x1b0>
<== NOT EXECUTED
40005d98: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
status = (*config->eval_token)(ctx, arg, ".", 1);
40005d9c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
40005da0: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
40005da4: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40005da8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40005dac: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005db0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
40005db4: 80 a2 20 02 cmp %o0, 2
<== NOT EXECUTED
40005db8: 12 bf ff ed bne 40005d6c <rtems_filesystem_eval_path_generic+0x88>
<== NOT EXECUTED
40005dbc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
if (rtems_filesystem_eval_path_has_path(ctx)) {
40005dc0: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40005dc4: 80 a0 60 00 cmp %g1, 0
40005dc8: 12 80 00 04 bne 40005dd8 <rtems_filesystem_eval_path_generic+0xf4>
<== NEVER TAKEN
40005dcc: 01 00 00 00 nop
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
40005dd0: 81 c7 e0 08 ret
40005dd4: 81 e8 00 00 restore
rtems_filesystem_eval_path_eat_delimiter(ctx);
40005dd8: 40 00 02 be call 400068d0 <rtems_filesystem_eval_path_eat_delimiter>
<== NOT EXECUTED
40005ddc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
40005de0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
if (
40005de4: 80 88 60 80 btst 0x80, %g1
<== NOT EXECUTED
40005de8: 02 80 00 06 be 40005e00 <rtems_filesystem_eval_path_generic+0x11c>
<== NOT EXECUTED
40005dec: b2 10 20 02 mov 2, %i1
<== NOT EXECUTED
|| rtems_filesystem_eval_path_has_path(ctx)
40005df0: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40005df4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40005df8: 02 bf ff f6 be 40005dd0 <rtems_filesystem_eval_path_generic+0xec>
<== NOT EXECUTED
40005dfc: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOENT);
40005e00: 40 00 00 4d call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005e04: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
40005e08: 80 a0 60 2e cmp %g1, 0x2e
<== NOT EXECUTED
40005e0c: 32 bf ff cf bne,a 40005d48 <rtems_filesystem_eval_path_generic+0x64>
<== NOT EXECUTED
40005e10: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
40005e14: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
<== NOT EXECUTED
40005e18: 80 a0 60 2e cmp %g1, 0x2e
<== NOT EXECUTED
40005e1c: 32 bf ff cb bne,a 40005d48 <rtems_filesystem_eval_path_generic+0x64>
<== NOT EXECUTED
40005e20: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40005e24: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40005e28: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
<== NOT EXECUTED
40005e2c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
40005e30: c6 02 60 14 ld [ %o1 + 0x14 ], %g3
<== NOT EXECUTED
40005e34: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40005e38: 12 80 00 0a bne 40005e60 <rtems_filesystem_eval_path_generic+0x17c>
<== NOT EXECUTED
40005e3c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
40005e40: 9f c0 80 00 call %g2
<== NOT EXECUTED
40005e44: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
40005e48: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005e4c: 32 bf ff d5 bne,a 40005da0 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
40005e50: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
40005e54: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40005e58: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40005e5c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
40005e60: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
<== NOT EXECUTED
40005e64: 9f c0 80 00 call %g2
<== NOT EXECUTED
40005e68: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
} else if (is_fs_root(currentloc)) {
40005e6c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005e70: 12 80 00 12 bne 40005eb8 <rtems_filesystem_eval_path_generic+0x1d4>
<== NOT EXECUTED
40005e74: 96 10 20 02 mov 2, %o3
<== NOT EXECUTED
status = (*config->eval_token)(ctx, arg, "..", 2);
40005e78: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
40005e7c: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
40005e80: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40005e84: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005e88: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
40005e8c: 10 bf ff b5 b 40005d60 <rtems_filesystem_eval_path_generic+0x7c>
<== NOT EXECUTED
40005e90: 80 a2 20 02 cmp %o0, 2
<== NOT EXECUTED
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
40005e94: 80 88 61 00 btst 0x100, %g1
<== NOT EXECUTED
40005e98: 22 bf ff c2 be,a 40005da0 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
40005e9c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, EINVAL);
40005ea0: b2 10 20 16 mov 0x16, %i1
<== NOT EXECUTED
40005ea4: 40 00 00 24 call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005ea8: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
40005eac: b2 10 20 14 mov 0x14, %i1
<== NOT EXECUTED
40005eb0: 40 00 00 21 call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005eb4: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
if (currentloc->mt_entry->mt_point_node != NULL) {
40005eb8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40005ebc: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
<== NOT EXECUTED
40005ec0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40005ec4: 22 bf ff b7 be,a 40005da0 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
40005ec8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
size_t tokenlen = ctx->tokenlen;
40005ecc: c8 07 60 0c ld [ %i5 + 0xc ], %g4
<== NOT EXECUTED
ctx->path -= tokenlen;
40005ed0: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
ctx->pathlen += tokenlen;
40005ed4: c4 07 60 04 ld [ %i5 + 4 ], %g2
<== NOT EXECUTED
ctx->path -= tokenlen;
40005ed8: 86 20 c0 04 sub %g3, %g4, %g3
<== NOT EXECUTED
ctx->pathlen += tokenlen;
40005edc: 84 00 80 04 add %g2, %g4, %g2
<== NOT EXECUTED
ctx->path -= tokenlen;
40005ee0: c6 27 40 00 st %g3, [ %i5 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_restart(
40005ee4: b2 00 60 20 add %g1, 0x20, %i1
<== NOT EXECUTED
ctx->pathlen += tokenlen;
40005ee8: c4 27 60 04 st %g2, [ %i5 + 4 ]
<== NOT EXECUTED
ctx->tokenlen = 0;
40005eec: c0 27 60 0c clr [ %i5 + 0xc ]
<== NOT EXECUTED
40005ef0: 40 00 00 e7 call 4000628c <rtems_filesystem_eval_path_restart>
<== NOT EXECUTED
40005ef4: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40006948 <rtems_filesystem_eval_path_next_token>:
const char *current = ctx->path;
40006948: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
4000694c: c6 02 20 04 ld [ %o0 + 4 ], %g3
40006950: 86 00 40 03 add %g1, %g3, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006954: 80 a0 40 03 cmp %g1, %g3
40006958: 32 80 00 09 bne,a 4000697c <rtems_filesystem_eval_path_next_token+0x34>
<== ALWAYS TAKEN
4000695c: c4 48 40 00 ldsb [ %g1 ], %g2
40006960: 10 80 00 20 b 400069e0 <rtems_filesystem_eval_path_next_token+0x98>
<== NOT EXECUTED
40006964: 9a 10 20 00 clr %o5
<== NOT EXECUTED
++current;
40006968: 82 00 60 01 inc %g1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000696c: 80 a0 c0 01 cmp %g3, %g1
40006970: 22 80 00 22 be,a 400069f8 <rtems_filesystem_eval_path_next_token+0xb0>
<== NEVER TAKEN
40006974: 82 10 00 03 mov %g3, %g1
<== NOT EXECUTED
40006978: c4 48 40 00 ldsb [ %g1 ], %g2
4000697c: 80 a0 a0 2f cmp %g2, 0x2f
40006980: 02 bf ff fa be 40006968 <rtems_filesystem_eval_path_next_token+0x20>
40006984: 80 a0 a0 5c cmp %g2, 0x5c
40006988: 22 bf ff f9 be,a 4000696c <rtems_filesystem_eval_path_next_token+0x24>
<== NEVER TAKEN
4000698c: 82 00 60 01 inc %g1
<== NOT EXECUTED
ctx->path = current;
40006990: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
40006994: 9a 20 c0 01 sub %g3, %g1, %o5
40006998: da 22 20 04 st %o5, [ %o0 + 4 ]
4000699c: 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)) {
400069a0: 80 a0 a0 5c cmp %g2, 0x5c
400069a4: 02 80 00 1f be 40006a20 <rtems_filesystem_eval_path_next_token+0xd8>
<== NEVER TAKEN
400069a8: 80 a0 a0 2f cmp %g2, 0x2f
400069ac: 02 80 00 1e be 40006a24 <rtems_filesystem_eval_path_next_token+0xdc>
<== NEVER TAKEN
400069b0: 88 10 00 0d mov %o5, %g4
400069b4: 10 80 00 07 b 400069d0 <rtems_filesystem_eval_path_next_token+0x88>
400069b8: 84 10 00 01 mov %g1, %g2
400069bc: 80 a1 20 2f cmp %g4, 0x2f
400069c0: 02 80 00 10 be 40006a00 <rtems_filesystem_eval_path_next_token+0xb8>
400069c4: 80 a1 20 5c cmp %g4, 0x5c
400069c8: 02 80 00 0f be 40006a04 <rtems_filesystem_eval_path_next_token+0xbc>
<== NEVER TAKEN
400069cc: 88 20 c0 02 sub %g3, %g2, %g4
++current;
400069d0: 84 00 a0 01 inc %g2
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
400069d4: 80 a0 80 03 cmp %g2, %g3
400069d8: 32 bf ff f9 bne,a 400069bc <rtems_filesystem_eval_path_next_token+0x74>
400069dc: c8 48 80 00 ldsb [ %g2 ], %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
400069e0: 88 10 20 00 clr %g4
}
ctx->path = current;
400069e4: c6 22 00 00 st %g3, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
400069e8: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
400069ec: 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);
}
400069f0: 81 c3 e0 08 retl
400069f4: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && rtems_filesystem_is_delimiter(*current)) {
400069f8: 10 bf ff fa b 400069e0 <rtems_filesystem_eval_path_next_token+0x98>
<== NOT EXECUTED
400069fc: 9a 10 20 00 clr %o5
<== NOT EXECUTED
40006a00: 88 20 c0 02 sub %g3, %g2, %g4
40006a04: 9a 20 80 01 sub %g2, %g1, %o5
++current;
40006a08: 86 10 00 02 mov %g2, %g3
ctx->pathlen = (size_t) (end - current);
40006a0c: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->path = current;
40006a10: c6 22 00 00 st %g3, [ %o0 ]
ctx->token = begin;
40006a14: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
40006a18: 81 c3 e0 08 retl
40006a1c: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40006a20: 88 10 00 0d mov %o5, %g4
<== NOT EXECUTED
40006a24: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
40006a28: 10 bf ff ef b 400069e4 <rtems_filesystem_eval_path_next_token+0x9c>
<== NOT EXECUTED
40006a2c: 9a 10 20 00 clr %o5
<== NOT EXECUTED
400062f0 <rtems_filesystem_eval_path_recursive>:
{
400062f0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if (pathlen > 0) {
400062f4: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
400062f8: 02 80 00 22 be 40006380 <rtems_filesystem_eval_path_recursive+0x90>
<== NOT EXECUTED
400062fc: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
40006300: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
40006304: 80 a0 60 1f cmp %g1, 0x1f
<== NOT EXECUTED
40006308: 14 80 00 20 bg 40006388 <rtems_filesystem_eval_path_recursive+0x98>
<== NOT EXECUTED
4000630c: 01 00 00 00 nop
<== NOT EXECUTED
return c == '/' || c == '\\';
40006310: c4 4e 40 00 ldsb [ %i1 ], %g2
<== NOT EXECUTED
const char *saved_path = ctx->path;
40006314: f6 06 00 00 ld [ %i0 ], %i3
<== NOT EXECUTED
if (rtems_filesystem_is_delimiter(path [0])) {
40006318: 80 a0 a0 2f cmp %g2, 0x2f
<== NOT EXECUTED
4000631c: 02 80 00 1d be 40006390 <rtems_filesystem_eval_path_recursive+0xa0>
<== NOT EXECUTED
40006320: f8 06 20 04 ld [ %i0 + 4 ], %i4
<== NOT EXECUTED
40006324: 80 a0 a0 5c cmp %g2, 0x5c
<== NOT EXECUTED
40006328: 02 80 00 1b be 40006394 <rtems_filesystem_eval_path_recursive+0xa4>
<== NOT EXECUTED
4000632c: 92 07 60 30 add %i5, 0x30, %o1
<== NOT EXECUTED
++ctx->recursionlevel;
40006330: 82 00 60 01 inc %g1
<== NOT EXECUTED
ctx->path = path;
40006334: f2 27 40 00 st %i1, [ %i5 ]
<== NOT EXECUTED
ctx->pathlen = pathlen;
40006338: f4 27 60 04 st %i2, [ %i5 + 4 ]
<== NOT EXECUTED
++ctx->recursionlevel;
4000633c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
40006340: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40006344: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40006348: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
4000634c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40006350: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
while (ctx->pathlen > 0) {
40006354: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40006358: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000635c: 32 bf ff fa bne,a 40006344 <rtems_filesystem_eval_path_recursive+0x54>
<== NOT EXECUTED
40006360: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
--ctx->recursionlevel;
40006364: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
40006368: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
ctx->path = saved_path;
4000636c: f6 27 40 00 st %i3, [ %i5 ]
<== NOT EXECUTED
--ctx->recursionlevel;
40006370: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
ctx->pathlen = saved_pathlen;
40006374: f8 27 60 04 st %i4, [ %i5 + 4 ]
<== NOT EXECUTED
}
40006378: 81 c7 e0 08 ret
<== NOT EXECUTED
4000637c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOENT);
40006380: 7f ff fe ed call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40006384: 93 e8 20 02 restore %g0, 2, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ELOOP);
40006388: 7f ff fe eb call 40005f34 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
4000638c: 93 e8 20 5c restore %g0, 0x5c, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
40006390: 92 07 60 30 add %i5, 0x30, %o1
<== NOT EXECUTED
40006394: 7f ff ff be call 4000628c <rtems_filesystem_eval_path_restart>
<== NOT EXECUTED
40006398: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000639c: 10 bf ff e5 b 40006330 <rtems_filesystem_eval_path_recursive+0x40>
<== NOT EXECUTED
400063a0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4000628c <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
)
{
4000628c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
40006290: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
free_location(&ctx->currentloc);
40006294: b0 06 20 18 add %i0, 0x18, %i0
<== NOT EXECUTED
40006298: 7f ff ff 18 call 40005ef8 <free_location>
<== NOT EXECUTED
4000629c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400062a0: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
400062a4: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
<== NOT EXECUTED
400062a8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
400062ac: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
400062b0: 9f c0 40 00 call %g1
<== NOT EXECUTED
400062b4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_instance_unlock(&ctx->startloc->location);
rtems_filesystem_global_location_assign(
400062b8: 40 00 00 b1 call 4000657c <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
400062bc: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
400062c0: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
400062c4: 40 00 01 02 call 400066cc <rtems_filesystem_global_location_assign>
<== NOT EXECUTED
400062c8: 90 07 60 34 add %i5, 0x34, %o0
<== NOT EXECUTED
400062cc: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
400062d0: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
400062d4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
400062d8: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
400062dc: 9f c0 40 00 call %g1
<== NOT EXECUTED
400062e0: 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);
400062e4: f2 07 60 34 ld [ %i5 + 0x34 ], %i1
<== NOT EXECUTED
400062e8: 40 00 1b ae call 4000d1a0 <rtems_filesystem_location_clone>
<== NOT EXECUTED
400062ec: 81 e8 00 00 restore
<== NOT EXECUTED
400060c8 <rtems_filesystem_eval_path_start_with_root_and_current>:
{
400060c8: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
400060cc: 94 10 20 30 mov 0x30, %o2
400060d0: 92 10 20 00 clr %o1
400060d4: 40 00 24 4b call 4000f200 <memset>
400060d8: 90 06 20 08 add %i0, 8, %o0
ctx->path = path;
400060dc: f2 26 00 00 st %i1, [ %i0 ]
if (ctx->pathlen > 0) {
400060e0: 80 a6 a0 00 cmp %i2, 0
ctx->pathlen = pathlen;
400060e4: f4 26 20 04 st %i2, [ %i0 + 4 ]
if (ctx->pathlen > 0) {
400060e8: 02 80 00 1d be 4000615c <rtems_filesystem_eval_path_start_with_root_and_current+0x94>
<== NEVER TAKEN
400060ec: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
400060f0: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
400060f4: 40 00 01 22 call 4000657c <rtems_filesystem_global_location_obtain>
400060f8: 90 10 00 1c mov %i4, %o0
return c == '/' || c == '\\';
400060fc: 83 2e e0 18 sll %i3, 0x18, %g1
40006100: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
40006104: 80 a0 60 2f cmp %g1, 0x2f
40006108: 02 80 00 2f be 400061c4 <rtems_filesystem_eval_path_start_with_root_and_current+0xfc>
<== ALWAYS TAKEN
4000610c: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
40006110: 80 a0 60 5c cmp %g1, 0x5c
<== NOT EXECUTED
40006114: 22 80 00 2d be,a 400061c8 <rtems_filesystem_eval_path_start_with_root_and_current+0x100>
<== NOT EXECUTED
40006118: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain(
4000611c: 40 00 01 18 call 4000657c <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40006120: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40006124: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
<== NOT EXECUTED
40006128: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
4000612c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40006130: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
40006134: 9f c0 40 00 call %g1
<== NOT EXECUTED
40006138: ba 06 20 18 add %i0, 0x18, %i5
<== NOT EXECUTED
rtems_filesystem_location_clone(
4000613c: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
<== NOT EXECUTED
40006140: 40 00 1c 18 call 4000d1a0 <rtems_filesystem_location_clone>
<== NOT EXECUTED
40006144: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_continue(ctx);
40006148: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000614c: 7f ff ff c2 call 40006054 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
40006150: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
40006154: 81 c7 e0 08 ret
<== NOT EXECUTED
40006158: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_global_location_t *global_loc = NULL;
4000615c: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
40006160: 40 00 01 07 call 4000657c <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40006164: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
40006168: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
<== NOT EXECUTED
4000616c: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
40006170: 40 00 01 03 call 4000657c <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40006174: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain_null();
40006178: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
<== NOT EXECUTED
errno = ENOENT;
4000617c: 40 00 22 74 call 4000eb4c <__errno>
<== NOT EXECUTED
40006180: ba 06 20 18 add %i0, 0x18, %i5
<== NOT EXECUTED
40006184: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
40006188: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000618c: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
<== NOT EXECUTED
40006190: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
40006194: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40006198: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4000619c: 9f c0 40 00 call %g1
<== NOT EXECUTED
400061a0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_clone(
400061a4: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
<== NOT EXECUTED
400061a8: 40 00 1b fe call 4000d1a0 <rtems_filesystem_location_clone>
<== NOT EXECUTED
400061ac: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_continue(ctx);
400061b0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400061b4: 7f ff ff a8 call 40006054 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
400061b8: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
400061bc: 81 c7 e0 08 ret
<== NOT EXECUTED
400061c0: 81 e8 00 00 restore
<== NOT EXECUTED
++ctx->path;
400061c4: c4 06 00 00 ld [ %i0 ], %g2
--ctx->pathlen;
400061c8: c2 06 20 04 ld [ %i0 + 4 ], %g1
++ctx->path;
400061cc: 84 00 a0 01 inc %g2
--ctx->pathlen;
400061d0: 82 00 7f ff add %g1, -1, %g1
++ctx->path;
400061d4: c4 26 00 00 st %g2, [ %i0 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
400061d8: 90 06 20 30 add %i0, 0x30, %o0
--ctx->pathlen;
400061dc: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
400061e0: 40 00 00 e7 call 4000657c <rtems_filesystem_global_location_obtain>
400061e4: ba 06 20 18 add %i0, 0x18, %i5
400061e8: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
400061ec: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
400061f0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400061f4: c2 00 40 00 ld [ %g1 ], %g1
400061f8: 9f c0 40 00 call %g1
400061fc: 01 00 00 00 nop
rtems_filesystem_location_clone(
40006200: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40006204: 40 00 1b e7 call 4000d1a0 <rtems_filesystem_location_clone>
40006208: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
4000620c: 90 10 00 18 mov %i0, %o0
40006210: 7f ff ff 91 call 40006054 <rtems_filesystem_eval_path_continue>
40006214: b0 10 00 1d mov %i5, %i0
}
40006218: 81 c7 e0 08 ret
4000621c: 81 e8 00 00 restore
4000d504 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000d504: 9d e3 bf 98 save %sp, -104, %sp
4000d508: 82 10 00 18 mov %i0, %g1
find_arg fa = {
4000d50c: c0 27 bf fc clr [ %fp + -4 ]
4000d510: b0 10 20 00 clr %i0
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
4000d514: 80 a0 60 00 cmp %g1, 0
4000d518: 02 80 00 07 be 4000d534 <rtems_filesystem_get_mount_handler+0x30>
<== NEVER TAKEN
4000d51c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_filesystem_iterate( find_handler, &fa );
4000d520: 92 07 bf f8 add %fp, -8, %o1
4000d524: 11 10 00 35 sethi %hi(0x4000d400), %o0
4000d528: 7f ff ff cb call 4000d454 <rtems_filesystem_iterate>
4000d52c: 90 12 20 20 or %o0, 0x20, %o0 ! 4000d420 <find_handler>
4000d530: f0 07 bf fc ld [ %fp + -4 ], %i0
}
return fa.mount_h;
}
4000d534: 81 c7 e0 08 ret
4000d538: 81 e8 00 00 restore
400066cc <rtems_filesystem_global_location_assign>:
{
400066cc: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400066d0: 91 d0 20 09 ta 9
<== NOT EXECUTED
lhs_global_loc = *lhs_global_loc_ptr;
400066d4: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
*lhs_global_loc_ptr = rhs_global_loc;
400066d8: d2 20 80 00 st %o1, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400066dc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400066e0: 01 00 00 00 nop
rtems_filesystem_global_location_release(lhs_global_loc, true);
400066e4: 92 10 20 01 mov 1, %o1 ! 1 <_TLS_Alignment>
400066e8: 82 13 c0 00 mov %o7, %g1
400066ec: 7f ff ff de call 40006664 <rtems_filesystem_global_location_release>
400066f0: 9e 10 40 00 mov %g1, %o7
4000657c <rtems_filesystem_global_location_obtain>:
{
4000657c: 9d e3 bf 98 save %sp, -104, %sp
if (deferred_released_global_locations != NULL) {
40006580: 3b 10 00 71 sethi %hi(0x4001c400), %i5
40006584: c2 07 62 ec ld [ %i5 + 0x2ec ], %g1 ! 4001c6ec <deferred_released_global_locations>
40006588: 80 a0 60 00 cmp %g1, 0
4000658c: 02 80 00 1e be 40006604 <rtems_filesystem_global_location_obtain+0x88>
40006590: 01 00 00 00 nop
40006594: ba 17 62 ec or %i5, 0x2ec, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006598: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
4000659c: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
400065a0: 80 a2 20 00 cmp %o0, 0
400065a4: 02 80 00 07 be 400065c0 <rtems_filesystem_global_location_obtain+0x44>
<== NEVER TAKEN
400065a8: 92 10 20 00 clr %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
400065ac: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
<== NOT EXECUTED
count = current->deferred_released_count;
400065b0: d2 02 20 20 ld [ %o0 + 0x20 ], %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
400065b4: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
current->deferred_released_next = NULL;
400065b8: c0 22 20 1c clr [ %o0 + 0x1c ]
<== NOT EXECUTED
current->deferred_released_count = 0;
400065bc: c0 22 20 20 clr [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400065c0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400065c4: 01 00 00 00 nop
if (current != NULL) {
400065c8: 80 a2 20 00 cmp %o0, 0
400065cc: 02 80 00 0e be 40006604 <rtems_filesystem_global_location_obtain+0x88>
<== NEVER TAKEN
400065d0: 01 00 00 00 nop
release_with_count(current, count);
400065d4: 7f ff ff be call 400064cc <release_with_count>
400065d8: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400065dc: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
400065e0: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
400065e4: 80 a2 20 00 cmp %o0, 0
400065e8: 12 bf ff f1 bne 400065ac <rtems_filesystem_global_location_obtain+0x30>
<== NEVER TAKEN
400065ec: 92 10 20 00 clr %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400065f0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400065f4: 01 00 00 00 nop
if (current != NULL) {
400065f8: 80 a2 20 00 cmp %o0, 0
400065fc: 12 bf ff f6 bne 400065d4 <rtems_filesystem_global_location_obtain+0x58>
<== NEVER TAKEN
40006600: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006604: 91 d0 20 09 ta 9
<== NOT EXECUTED
global_loc = *global_loc_ptr;
40006608: f0 06 00 00 ld [ %i0 ], %i0
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
4000660c: 80 a6 20 00 cmp %i0, 0
40006610: 02 80 00 07 be 4000662c <rtems_filesystem_global_location_obtain+0xb0>
<== NEVER TAKEN
40006614: 01 00 00 00 nop
40006618: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4000661c: c4 08 a0 28 ldub [ %g2 + 0x28 ], %g2
40006620: 80 a0 a0 00 cmp %g2, 0
40006624: 32 80 00 0a bne,a 4000664c <rtems_filesystem_global_location_obtain+0xd0>
<== ALWAYS TAKEN
40006628: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
errno = ENXIO;
4000662c: 40 00 21 48 call 4000eb4c <__errno>
<== NOT EXECUTED
40006630: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
40006634: 84 10 20 06 mov 6, %g2
<== NOT EXECUTED
40006638: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
global_loc = &rtems_filesystem_global_location_null;
4000663c: 31 10 00 6d sethi %hi(0x4001b400), %i0
<== NOT EXECUTED
40006640: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
40006644: b0 16 20 30 or %i0, 0x30, %i0
<== NOT EXECUTED
++global_loc->reference_count;
40006648: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
<== NOT EXECUTED
4000664c: 84 00 a0 01 inc %g2
<== NOT EXECUTED
40006650: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006654: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006658: 01 00 00 00 nop
}
4000665c: 81 c7 e0 08 ret
40006660: 81 e8 00 00 restore
40006664 <rtems_filesystem_global_location_release>:
if (!deferred) {
40006664: 80 a2 60 00 cmp %o1, 0
40006668: 22 80 00 16 be,a 400066c0 <rtems_filesystem_global_location_release+0x5c>
4000666c: 92 10 20 01 mov 1, %o1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006670: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (global_loc->deferred_released_count == 0) {
40006674: c6 02 20 20 ld [ %o0 + 0x20 ], %g3
40006678: 80 a0 e0 00 cmp %g3, 0
4000667c: 22 80 00 08 be,a 4000669c <rtems_filesystem_global_location_release+0x38>
40006680: 07 10 00 71 sethi %hi(0x4001c400), %g3
++global_loc->deferred_released_count;
40006684: 86 00 e0 01 inc %g3
<== NOT EXECUTED
40006688: c6 22 20 20 st %g3, [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000668c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006690: 01 00 00 00 nop
}
40006694: 81 c3 e0 08 retl
40006698: 01 00 00 00 nop
rtems_filesystem_global_location_t *head =
4000669c: c8 00 e2 ec ld [ %g3 + 0x2ec ], %g4
<== NOT EXECUTED
global_loc->deferred_released_next = head;
400066a0: c8 22 20 1c st %g4, [ %o0 + 0x1c ]
<== NOT EXECUTED
global_loc->deferred_released_count = 1;
400066a4: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
deferred_released_global_locations = global_loc;
400066a8: d0 20 e2 ec st %o0, [ %g3 + 0x2ec ]
<== NOT EXECUTED
global_loc->deferred_released_count = 1;
400066ac: c8 22 20 20 st %g4, [ %o0 + 0x20 ]
<== NOT EXECUTED
400066b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400066b4: 01 00 00 00 nop
}
400066b8: 81 c3 e0 08 retl
400066bc: 01 00 00 00 nop
release_with_count(global_loc, 1);
400066c0: 82 13 c0 00 mov %o7, %g1
400066c4: 7f ff ff 82 call 400064cc <release_with_count>
400066c8: 9e 10 40 00 mov %g1, %o7
40004d80 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40004d80: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40004d84: 05 10 00 63 sethi %hi(0x40018c00), %g2
40004d88: 82 10 a2 1c or %g2, 0x21c, %g1 ! 40018e1c <rtems_filesystem_root_configuration>
40004d8c: d0 00 a2 1c ld [ %g2 + 0x21c ], %o0
40004d90: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
40004d94: d6 00 60 0c ld [ %g1 + 0xc ], %o3
40004d98: d4 00 60 08 ld [ %g1 + 8 ], %o2
40004d9c: 40 00 01 a4 call 4000542c <mount>
40004da0: d2 00 60 04 ld [ %g1 + 4 ], %o1
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
40004da4: 80 a2 20 00 cmp %o0, 0
40004da8: 12 80 00 0a bne 40004dd0 <rtems_filesystem_initialize+0x50>
<== NEVER TAKEN
40004dac: 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 );
40004db0: 11 10 00 65 sethi %hi(0x40019400), %o0
40004db4: 40 00 01 56 call 4000530c <mkdir>
40004db8: 90 12 23 88 or %o0, 0x388, %o0 ! 40019788 <IMFS_node_control_sym_link+0x14>
if ( rv != 0 )
40004dbc: 80 a2 20 00 cmp %o0, 0
40004dc0: 12 80 00 07 bne 40004ddc <rtems_filesystem_initialize+0x5c>
<== NEVER TAKEN
40004dc4: 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.
*/
}
40004dc8: 81 c7 e0 08 ret
40004dcc: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xABCD0002 );
40004dd0: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
<== NOT EXECUTED
40004dd4: 40 00 08 59 call 40006f38 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40004dd8: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0x6b8d0002>
<== NOT EXECUTED
rtems_fatal_error_occurred( 0xABCD0003 );
40004ddc: 40 00 08 57 call 40006f38 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40004de0: 90 12 20 03 or %o0, 3, %o0
<== NOT EXECUTED
40004de4: 01 00 00 00 nop
<== NOT EXECUTED
4000d454 <rtems_filesystem_iterate>:
{
4000d454: 9d e3 bf a0 save %sp, -96, %sp
while ( table_entry->type && !stop ) {
4000d458: 3b 10 00 63 sethi %hi(0x40018c00), %i5
4000d45c: c2 07 62 98 ld [ %i5 + 0x298 ], %g1 ! 40018e98 <rtems_filesystem_table>
4000d460: 80 a0 60 00 cmp %g1, 0
4000d464: 12 80 00 06 bne 4000d47c <rtems_filesystem_iterate+0x28>
<== ALWAYS TAKEN
4000d468: ba 17 62 98 or %i5, 0x298, %i5
4000d46c: 30 80 00 0f b,a 4000d4a8 <rtems_filesystem_iterate+0x54>
<== NOT EXECUTED
4000d470: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000d474: 32 80 00 22 bne,a 4000d4fc <rtems_filesystem_iterate+0xa8>
<== NOT EXECUTED
4000d478: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
stop = (*routine)( table_entry, routine_arg );
4000d47c: 90 10 00 1d mov %i5, %o0
4000d480: 9f c6 00 00 call %i0
4000d484: 92 10 00 19 mov %i1, %o1
++table_entry;
4000d488: ba 07 60 08 add %i5, 8, %i5
while ( table_entry->type && !stop ) {
4000d48c: c2 07 40 00 ld [ %i5 ], %g1
4000d490: 80 a0 60 00 cmp %g1, 0
4000d494: 12 bf ff f7 bne 4000d470 <rtems_filesystem_iterate+0x1c>
<== NEVER TAKEN
4000d498: b8 10 00 08 mov %o0, %i4
if ( !stop ) {
4000d49c: b8 8a 20 ff andcc %o0, 0xff, %i4
4000d4a0: 12 80 00 17 bne 4000d4fc <rtems_filesystem_iterate+0xa8>
<== ALWAYS TAKEN
4000d4a4: 01 00 00 00 nop
rtems_libio_lock();
4000d4a8: 7f ff de ea call 40005050 <rtems_libio_lock>
<== NOT EXECUTED
4000d4ac: 37 10 00 6d sethi %hi(0x4001b400), %i3
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000d4b0: fa 06 e1 f8 ld [ %i3 + 0x1f8 ], %i5 ! 4001b5f8 <filesystem_chain>
<== NOT EXECUTED
4000d4b4: b6 16 e1 f8 or %i3, 0x1f8, %i3
<== NOT EXECUTED
for (
4000d4b8: b6 06 e0 04 add %i3, 4, %i3
<== NOT EXECUTED
4000d4bc: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
4000d4c0: 12 80 00 06 bne 4000d4d8 <rtems_filesystem_iterate+0x84>
<== NOT EXECUTED
4000d4c4: b8 10 20 00 clr %i4
<== NOT EXECUTED
4000d4c8: 30 80 00 0b b,a 4000d4f4 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
!rtems_chain_is_tail( chain, node ) && !stop;
4000d4cc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000d4d0: 12 80 00 09 bne 4000d4f4 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
4000d4d4: 01 00 00 00 nop
<== NOT EXECUTED
stop = (*routine)( &fsn->entry, routine_arg );
4000d4d8: 90 07 60 08 add %i5, 8, %o0
<== NOT EXECUTED
4000d4dc: 9f c6 00 00 call %i0
<== NOT EXECUTED
4000d4e0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000d4e4: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
for (
4000d4e8: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
4000d4ec: 12 bf ff f8 bne 4000d4cc <rtems_filesystem_iterate+0x78>
<== NOT EXECUTED
4000d4f0: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rtems_libio_unlock();
4000d4f4: 7f ff de dc call 40005064 <rtems_libio_unlock>
<== NOT EXECUTED
4000d4f8: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
}
4000d4fc: 81 c7 e0 08 ret
4000d500: 91 e8 00 1c restore %g0, %i4, %o0
4000d1a0 <rtems_filesystem_location_clone>:
void rtems_filesystem_location_clone(
rtems_filesystem_location_info_t *clone,
const rtems_filesystem_location_info_t *master
)
{
4000d1a0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
clone = rtems_filesystem_location_copy( clone, master );
4000d1a4: 92 10 00 19 mov %i1, %o1
4000d1a8: 7f ff e4 7f call 400063a4 <rtems_filesystem_location_copy>
4000d1ac: 90 10 00 18 mov %i0, %o0
rv = (*clone->mt_entry->ops->clonenod_h)( clone );
4000d1b0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000d1b4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000d1b8: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
4000d1bc: 9f c0 40 00 call %g1
4000d1c0: ba 10 00 08 mov %o0, %i5
if ( rv != 0 ) {
4000d1c4: 80 a2 20 00 cmp %o0, 0
4000d1c8: 12 80 00 04 bne 4000d1d8 <rtems_filesystem_location_clone+0x38>
<== NEVER TAKEN
4000d1cc: 90 10 00 1d mov %i5, %o0
rtems_filesystem_location_remove_from_mt_entry( clone );
rtems_filesystem_location_initialize_to_null( clone );
}
}
4000d1d0: 81 c7 e0 08 ret
4000d1d4: 81 e8 00 00 restore
return rtems_filesystem_location_copy(
4000d1d8: 33 10 00 6d sethi %hi(0x4001b400), %i1
<== NOT EXECUTED
rtems_filesystem_location_remove_from_mt_entry( clone );
4000d1dc: 7f ff e5 46 call 400066f4 <rtems_filesystem_location_remove_from_mt_entry>
<== NOT EXECUTED
4000d1e0: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
4000d1e4: 7f ff e4 70 call 400063a4 <rtems_filesystem_location_copy>
<== NOT EXECUTED
4000d1e8: 93 ee 60 30 restore %i1, 0x30, %o1
<== NOT EXECUTED
400063a4 <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;
400063a4: da 02 60 08 ld [ %o1 + 8 ], %o5
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
400063a8: c8 02 60 0c ld [ %o1 + 0xc ], %g4
<== NOT EXECUTED
dst->handlers = src->handlers;
400063ac: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
400063b0: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
<== NOT EXECUTED
400063b4: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
400063b8: da 22 20 08 st %o5, [ %o0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
400063bc: c8 22 20 0c st %g4, [ %o0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
400063c0: c6 22 20 10 st %g3, [ %o0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400063c4: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
400063c8: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
<== NOT EXECUTED
old_last = tail->previous;
400063cc: c8 00 e0 1c ld [ %g3 + 0x1c ], %g4
<== NOT EXECUTED
return &the_chain->Tail.Node;
400063d0: 9a 00 e0 18 add %g3, 0x18, %o5
<== NOT EXECUTED
the_node->next = tail;
400063d4: da 22 00 00 st %o5, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
400063d8: d0 20 e0 1c st %o0, [ %g3 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
400063dc: d0 21 00 00 st %o0, [ %g4 ]
<== NOT EXECUTED
the_node->previous = old_last;
400063e0: c8 22 20 04 st %g4, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400063e4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400063e8: 01 00 00 00 nop
rtems_chain_initialize_node(&dst->mt_entry_node);
rtems_filesystem_location_add_to_mt_entry(dst);
return dst;
}
400063ec: 81 c3 e0 08 retl
400063f0: 01 00 00 00 nop
40006778 <rtems_filesystem_location_copy_and_detach>:
{
40006778: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
dst->node_access = src->node_access;
4000677c: c8 06 60 08 ld [ %i1 + 8 ], %g4
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40006780: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
dst->handlers = src->handlers;
40006784: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40006788: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
<== NOT EXECUTED
4000678c: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40006790: c8 26 20 08 st %g4, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40006794: c6 26 20 0c st %g3, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40006798: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000679c: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
400067a0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
400067a4: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
400067a8: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
400067ac: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
400067b0: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
400067b4: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
400067b8: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400067bc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400067c0: 01 00 00 00 nop
rtems_filesystem_location_remove_from_mt_entry(detach);
400067c4: 7f ff ff cc call 400066f4 <rtems_filesystem_location_remove_from_mt_entry>
400067c8: 90 10 00 19 mov %i1, %o0
dst->node_access = src->node_access;
400067cc: 03 10 00 6d sethi %hi(0x4001b400), %g1
<== NOT EXECUTED
400067d0: 82 10 60 30 or %g1, 0x30, %g1 ! 4001b430 <rtems_filesystem_global_location_null>
<== NOT EXECUTED
400067d4: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
400067d8: c4 26 60 08 st %g2, [ %i1 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
400067dc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
400067e0: c4 26 60 0c st %g2, [ %i1 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
400067e4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
400067e8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
400067ec: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
400067f0: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400067f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
400067f8: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
400067fc: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006800: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006804: c8 26 40 00 st %g4, [ %i1 ]
<== NOT EXECUTED
tail->previous = the_node;
40006808: f2 20 a0 1c st %i1, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
4000680c: f2 20 c0 00 st %i1, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006810: c6 26 60 04 st %g3, [ %i1 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006814: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006818: 01 00 00 00 nop
}
4000681c: 81 c7 e0 08 ret
40006820: 81 e8 00 00 restore
400063f4 <rtems_filesystem_location_detach>:
void rtems_filesystem_location_detach(
rtems_filesystem_location_info_t *detach
)
{
400063f4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_filesystem_location_free(detach);
400063f8: 40 00 1b 7d call 4000d1ec <rtems_filesystem_location_free>
<== NOT EXECUTED
400063fc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
dst->node_access = src->node_access;
40006400: 03 10 00 6d sethi %hi(0x4001b400), %g1
<== NOT EXECUTED
40006404: 82 10 60 30 or %g1, 0x30, %g1 ! 4001b430 <rtems_filesystem_global_location_null>
<== NOT EXECUTED
40006408: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
4000640c: c4 26 20 08 st %g2, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40006410: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40006414: c4 26 20 0c st %g2, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40006418: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
4000641c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
40006420: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40006424: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006428: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000642c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40006430: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006434: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006438: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
4000643c: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40006440: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006444: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006448: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000644c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_initialize_to_null(detach);
}
40006450: 81 c7 e0 08 ret
<== NOT EXECUTED
40006454: 81 e8 00 00 restore
<== NOT EXECUTED
4000d1ec <rtems_filesystem_location_free>:
#endif
#include <rtems/libio_.h>
void rtems_filesystem_location_free( rtems_filesystem_location_info_t *loc )
{
4000d1ec: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000d1f0: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
4000d1f4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4000d1f8: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4000d1fc: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000d200: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_instance_lock( loc );
(*loc->mt_entry->ops->freenod_h)( loc );
4000d204: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
4000d208: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
4000d20c: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
<== NOT EXECUTED
4000d210: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000d214: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000d218: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
4000d21c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4000d220: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4000d224: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000d228: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_instance_unlock( loc );
rtems_filesystem_location_remove_from_mt_entry( loc );
4000d22c: 7f ff e5 32 call 400066f4 <rtems_filesystem_location_remove_from_mt_entry>
<== NOT EXECUTED
4000d230: 81 e8 00 00 restore
<== NOT EXECUTED
400066f4 <rtems_filesystem_location_remove_from_mt_entry>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400066f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous = the_node->previous;
400066f8: c6 02 20 04 ld [ %o0 + 4 ], %g3
next = the_node->next;
400066fc: c8 02 00 00 ld [ %o0 ], %g4
next->previous = previous;
40006700: c6 21 20 04 st %g3, [ %g4 + 4 ]
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
40006704: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
previous->next = next;
40006708: c8 20 c0 00 st %g4, [ %g3 ]
4000670c: c6 08 a0 28 ldub [ %g2 + 0x28 ], %g3
40006710: 80 a0 e0 00 cmp %g3, 0
40006714: 12 80 00 07 bne 40006730 <rtems_filesystem_location_remove_from_mt_entry+0x3c>
<== ALWAYS TAKEN
40006718: 01 00 00 00 nop
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
4000671c: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
<== NOT EXECUTED
40006720: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
40006724: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
40006728: 22 80 00 06 be,a 40006740 <rtems_filesystem_location_remove_from_mt_entry+0x4c>
<== NOT EXECUTED
4000672c: c6 00 a0 24 ld [ %g2 + 0x24 ], %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006730: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006734: 01 00 00 00 nop
}
40006738: 81 c3 e0 08 retl
4000673c: 01 00 00 00 nop
&& mt_entry->mt_fs_root->reference_count == 1;
40006740: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3
<== NOT EXECUTED
40006744: 80 a0 e0 01 cmp %g3, 1
<== NOT EXECUTED
40006748: 12 bf ff fa bne 40006730 <rtems_filesystem_location_remove_from_mt_entry+0x3c>
<== NOT EXECUTED
4000674c: 86 00 a0 14 add %g2, 0x14, %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006750: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
head->previous = NULL;
40006754: c0 20 a0 18 clr [ %g2 + 0x18 ]
<== NOT EXECUTED
head->next = tail;
40006758: c8 20 a0 14 st %g4, [ %g2 + 0x14 ]
<== NOT EXECUTED
tail->previous = head;
4000675c: c6 20 a0 1c st %g3, [ %g2 + 0x1c ]
<== NOT EXECUTED
40006760: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006764: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
40006768: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
4000676c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40006770: 7f ff ff 3a call 40006458 <rtems_filesystem_do_unmount>
<== NOT EXECUTED
40006774: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40006824 <rtems_filesystem_location_transform_to_global>:
{
40006824: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
40006828: 7f ff fa a5 call 400052bc <malloc>
<== NOT EXECUTED
4000682c: 90 10 20 24 mov 0x24, %o0
<== NOT EXECUTED
if (global_loc != NULL) {
40006830: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
40006834: 02 80 00 1c be 400068a4 <rtems_filesystem_location_transform_to_global+0x80>
<== NOT EXECUTED
40006838: b8 10 20 01 mov 1, %i4
<== NOT EXECUTED
dst->node_access = src->node_access;
4000683c: c8 06 20 08 ld [ %i0 + 8 ], %g4
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40006840: c6 06 20 0c ld [ %i0 + 0xc ], %g3
<== NOT EXECUTED
dst->handlers = src->handlers;
40006844: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40006848: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
global_loc->deferred_released_next = NULL;
4000684c: c0 27 60 1c clr [ %i5 + 0x1c ]
<== NOT EXECUTED
global_loc->reference_count = 1;
40006850: f8 27 60 18 st %i4, [ %i5 + 0x18 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 0;
40006854: c0 27 60 20 clr [ %i5 + 0x20 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40006858: c8 27 60 08 st %g4, [ %i5 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
4000685c: c6 27 60 0c st %g3, [ %i5 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40006860: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40006864: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006868: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000686c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40006870: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006874: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006878: c8 27 40 00 st %g4, [ %i5 ]
<== NOT EXECUTED
tail->previous = the_node;
4000687c: fa 20 a0 1c st %i5, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40006880: fa 20 c0 00 st %i5, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006884: c6 27 60 04 st %g3, [ %i5 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006888: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000688c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_remove_from_mt_entry(loc);
40006890: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006894: 7f ff ff 98 call 400066f4 <rtems_filesystem_location_remove_from_mt_entry>
<== NOT EXECUTED
40006898: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4000689c: 81 c7 e0 08 ret
<== NOT EXECUTED
400068a0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_location_free(loc);
400068a4: 40 00 1a 52 call 4000d1ec <rtems_filesystem_location_free>
<== NOT EXECUTED
400068a8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
400068ac: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
400068b0: 7f ff ff 33 call 4000657c <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
400068b4: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
errno = ENOMEM;
400068b8: 40 00 20 a5 call 4000eb4c <__errno>
<== NOT EXECUTED
400068bc: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
400068c0: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
400068c4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
400068c8: 81 c7 e0 08 ret
<== NOT EXECUTED
400068cc: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40005328 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40005328: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
4000532c: 40 00 02 0f call 40005b68 <rtems_current_user_env_get>
40005330: 01 00 00 00 nop
40005334: d6 02 20 08 ld [ %o0 + 8 ], %o3
40005338: 96 2e c0 0b andn %i3, %o3, %o3
switch (mode & S_IFMT) {
4000533c: 03 00 00 3c sethi %hi(0xf000), %g1
40005340: 05 00 00 10 sethi %hi(0x4000), %g2
40005344: 82 0a c0 01 and %o3, %g1, %g1
40005348: 80 a0 40 02 cmp %g1, %g2
4000534c: 22 80 00 0c be,a 4000537c <rtems_filesystem_mknod+0x54>
<== ALWAYS TAKEN
40005350: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40005354: 08 80 00 14 bleu 400053a4 <rtems_filesystem_mknod+0x7c>
<== NOT EXECUTED
40005358: 05 00 00 04 sethi %hi(0x1000), %g2
<== NOT EXECUTED
4000535c: 05 00 00 18 sethi %hi(0x6000), %g2
<== NOT EXECUTED
40005360: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40005364: 02 80 00 05 be 40005378 <rtems_filesystem_mknod+0x50>
<== NOT EXECUTED
40005368: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
4000536c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40005370: 12 80 00 13 bne 400053bc <rtems_filesystem_mknod+0x94>
<== NOT EXECUTED
40005374: 01 00 00 00 nop
<== NOT EXECUTED
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
40005378: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
4000537c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40005380: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40005384: 98 10 00 1c mov %i4, %o4
40005388: 9a 10 00 1d mov %i5, %o5
4000538c: 94 10 00 1a mov %i2, %o2
40005390: 92 10 00 19 mov %i1, %o1
40005394: 9f c0 40 00 call %g1
40005398: 90 10 00 18 mov %i0, %o0
4000539c: 81 c7 e0 08 ret
400053a0: 91 e8 00 08 restore %g0, %o0, %o0
switch (mode & S_IFMT) {
400053a4: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
400053a8: 02 bf ff f4 be 40005378 <rtems_filesystem_mknod+0x50>
<== NOT EXECUTED
400053ac: 05 00 00 08 sethi %hi(0x2000), %g2
<== NOT EXECUTED
400053b0: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
400053b4: 22 bf ff f2 be,a 4000537c <rtems_filesystem_mknod+0x54>
<== NOT EXECUTED
400053b8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
errno = EINVAL;
400053bc: 40 00 25 e4 call 4000eb4c <__errno>
<== NOT EXECUTED
400053c0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400053c4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400053c8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
return rv;
}
400053cc: 81 c7 e0 08 ret
<== NOT EXECUTED
400053d0: 81 e8 00 00 restore
<== NOT EXECUTED
40019880 <rtems_filesystem_null_handlers>:
40019880: 40 00 6a 30 40 00 cb e0 40 00 ce 34 40 00 ce cc @.j0@...@..4@...
40019890: 40 00 cc 68 40 00 cd ec 40 00 6a 38 40 00 cc 4c @..h@...@.j8@..L
400198a0: 40 00 cc 0c 40 00 cc 0c 40 00 cb fc 40 00 ce 2c @...@...@...@..,
400198b0: 40 00 cc 84 40 00 ce 50 40 00 ce e8 40 00 ce 08 @...@..P@...@...
40005118 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
40005118: 9d e3 bf a0 save %sp, -96, %sp
4000511c: 03 10 00 7d sethi %hi(0x4001f400), %g1
40005120: c2 00 61 38 ld [ %g1 + 0x138 ], %g1 ! 4001f538 <_System_state_Current>
Heap_Control *heap = RTEMS_Malloc_Heap;
40005124: 05 10 00 6c sethi %hi(0x4001b000), %g2
if ( _System_state_Is_up( state ) ) {
40005128: 80 a0 60 02 cmp %g1, 2
4000512c: 02 80 00 21 be 400051b0 <rtems_heap_allocate_aligned_with_boundary+0x98>
40005130: f8 00 a3 a4 ld [ %g2 + 0x3a4 ], %i4
} else if ( _System_state_Is_before_multitasking( state ) ) {
40005134: 80 a0 60 01 cmp %g1, 1
40005138: 02 80 00 22 be 400051c0 <rtems_heap_allocate_aligned_with_boundary+0xa8>
4000513c: 96 10 00 1a mov %i2, %o3
boundary
);
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
p = _Heap_Allocate_aligned_with_boundary(
40005140: 94 10 00 19 mov %i1, %o2
40005144: 92 10 00 18 mov %i0, %o1
40005148: 40 00 08 30 call 40007208 <_Heap_Allocate_aligned_with_boundary>
4000514c: 90 10 00 1c mov %i4, %o0
40005150: 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 ) {
40005154: 80 a7 60 00 cmp %i5, 0
40005158: 12 80 00 0b bne 40005184 <rtems_heap_allocate_aligned_with_boundary+0x6c>
<== ALWAYS TAKEN
4000515c: 80 a6 60 00 cmp %i1, 0
40005160: 12 80 00 09 bne 40005184 <rtems_heap_allocate_aligned_with_boundary+0x6c>
<== NOT EXECUTED
40005164: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40005168: 12 80 00 23 bne 400051f4 <rtems_heap_allocate_aligned_with_boundary+0xdc>
<== NOT EXECUTED
4000516c: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
p = (*rtems_malloc_extend_handler)( heap, size );
40005170: c2 00 61 c4 ld [ %g1 + 0x1c4 ], %g1 ! 40018dc4 <rtems_malloc_extend_handler>
<== NOT EXECUTED
40005174: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40005178: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000517c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40005180: 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 )
40005184: 80 a7 60 00 cmp %i5, 0
40005188: 02 80 00 1b be 400051f4 <rtems_heap_allocate_aligned_with_boundary+0xdc>
<== NEVER TAKEN
4000518c: 03 10 00 6e sethi %hi(0x4001b800), %g1
40005190: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 4001b980 <rtems_malloc_dirty_helper>
40005194: 80 a0 60 00 cmp %g1, 0
40005198: 02 80 00 04 be 400051a8 <rtems_heap_allocate_aligned_with_boundary+0x90>
<== ALWAYS TAKEN
4000519c: 92 10 00 18 mov %i0, %o1
(*rtems_malloc_dirty_helper)( p, size );
400051a0: 9f c0 40 00 call %g1
<== NOT EXECUTED
400051a4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return p;
}
400051a8: 81 c7 e0 08 ret
400051ac: 91 e8 00 1d restore %g0, %i5, %o0
400051b0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
if ( _Thread_Dispatch_is_enabled() ) {
400051b4: 80 a0 60 00 cmp %g1, 0
400051b8: 32 80 00 10 bne,a 400051f8 <rtems_heap_allocate_aligned_with_boundary+0xe0>
<== NEVER TAKEN
400051bc: ba 10 20 00 clr %i5
<== NOT EXECUTED
_RTEMS_Lock_allocator();
400051c0: 40 00 07 a7 call 4000705c <_RTEMS_Lock_allocator>
400051c4: 01 00 00 00 nop
_Malloc_Process_deferred_frees();
400051c8: 7f ff ff bb call 400050b4 <_Malloc_Process_deferred_frees>
400051cc: 01 00 00 00 nop
p = _Heap_Allocate_aligned_with_boundary(
400051d0: 96 10 00 1a mov %i2, %o3
400051d4: 94 10 00 19 mov %i1, %o2
400051d8: 92 10 00 18 mov %i0, %o1
400051dc: 40 00 08 0b call 40007208 <_Heap_Allocate_aligned_with_boundary>
400051e0: 90 10 00 1c mov %i4, %o0
_RTEMS_Unlock_allocator();
400051e4: 40 00 07 a3 call 40007070 <_RTEMS_Unlock_allocator>
400051e8: ba 10 00 08 mov %o0, %i5
break;
400051ec: 10 bf ff db b 40005158 <rtems_heap_allocate_aligned_with_boundary+0x40>
400051f0: 80 a7 60 00 cmp %i5, 0
return NULL;
400051f4: ba 10 20 00 clr %i5
<== NOT EXECUTED
}
400051f8: 81 c7 e0 08 ret
<== NOT EXECUTED
400051fc: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40005bbc <rtems_heap_null_extend>:
Heap_Control *heap RTEMS_UNUSED,
size_t alloc_size RTEMS_UNUSED
)
{
return NULL;
}
40005bbc: 81 c3 e0 08 retl
<== NOT EXECUTED
40005bc0: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
4000d38c <rtems_libio_allocate>:
return fcntl_flags;
}
rtems_libio_t *rtems_libio_allocate( void )
{
4000d38c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_lock();
4000d390: 7f ff df 30 call 40005050 <rtems_libio_lock>
4000d394: 01 00 00 00 nop
iop = rtems_libio_iop_free_head;
4000d398: 03 10 00 7d sethi %hi(0x4001f400), %g1
4000d39c: f0 00 60 dc ld [ %g1 + 0xdc ], %i0 ! 4001f4dc <rtems_libio_iop_free_head>
if ( iop != NULL ) {
4000d3a0: 80 a6 20 00 cmp %i0, 0
4000d3a4: 02 80 00 06 be 4000d3bc <rtems_libio_allocate+0x30>
<== NEVER TAKEN
4000d3a8: 86 10 60 dc or %g1, 0xdc, %g3
void *next;
next = iop->data1;
4000d3ac: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
rtems_libio_iop_free_head = next;
if ( next == NULL ) {
4000d3b0: 80 a0 a0 00 cmp %g2, 0
4000d3b4: 02 80 00 06 be 4000d3cc <rtems_libio_allocate+0x40>
4000d3b8: c4 20 60 dc st %g2, [ %g1 + 0xdc ]
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
}
}
rtems_libio_unlock();
4000d3bc: 7f ff df 2a call 40005064 <rtems_libio_unlock>
4000d3c0: 01 00 00 00 nop
return iop;
}
4000d3c4: 81 c7 e0 08 ret
4000d3c8: 81 e8 00 00 restore
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
4000d3cc: 03 10 00 6c sethi %hi(0x4001b000), %g1
rtems_libio_unlock();
4000d3d0: 7f ff df 25 call 40005064 <rtems_libio_unlock>
4000d3d4: c6 20 63 b0 st %g3, [ %g1 + 0x3b0 ] ! 4001b3b0 <rtems_libio_iop_free_tail>
}
4000d3d8: 81 c7 e0 08 ret
4000d3dc: 81 e8 00 00 restore
4000d338 <rtems_libio_exit>:
#include <unistd.h>
#include <rtems/libio.h>
void rtems_libio_exit(void)
{
4000d338: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
(void)close(0);
4000d33c: 40 00 05 af call 4000e9f8 <close>
<== NOT EXECUTED
4000d340: 90 10 20 00 clr %o0
<== NOT EXECUTED
(void)close(1);
(void)close(2);
4000d344: b0 10 20 02 mov 2, %i0
<== NOT EXECUTED
(void)close(1);
4000d348: 40 00 05 ac call 4000e9f8 <close>
<== NOT EXECUTED
4000d34c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
(void)close(2);
4000d350: 40 00 05 aa call 4000e9f8 <close>
<== NOT EXECUTED
4000d354: 81 e8 00 00 restore
<== NOT EXECUTED
4000d3e0 <rtems_libio_free>:
void rtems_libio_free(
rtems_libio_t *iop
)
{
4000d3e0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_filesystem_location_free( &iop->pathinfo );
4000d3e4: 7f ff ff 82 call 4000d1ec <rtems_filesystem_location_free>
<== NOT EXECUTED
4000d3e8: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
rtems_libio_lock();
4000d3ec: 7f ff df 19 call 40005050 <rtems_libio_lock>
<== NOT EXECUTED
4000d3f0: 01 00 00 00 nop
<== NOT EXECUTED
iop = memset( iop, 0, sizeof( *iop ) );
4000d3f4: 94 10 20 30 mov 0x30, %o2 ! 30 <_TLS_Alignment+0x2f>
<== NOT EXECUTED
4000d3f8: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000d3fc: 40 00 07 81 call 4000f200 <memset>
<== NOT EXECUTED
4000d400: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
*rtems_libio_iop_free_tail = iop;
4000d404: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
4000d408: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 4001b3b0 <rtems_libio_iop_free_tail>
<== NOT EXECUTED
4000d40c: d0 20 80 00 st %o0, [ %g2 ]
<== NOT EXECUTED
rtems_libio_iop_free_tail = &iop->data1;
4000d410: 90 02 20 28 add %o0, 0x28, %o0
<== NOT EXECUTED
4000d414: d0 20 63 b0 st %o0, [ %g1 + 0x3b0 ]
<== NOT EXECUTED
rtems_libio_unlock();
4000d418: 7f ff df 13 call 40005064 <rtems_libio_unlock>
<== NOT EXECUTED
4000d41c: 81 e8 00 00 restore
<== NOT EXECUTED
40005b94 <rtems_libio_free_user_env>:
if (!uses_global_env) {
40005b94: 03 10 00 6c sethi %hi(0x4001b000), %g1
<== NOT EXECUTED
40005b98: 82 10 63 e8 or %g1, 0x3e8, %g1 ! 4001b3e8 <rtems_global_user_env>
<== NOT EXECUTED
40005b9c: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
40005ba0: 02 80 00 05 be 40005bb4 <rtems_libio_free_user_env+0x20>
<== NOT EXECUTED
40005ba4: 01 00 00 00 nop
<== NOT EXECUTED
40005ba8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40005bac: 7f ff ff e6 call 40005b44 <rtems_libio_free_user_env.part.1>
<== NOT EXECUTED
40005bb0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
}
}
40005bb4: 81 c3 e0 08 retl
<== NOT EXECUTED
40005bb8: 01 00 00 00 nop
<== NOT EXECUTED
400057d4 <rtems_libio_post_driver>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void rtems_libio_post_driver(void)
{
400057d4: 9d e3 bf a0 save %sp, -96, %sp
/*
* Attempt to open /dev/console.
*/
if ( open( CONSOLE_DEVICE_NAME, O_RDONLY, 0 ) != STDIN_FILENO ) {
400057d8: 94 10 20 00 clr %o2
400057dc: 92 10 20 00 clr %o1
400057e0: 3b 10 00 65 sethi %hi(0x40019400), %i5
400057e4: 40 00 00 1a call 4000584c <open>
400057e8: 90 17 63 90 or %i5, 0x390, %o0 ! 40019790 <IMFS_node_control_sym_link+0x1c>
400057ec: 80 a2 20 00 cmp %o0, 0
400057f0: 02 80 00 04 be 40005800 <rtems_libio_post_driver+0x2c>
<== ALWAYS TAKEN
400057f4: 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);
}
400057f8: 81 c7 e0 08 ret
<== NOT EXECUTED
400057fc: 81 e8 00 00 restore
<== NOT EXECUTED
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDOUT_FILENO ) {
40005800: 92 10 20 01 mov 1, %o1
40005804: 40 00 00 12 call 4000584c <open>
40005808: 90 17 63 90 or %i5, 0x390, %o0
4000580c: 80 a2 20 01 cmp %o0, 1
40005810: 12 80 00 0a bne 40005838 <rtems_libio_post_driver+0x64>
<== NEVER TAKEN
40005814: 94 10 20 00 clr %o2
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
40005818: 92 10 20 01 mov 1, %o1
4000581c: 40 00 00 0c call 4000584c <open>
40005820: 90 17 63 90 or %i5, 0x390, %o0
40005824: 80 a2 20 02 cmp %o0, 2
40005828: 12 80 00 06 bne 40005840 <rtems_libio_post_driver+0x6c>
<== NEVER TAKEN
4000582c: 31 10 00 34 sethi %hi(0x4000d000), %i0
<== NOT EXECUTED
atexit(rtems_libio_exit);
40005830: 40 00 24 b6 call 4000eb08 <atexit>
<== NOT EXECUTED
40005834: 91 ee 23 38 restore %i0, 0x338, %o0
_Internal_error( INTERNAL_ERROR_LIBIO_STDOUT_FD_OPEN_FAILED );
40005838: 40 00 08 1b call 400078a4 <_Internal_error>
<== NOT EXECUTED
4000583c: 90 10 20 24 mov 0x24, %o0
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
40005840: 40 00 08 19 call 400078a4 <_Internal_error>
<== NOT EXECUTED
40005844: 90 10 20 25 mov 0x25, %o0
<== NOT EXECUTED
40005848: 01 00 00 00 nop
<== NOT EXECUTED
4000d594 <rtems_printf>:
int rtems_printf(
const rtems_printer *printer,
const char *format,
...
)
{
4000d594: 9d e3 bf 98 save %sp, -104, %sp
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
va_list ap;
va_start( ap, format );
4000d598: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
{
4000d59c: 82 10 00 18 mov %i0, %g1
va_start( ap, format );
4000d5a0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int len = 0;
4000d5a4: b0 10 20 00 clr %i0
va_start( ap, format );
4000d5a8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000d5ac: 80 a0 60 00 cmp %g1, 0
4000d5b0: 02 80 00 0b be 4000d5dc <rtems_printf+0x48>
<== NEVER TAKEN
4000d5b4: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
4000d5b8: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000d5bc: 80 a0 a0 00 cmp %g2, 0
4000d5c0: 02 80 00 07 be 4000d5dc <rtems_printf+0x48>
<== NEVER TAKEN
4000d5c4: 94 07 a0 4c add %fp, 0x4c, %o2
len = printer->printer( printer->context, format, ap );
4000d5c8: d0 00 40 00 ld [ %g1 ], %o0
4000d5cc: 92 10 00 19 mov %i1, %o1
4000d5d0: 9f c0 80 00 call %g2
4000d5d4: d4 27 bf fc st %o2, [ %fp + -4 ]
4000d5d8: b0 10 00 08 mov %o0, %i0
va_end( ap );
}
return len;
}
4000d5dc: 81 c7 e0 08 ret
4000d5e0: 81 e8 00 00 restore
4000d558 <rtems_vprintf>:
int rtems_vprintf(
const rtems_printer *printer,
const char *format,
va_list ap
)
{
4000d558: 9d e3 bf a0 save %sp, -96, %sp
4000d55c: 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;
4000d560: 80 a0 60 00 cmp %g1, 0
4000d564: 02 80 00 0a be 4000d58c <rtems_vprintf+0x34>
<== NEVER TAKEN
4000d568: b0 10 20 00 clr %i0
4000d56c: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000d570: 80 a0 a0 00 cmp %g2, 0
4000d574: 02 80 00 06 be 4000d58c <rtems_vprintf+0x34>
<== NEVER TAKEN
4000d578: 94 10 00 1a mov %i2, %o2
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
len = printer->printer( printer->context, format, ap );
4000d57c: d0 00 40 00 ld [ %g1 ], %o0
4000d580: 9f c0 80 00 call %g2
4000d584: 92 10 00 19 mov %i1, %o1
4000d588: b0 10 00 08 mov %o0, %i0
}
return len;
}
4000d58c: 81 c7 e0 08 ret
4000d590: 81 e8 00 00 restore
40018940 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
40018940: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
40018944: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40018948: 02 80 00 32 be 40018a10 <write+0xd0>
<== NOT EXECUTED
4001894c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
rtems_libio_check_count( count );
40018950: 02 80 00 22 be 400189d8 <write+0x98>
<== NOT EXECUTED
40018954: 84 10 20 00 clr %g2
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40018958: 03 10 00 63 sethi %hi(0x40018c00), %g1
<== NOT EXECUTED
4001895c: c2 00 62 a8 ld [ %g1 + 0x2a8 ], %g1 ! 40018ea8 <rtems_libio_number_iops>
<== NOT EXECUTED
40018960: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
40018964: 1a 80 00 25 bcc 400189f8 <write+0xb8>
<== NOT EXECUTED
40018968: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
4001896c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40018970: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
40018974: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40018978: b0 16 21 48 or %i0, 0x148, %i0
<== NOT EXECUTED
4001897c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018980: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40018984: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40018988: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4001898c: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018990: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018994: 01 00 00 00 nop
<== NOT EXECUTED
40018998: 84 08 a1 04 and %g2, 0x104, %g2
<== NOT EXECUTED
4001899c: 80 a0 a1 04 cmp %g2, 0x104
<== NOT EXECUTED
400189a0: 12 80 00 10 bne 400189e0 <write+0xa0>
<== NOT EXECUTED
400189a4: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
/*
* Now process the write() request.
*/
n = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
400189a8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
400189ac: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
400189b0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400189b4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400189b8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400189bc: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400189c0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
400189c4: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
400189c8: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
400189cc: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400189d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400189d4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
return n;
}
400189d8: 81 c7 e0 08 ret
<== NOT EXECUTED
400189dc: 91 e8 00 02 restore %g0, %g2, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400189e0: 91 d0 20 09 ta 9
<== NOT EXECUTED
400189e4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400189e8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400189ec: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400189f0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400189f4: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
400189f8: 7f ff d8 55 call 4000eb4c <__errno>
<== NOT EXECUTED
400189fc: 01 00 00 00 nop
<== NOT EXECUTED
40018a00: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
40018a04: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40018a08: 10 bf ff f4 b 400189d8 <write+0x98>
<== NOT EXECUTED
40018a0c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_libio_check_buffer( buffer );
40018a10: 7f ff d8 4f call 4000eb4c <__errno>
<== NOT EXECUTED
40018a14: 01 00 00 00 nop
<== NOT EXECUTED
40018a18: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40018a1c: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40018a20: 10 bf ff ee b 400189d8 <write+0x98>
<== NOT EXECUTED
40018a24: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED