RTEMS-5
Annotated Report
Fri Aug 10 14:12:06 2018
400054ac <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
400054ac: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
if ( !rtems_configuration_get_unified_work_area() ) {
400054b0: 03 10 00 4f sethi %hi(0x40013c00), %g1
400054b4: c2 08 60 95 ldub [ %g1 + 0x95 ], %g1 ! 40013c95 <Configuration+0x31>
400054b8: 80 a0 60 00 cmp %g1, 0
400054bc: 12 80 00 19 bne 40005520 <RTEMS_Malloc_Initialize+0x74>
400054c0: 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) {
400054c4: 02 80 00 19 be 40005528 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
400054c8: 03 10 00 56 sethi %hi(0x40015800), %g1
Heap_Control *heap = RTEMS_Malloc_Heap;
400054cc: f8 00 60 8c ld [ %g1 + 0x8c ], %i4 ! 4001588c <RTEMS_Malloc_Heap>
400054d0: b3 2e 60 03 sll %i1, 3, %i1
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
400054d4: 37 10 00 1e sethi %hi(0x40007800), %i3
400054d8: b2 06 00 19 add %i0, %i1, %i1
400054dc: b6 16 e3 28 or %i3, 0x328, %i3
400054e0: ba 10 00 1b mov %i3, %i5
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
400054e4: d4 06 20 04 ld [ %i0 + 4 ], %o2
400054e8: d2 06 00 00 ld [ %i0 ], %o1
400054ec: 96 10 20 08 mov 8, %o3
400054f0: 9f c7 40 00 call %i5
400054f4: 90 10 00 1c mov %i4, %o0
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
400054f8: 80 a2 20 00 cmp %o0, 0
400054fc: 32 80 00 02 bne,a 40005504 <RTEMS_Malloc_Initialize+0x58>
<== ALWAYS TAKEN
40005500: ba 10 00 1a mov %i2, %i5
40005504: b0 06 20 08 add %i0, 8, %i0
for (i = 0; i < area_count; ++i) {
40005508: 80 a6 00 19 cmp %i0, %i1
4000550c: 32 bf ff f7 bne,a 400054e8 <RTEMS_Malloc_Initialize+0x3c>
<== NEVER TAKEN
40005510: d4 06 20 04 ld [ %i0 + 4 ], %o2
<== NOT EXECUTED
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
40005514: 80 a7 40 1b cmp %i5, %i3
40005518: 02 80 00 04 be 40005528 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
4000551c: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
}
}
}
40005520: 81 c7 e0 08 ret
40005524: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
40005528: 40 00 0a 93 call 40007f74 <_Internal_error>
<== NOT EXECUTED
4000552c: 90 10 20 17 mov 0x17, %o0
<== NOT EXECUTED
40005530: 01 00 00 00 nop
<== NOT EXECUTED
40004f20 <_Console_simple_Read>:
ssize_t _Console_simple_Read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
40004f20: 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 ) {
40004f24: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40004f28: 04 80 00 0c ble 40004f58 <_Console_simple_Read+0x38>
<== NOT EXECUTED
40004f2c: ba 10 20 00 clr %i5
<== NOT EXECUTED
int c;
do {
c = getchark();
40004f30: 40 00 00 22 call 40004fb8 <getchark>
<== NOT EXECUTED
40004f34: 01 00 00 00 nop
<== NOT EXECUTED
} while (c == -1);
40004f38: 80 a2 3f ff cmp %o0, -1
<== NOT EXECUTED
40004f3c: 02 bf ff fd be 40004f30 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004f40: 01 00 00 00 nop
<== NOT EXECUTED
buf[ i ] = (char) c;
40004f44: d0 2e 40 1d stb %o0, [ %i1 + %i5 ]
<== NOT EXECUTED
for ( i = 0; i < n; ++i ) {
40004f48: ba 07 60 01 inc %i5
<== NOT EXECUTED
40004f4c: 80 a6 80 1d cmp %i2, %i5
<== NOT EXECUTED
40004f50: 12 bf ff f8 bne 40004f30 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004f54: 01 00 00 00 nop
<== NOT EXECUTED
}
return n;
}
40004f58: 81 c7 e0 08 ret
<== NOT EXECUTED
40004f5c: 91 e8 00 1a restore %g0, %i2, %o0
<== NOT EXECUTED
40005478 <_Malloc_Deferred_free>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005478: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
4000547c: 05 10 00 56 sethi %hi(0x40015800), %g2
<== NOT EXECUTED
40005480: 84 10 a0 cc or %g2, 0xcc, %g2 ! 400158cc <_Malloc_GC_list>
<== NOT EXECUTED
40005484: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
40005488: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
4000548c: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005490: d0 20 a0 08 st %o0, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
40005494: d0 20 c0 00 st %o0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005498: c6 22 20 04 st %g3, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000549c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400054a0: 01 00 00 00 nop
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 );
}
400054a4: 81 c3 e0 08 retl
400054a8: 01 00 00 00 nop
4000532c <_Malloc_Process_deferred_frees>:
return p;
}
void _Malloc_Process_deferred_frees( void )
{
4000532c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005330: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40005334: 3b 10 00 56 sethi %hi(0x40015800), %i5
40005338: d0 07 60 cc ld [ %i5 + 0xcc ], %o0 ! 400158cc <_Malloc_GC_list>
4000533c: ba 17 60 cc or %i5, 0xcc, %i5
if ( !_Chain_Is_empty(the_chain))
40005340: b8 07 60 04 add %i5, 4, %i4
40005344: 80 a2 00 1c cmp %o0, %i4
40005348: 02 80 00 0e be 40005380 <_Malloc_Process_deferred_frees+0x54>
4000534c: 01 00 00 00 nop
new_first = old_first->next;
40005350: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
head->next = new_first;
40005354: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
new_first->previous = head;
40005358: fa 20 a0 04 st %i5, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000535c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005360: 01 00 00 00 nop
/*
* If some free's have been deferred, then do them now.
*/
while ( ( to_be_freed = _Malloc_Get_deferred_free() ) != NULL ) {
free( to_be_freed );
40005364: 7f ff fe ff call 40004f60 <free>
40005368: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000536c: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40005370: d0 07 40 00 ld [ %i5 ], %o0
if ( !_Chain_Is_empty(the_chain))
40005374: 80 a2 00 1c cmp %o0, %i4
40005378: 32 bf ff f7 bne,a 40005354 <_Malloc_Process_deferred_frees+0x28>
4000537c: c4 02 00 00 ld [ %o0 ], %g2
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005380: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005384: 01 00 00 00 nop
}
}
40005388: 81 c7 e0 08 ret
4000538c: 81 e8 00 00 restore
40007bf4 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
40007bf4: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
rtems_assert_context assert_context = {
40007bf8: f0 27 bf f0 st %i0, [ %fp + -16 ]
<== NOT EXECUTED
.line = line,
.function = func,
.failed_expression = failedexpr
};
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
40007bfc: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
rtems_assert_context assert_context = {
40007c00: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
40007c04: 02 80 00 0e be 40007c3c <__assert_func+0x48>
<== NOT EXECUTED
40007c08: f4 3f bf f8 std %i2, [ %fp + -8 ]
<== NOT EXECUTED
40007c0c: 19 10 00 51 sethi %hi(0x40014400), %o4
<== NOT EXECUTED
40007c10: 98 13 21 28 or %o4, 0x128, %o4 ! 40014528 <IMFS_node_control_sym_link+0x14>
<== NOT EXECUTED
40007c14: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40007c18: 9a 10 00 1a mov %i2, %o5
<== NOT EXECUTED
40007c1c: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
40007c20: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40007c24: 11 10 00 51 sethi %hi(0x40014400), %o0
<== NOT EXECUTED
40007c28: 40 00 03 4c call 40008958 <printk>
<== NOT EXECUTED
40007c2c: 90 12 21 38 or %o0, 0x138, %o0 ! 40014538 <IMFS_node_control_sym_link+0x24>
<== NOT EXECUTED
40007c30: 92 07 bf f0 add %fp, -16, %o1
<== NOT EXECUTED
40007c34: 40 00 0d c9 call 4000b358 <_Terminate>
<== NOT EXECUTED
40007c38: 90 10 20 07 mov 7, %o0
<== NOT EXECUTED
40007c3c: 19 10 00 50 sethi %hi(0x40014000), %o4
<== NOT EXECUTED
40007c40: 98 13 23 08 or %o4, 0x308, %o4 ! 40014308 <rtems_test_name+0x100>
<== NOT EXECUTED
40007c44: 10 bf ff f4 b 40007c14 <__assert_func+0x20>
<== NOT EXECUTED
40007c48: b4 10 00 0c mov %o4, %i2
<== NOT EXECUTED
400138e4 <_exit>:
extern void FINI_SYMBOL( void );
#endif
void _exit(int status)
{
400138e4: 9d e3 bf a0 save %sp, -96, %sp
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(FINI_SYMBOL)
FINI_SYMBOL();
400138e8: 40 00 03 bc call 400147d8 <_fini>
400138ec: 01 00 00 00 nop
#endif
rtems_shutdown_executive(status);
400138f0: 7f ff f6 c3 call 400113fc <rtems_shutdown_executive>
400138f4: 90 10 00 18 mov %i0, %o0
400138f8: 01 00 00 00 nop
<== NOT EXECUTED
40007790 <_getpid_r>:
pid_t _getpid_r(
struct _reent *ptr RTEMS_UNUSED
)
{
return getpid();
}
40007790: 81 c3 e0 08 retl
<== NOT EXECUTED
40007794: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
40005050 <_gettimeofday_r>:
int _gettimeofday_r(
struct _reent *ignored_reentrancy_stuff RTEMS_UNUSED,
struct timeval *tp,
void *__tz
)
{
40005050: 9d e3 bf a0 save %sp, -96, %sp
if ( !tp )
40005054: 80 a6 60 00 cmp %i1, 0
40005058: 02 80 00 06 be 40005070 <_gettimeofday_r+0x20>
<== NEVER TAKEN
4000505c: 90 10 00 19 mov %i1, %o0
40005060: 40 00 0f 60 call 40008de0 <_Timecounter_Microtime>
40005064: b0 10 20 00 clr %i0
struct timezone *tzp = __tz;
return gettimeofday( tp, tzp );
}
40005068: 81 c7 e0 08 ret
4000506c: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EFAULT );
40005070: 40 00 35 01 call 40012474 <__errno>
<== NOT EXECUTED
40005074: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005078: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
4000507c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005080: 81 c7 e0 08 ret
<== NOT EXECUTED
40005084: 81 e8 00 00 restore
<== NOT EXECUTED
400056a4 <_libcsupport_scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
400056a4: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
400056a8: 98 10 20 00 clr %o4
{
400056ac: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
400056b0: 96 07 a0 50 add %fp, 0x50, %o3
{
400056b4: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
400056b8: 94 07 a0 4c add %fp, 0x4c, %o2
400056bc: 92 10 00 19 mov %i1, %o1
400056c0: 7f ff ff 34 call 40005390 <scanString>
400056c4: 90 10 00 18 mov %i0, %o0
400056c8: 80 a2 20 00 cmp %o0, 0
400056cc: 12 80 00 04 bne 400056dc <_libcsupport_scangr+0x38>
400056d0: 98 10 20 00 clr %o4
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
400056d4: 81 c7 e0 08 ret
400056d8: 91 e8 20 00 restore %g0, 0, %o0
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
400056dc: 96 07 a0 50 add %fp, 0x50, %o3
400056e0: 94 07 a0 4c add %fp, 0x4c, %o2
400056e4: 92 06 60 04 add %i1, 4, %o1
400056e8: 7f ff ff 2a call 40005390 <scanString>
400056ec: 90 10 00 18 mov %i0, %o0
400056f0: 80 a2 20 00 cmp %o0, 0
400056f4: 02 bf ff f8 be 400056d4 <_libcsupport_scangr+0x30>
<== NEVER TAKEN
400056f8: 92 07 bf f8 add %fp, -8, %o1
|| !scanInt(fp, &grgid)
400056fc: 7f ff fe ec call 400052ac <scanInt>
40005700: 90 10 00 18 mov %i0, %o0
40005704: 80 a2 20 00 cmp %o0, 0
40005708: 02 bf ff f3 be 400056d4 <_libcsupport_scangr+0x30>
<== NEVER TAKEN
4000570c: 98 10 20 01 mov 1, %o4
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
40005710: 96 07 a0 50 add %fp, 0x50, %o3
40005714: 94 07 a0 4c add %fp, 0x4c, %o2
40005718: 92 07 bf fc add %fp, -4, %o1
4000571c: 7f ff ff 1d call 40005390 <scanString>
40005720: 90 10 00 18 mov %i0, %o0
40005724: 80 a2 20 00 cmp %o0, 0
40005728: 02 bf ff eb be 400056d4 <_libcsupport_scangr+0x30>
<== NEVER TAKEN
4000572c: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
40005730: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
if (grmem[0] == '\0') {
40005734: fa 07 bf fc ld [ %fp + -4 ], %i5
40005738: c2 0f 40 00 ldub [ %i5 ], %g1
4000573c: 83 28 60 18 sll %g1, 0x18, %g1
40005740: 80 a0 60 00 cmp %g1, 0
40005744: 02 80 00 13 be 40005790 <_libcsupport_scangr+0xec>
40005748: 84 10 20 13 mov 0x13, %g2
4000574c: 84 10 00 1d mov %i5, %g2
memcount = 0;
} else {
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40005750: 88 10 20 01 mov 1, %g4
if(*cp == ',')
40005754: 83 38 60 18 sra %g1, 0x18, %g1
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40005758: 84 00 a0 01 inc %g2
if(*cp == ',')
4000575c: 80 a0 60 2c cmp %g1, 0x2c
40005760: 12 80 00 05 bne 40005774 <_libcsupport_scangr+0xd0>
40005764: 86 01 20 01 add %g4, 1, %g3
40005768: 82 01 20 02 add %g4, 2, %g1
memcount++;
4000576c: 88 10 00 03 mov %g3, %g4
if(*cp == ',')
40005770: 86 10 00 01 mov %g1, %g3
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40005774: c2 08 80 00 ldub [ %g2 ], %g1
40005778: 83 28 60 18 sll %g1, 0x18, %g1
4000577c: 80 a0 60 00 cmp %g1, 0
40005780: 12 bf ff f6 bne 40005758 <_libcsupport_scangr+0xb4>
40005784: 83 38 60 18 sra %g1, 0x18, %g1
40005788: 85 28 e0 02 sll %g3, 2, %g2
4000578c: 84 00 a0 0f add %g2, 0xf, %g2
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
40005790: c2 07 a0 50 ld [ %fp + 0x50 ], %g1
40005794: 80 a0 40 02 cmp %g1, %g2
40005798: 0a bf ff cf bcs 400056d4 <_libcsupport_scangr+0x30>
<== NEVER TAKEN
4000579c: c6 07 a0 4c ld [ %fp + 0x4c ], %g3
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
400057a0: 86 00 e0 0f add %g3, 0xf, %g3
400057a4: 86 08 ff f0 and %g3, -16, %g3
400057a8: c6 26 60 0c st %g3, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
if (grmem[0] == '\0') {
400057ac: c2 4f 40 00 ldsb [ %i5 ], %g1
400057b0: 80 a0 60 00 cmp %g1, 0
400057b4: 02 80 00 1a be 4000581c <_libcsupport_scangr+0x178>
400057b8: 88 10 20 00 clr %g4
memcount = 0;
} else {
grp->gr_mem[0] = grmem;
400057bc: fa 20 c0 00 st %i5, [ %g3 ]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
400057c0: c4 07 bf fc ld [ %fp + -4 ], %g2
400057c4: c2 08 80 00 ldub [ %g2 ], %g1
400057c8: 83 28 60 18 sll %g1, 0x18, %g1
400057cc: 80 a0 60 00 cmp %g1, 0
400057d0: 02 80 00 13 be 4000581c <_libcsupport_scangr+0x178>
<== NEVER TAKEN
400057d4: 88 10 20 04 mov 4, %g4
400057d8: 86 10 20 01 mov 1, %g3
if(*cp == ',') {
400057dc: 83 38 60 18 sra %g1, 0x18, %g1
400057e0: 89 28 e0 02 sll %g3, 2, %g4
400057e4: 80 a0 60 2c cmp %g1, 0x2c
400057e8: 12 80 00 07 bne 40005804 <_libcsupport_scangr+0x160>
400057ec: 84 00 a0 01 inc %g2
*cp = '\0';
400057f0: c0 28 bf ff clrb [ %g2 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
400057f4: 86 00 e0 01 inc %g3
400057f8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
400057fc: c4 20 40 04 st %g2, [ %g1 + %g4 ]
40005800: 88 01 20 04 add %g4, 4, %g4
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40005804: c2 08 80 00 ldub [ %g2 ], %g1
40005808: 83 28 60 18 sll %g1, 0x18, %g1
4000580c: 80 a0 60 00 cmp %g1, 0
40005810: 32 bf ff f4 bne,a 400057e0 <_libcsupport_scangr+0x13c>
40005814: 83 38 60 18 sra %g1, 0x18, %g1
40005818: c6 06 60 0c ld [ %i1 + 0xc ], %g3
}
}
}
grp->gr_mem[memcount] = NULL;
4000581c: c0 20 c0 04 clr [ %g3 + %g4 ]
return 1;
}
40005820: 81 c7 e0 08 ret
40005824: 91 e8 20 01 restore %g0, 1, %o0
40012bb0 <_libcsupport_scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
40012bb0: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40012bb4: 98 10 20 00 clr %o4
{
40012bb8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40012bbc: 96 07 a0 50 add %fp, 0x50, %o3
{
40012bc0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40012bc4: 94 07 a0 4c add %fp, 0x4c, %o2
40012bc8: 92 10 00 19 mov %i1, %o1
40012bcc: 7f ff ff cc call 40012afc <scanString>
40012bd0: 90 10 00 18 mov %i0, %o0
40012bd4: 80 a2 20 00 cmp %o0, 0
40012bd8: 12 80 00 04 bne 40012be8 <_libcsupport_scanpw+0x38>
40012bdc: 98 10 20 00 clr %o4
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
40012be0: 81 c7 e0 08 ret
40012be4: 91 e8 20 00 restore %g0, 0, %o0
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
40012be8: 96 07 a0 50 add %fp, 0x50, %o3
40012bec: 94 07 a0 4c add %fp, 0x4c, %o2
40012bf0: 92 06 60 04 add %i1, 4, %o1
40012bf4: 7f ff ff c2 call 40012afc <scanString>
40012bf8: 90 10 00 18 mov %i0, %o0
40012bfc: 80 a2 20 00 cmp %o0, 0
40012c00: 02 bf ff f8 be 40012be0 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40012c04: 92 07 bf f8 add %fp, -8, %o1
|| !scanInt(fp, &pwuid)
40012c08: 7f ff ff 84 call 40012a18 <scanInt>
40012c0c: 90 10 00 18 mov %i0, %o0
40012c10: 80 a2 20 00 cmp %o0, 0
40012c14: 02 bf ff f3 be 40012be0 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40012c18: 92 07 bf fc add %fp, -4, %o1
|| !scanInt(fp, &pwgid)
40012c1c: 7f ff ff 7f call 40012a18 <scanInt>
40012c20: 90 10 00 18 mov %i0, %o0
40012c24: 80 a2 20 00 cmp %o0, 0
40012c28: 02 bf ff ee be 40012be0 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40012c2c: 98 10 20 00 clr %o4
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
40012c30: 96 07 a0 50 add %fp, 0x50, %o3
40012c34: 94 07 a0 4c add %fp, 0x4c, %o2
40012c38: 92 06 60 0c add %i1, 0xc, %o1
40012c3c: 7f ff ff b0 call 40012afc <scanString>
40012c40: 90 10 00 18 mov %i0, %o0
40012c44: 80 a2 20 00 cmp %o0, 0
40012c48: 02 bf ff e6 be 40012be0 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40012c4c: 98 10 20 00 clr %o4
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
40012c50: 96 07 a0 50 add %fp, 0x50, %o3
40012c54: 94 07 a0 4c add %fp, 0x4c, %o2
40012c58: 92 06 60 10 add %i1, 0x10, %o1
40012c5c: 7f ff ff a8 call 40012afc <scanString>
40012c60: 90 10 00 18 mov %i0, %o0
40012c64: 80 a2 20 00 cmp %o0, 0
40012c68: 02 bf ff de be 40012be0 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40012c6c: 98 10 20 00 clr %o4
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
40012c70: 96 07 a0 50 add %fp, 0x50, %o3
40012c74: 94 07 a0 4c add %fp, 0x4c, %o2
40012c78: 92 06 60 14 add %i1, 0x14, %o1
40012c7c: 7f ff ff a0 call 40012afc <scanString>
40012c80: 90 10 00 18 mov %i0, %o0
40012c84: 80 a2 20 00 cmp %o0, 0
40012c88: 02 bf ff d6 be 40012be0 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40012c8c: 98 10 20 01 mov 1, %o4
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
40012c90: 96 07 a0 50 add %fp, 0x50, %o3
40012c94: 94 07 a0 4c add %fp, 0x4c, %o2
40012c98: 92 06 60 18 add %i1, 0x18, %o1
40012c9c: 7f ff ff 98 call 40012afc <scanString>
40012ca0: 90 10 00 18 mov %i0, %o0
40012ca4: 80 a2 20 00 cmp %o0, 0
40012ca8: 02 bf ff ce be 40012be0 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40012cac: c2 07 bf f8 ld [ %fp + -8 ], %g1
pwd->pw_uid = pwuid;
40012cb0: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
40012cb4: c2 07 bf fc ld [ %fp + -4 ], %g1
40012cb8: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
40012cbc: 81 c7 e0 08 ret
40012cc0: 91 e8 20 01 restore %g0, 1, %o0
40014180 <_unlink_r>:
int _unlink_r(
struct _reent *ptr RTEMS_UNUSED,
const char *path
)
{
return unlink( path );
40014180: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
40014184: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40014188: 7f ff ff dd call 400140fc <unlink>
<== NOT EXECUTED
4001418c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000c3b8 <chmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int chmod( const char *path, mode_t mode )
{
4000c3b8: 9d e3 bf 68 save %sp, -152, %sp
<== NOT EXECUTED
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
4000c3bc: 94 10 20 18 mov 0x18, %o2
<== NOT EXECUTED
4000c3c0: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4000c3c4: 40 00 07 f3 call 4000e390 <rtems_filesystem_eval_path_start>
<== NOT EXECUTED
4000c3c8: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rv = rtems_filesystem_chmod( currentloc, mode );
4000c3cc: 40 00 00 bc call 4000c6bc <rtems_filesystem_chmod>
<== NOT EXECUTED
4000c3d0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000c3d4: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
4000c3d8: 40 00 08 38 call 4000e4b8 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
4000c3dc: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
return rv;
}
4000c3e0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c3e4: 81 e8 00 00 restore
<== NOT EXECUTED
4000c5dc <chown>:
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int chown( const char *path, uid_t owner, gid_t group )
{
4000c5dc: 9d e3 bf 68 save %sp, -152, %sp
<== NOT EXECUTED
int rv;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
4000c5e0: 94 10 20 18 mov 0x18, %o2
<== NOT EXECUTED
4000c5e4: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4000c5e8: 7f ff e4 f1 call 400059ac <rtems_filesystem_eval_path_start>
<== NOT EXECUTED
4000c5ec: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rv = rtems_filesystem_chown( currentloc, owner, group );
4000c5f0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000c5f4: 40 00 00 6f call 4000c7b0 <rtems_filesystem_chown>
<== NOT EXECUTED
4000c5f8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000c5fc: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
4000c600: 7f ff e4 f7 call 400059dc <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
4000c604: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
return rv;
}
4000c608: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c60c: 81 e8 00 00 restore
<== NOT EXECUTED
4000c3e8 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
4000c3e8: 9d e3 be e8 save %sp, -280, %sp
/*
* We use the global environment for path evaluation. This makes it possible
* to escape from a chroot environment referencing an unmounted file system.
*/
rtems_filesystem_eval_path_start_with_root_and_current(
4000c3ec: 40 00 cf ce call 40040324 <strlen>
4000c3f0: 90 10 00 18 mov %i0, %o0
4000c3f4: 96 10 20 19 mov 0x19, %o3
4000c3f8: 94 10 00 08 mov %o0, %o2
4000c3fc: 92 10 00 18 mov %i0, %o1
4000c400: 90 07 bf 68 add %fp, -152, %o0
4000c404: 1b 10 01 6d sethi %hi(0x4005b400), %o5
4000c408: 9a 13 60 6c or %o5, 0x6c, %o5 ! 4005b46c <rtems_global_user_env>
4000c40c: 40 00 07 8b call 4000e238 <rtems_filesystem_eval_path_start_with_root_and_current>
4000c410: 98 03 60 04 add %o5, 4, %o4
4000c414: 92 07 bf 80 add %fp, -128, %o1
4000c418: 40 00 09 77 call 4000e9f4 <rtems_filesystem_location_copy_and_detach>
4000c41c: 90 07 bf 50 add %fp, -176, %o0
&rtems_global_user_env.root_directory,
&rtems_global_user_env.current_directory
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
4000c420: 40 00 09 a0 call 4000eaa0 <rtems_filesystem_location_transform_to_global>
4000c424: 90 07 bf 50 add %fp, -176, %o0
4000c428: d0 27 bf 4c st %o0, [ %fp + -180 ]
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
4000c42c: 3b 10 01 59 sethi %hi(0x40056400), %i5
4000c430: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4000c434: ba 17 62 fc or %i5, 0x2fc, %i5
4000c438: 80 a0 40 1d cmp %g1, %i5
4000c43c: 02 80 00 3c be 4000c52c <chroot+0x144>
4000c440: 01 00 00 00 nop
rtems_filesystem_global_location_t *new_root_loc =
4000c444: 40 00 08 ed call 4000e7f8 <rtems_filesystem_global_location_obtain>
4000c448: 90 07 bf 4c add %fp, -180, %o0
st.st_mode = 0;
4000c44c: c0 27 bf ac clr [ %fp + -84 ]
4000c450: b8 10 00 08 mov %o0, %i4
(void) ( *loc->handlers->fstat_h )( loc, &st );
4000c454: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4000c458: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
4000c45c: 9f c0 40 00 call %g1
4000c460: 92 07 bf a0 add %fp, -96, %o1
rtems_filesystem_global_location_obtain( &new_current_loc );
mode_t type = rtems_filesystem_location_type( &new_root_loc->location );
if ( S_ISDIR( type ) ) {
4000c464: 05 00 00 3c sethi %hi(0xf000), %g2
4000c468: c2 07 bf ac ld [ %fp + -84 ], %g1
4000c46c: 82 08 40 02 and %g1, %g2, %g1
4000c470: 05 00 00 10 sethi %hi(0x4000), %g2
4000c474: 80 a0 40 02 cmp %g1, %g2
4000c478: 32 80 00 14 bne,a 4000c4c8 <chroot+0xe0>
<== NEVER TAKEN
4000c47c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
<== NOT EXECUTED
sc = rtems_libio_set_private_env();
4000c480: 40 00 04 e9 call 4000d824 <rtems_libio_set_private_env>
4000c484: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
4000c488: 80 a2 20 00 cmp %o0, 0
4000c48c: 12 80 00 21 bne 4000c510 <chroot+0x128>
<== NEVER TAKEN
4000c490: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
&rtems_filesystem_root,
4000c494: 40 00 04 cf call 4000d7d0 <rtems_current_user_env_get>
4000c498: b0 10 20 00 clr %i0
rtems_filesystem_global_location_assign(
4000c49c: 92 10 00 1c mov %i4, %o1
4000c4a0: 40 00 09 2a call 4000e948 <rtems_filesystem_global_location_assign>
4000c4a4: 90 02 20 04 add %o0, 4, %o0
new_root_loc
);
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
4000c4a8: 40 00 04 ca call 4000d7d0 <rtems_current_user_env_get>
4000c4ac: 01 00 00 00 nop
rtems_filesystem_global_location_assign(
4000c4b0: 40 00 09 26 call 4000e948 <rtems_filesystem_global_location_assign>
4000c4b4: d2 07 bf 4c ld [ %fp + -180 ], %o1
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
4000c4b8: 40 00 08 00 call 4000e4b8 <rtems_filesystem_eval_path_cleanup>
4000c4bc: 90 07 bf 68 add %fp, -152, %o0
4000c4c0: 81 c7 e0 08 ret
4000c4c4: 81 e8 00 00 restore
if ( !rtems_filesystem_location_is_null( loc ) ) {
4000c4c8: 80 a0 40 1d cmp %g1, %i5
<== NOT EXECUTED
4000c4cc: 22 80 00 07 be,a 4000c4e8 <chroot+0x100>
<== NOT EXECUTED
4000c4d0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
errno = eno;
4000c4d4: 40 00 b7 a7 call 4003a370 <__errno>
<== NOT EXECUTED
4000c4d8: 01 00 00 00 nop
<== NOT EXECUTED
4000c4dc: 82 10 20 14 mov 0x14, %g1 ! 14 <_TLS_Alignment+0x13>
<== NOT EXECUTED
4000c4e0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_filesystem_global_location_release( new_root_loc, true );
4000c4e4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000c4e8: 40 00 08 fe call 4000e8e0 <rtems_filesystem_global_location_release>
<== NOT EXECUTED
4000c4ec: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
4000c4f0: 40 00 07 f2 call 4000e4b8 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
4000c4f4: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc, false );
4000c4f8: d0 07 bf 4c ld [ %fp + -180 ], %o0
<== NOT EXECUTED
4000c4fc: 92 10 20 00 clr %o1
4000c500: 40 00 08 f8 call 4000e8e0 <rtems_filesystem_global_location_release>
4000c504: b0 10 3f ff mov -1, %i0
}
return rv;
}
4000c508: 81 c7 e0 08 ret
4000c50c: 81 e8 00 00 restore
if (sc != RTEMS_UNSATISFIED) {
4000c510: 22 bf ff f6 be,a 4000c4e8 <chroot+0x100>
<== NOT EXECUTED
4000c514: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
errno = ENOMEM;
4000c518: 40 00 b7 96 call 4003a370 <__errno>
<== NOT EXECUTED
4000c51c: 01 00 00 00 nop
<== NOT EXECUTED
4000c520: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
4000c524: 10 bf ff f0 b 4000c4e4 <chroot+0xfc>
<== NOT EXECUTED
4000c528: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
4000c52c: 40 00 07 e3 call 4000e4b8 <rtems_filesystem_eval_path_cleanup>
4000c530: 90 07 bf 68 add %fp, -152, %o0
rtems_filesystem_global_location_release( new_current_loc, false );
4000c534: 10 bf ff f2 b 4000c4fc <chroot+0x114>
4000c538: d0 07 bf 4c ld [ %fp + -180 ], %o0
40004df0 <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
40004df0: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
unsigned int flags;
int rc;
if ( (uint32_t) fd >= rtems_libio_number_iops ) {
40004df4: 03 10 00 4f sethi %hi(0x40013c00), %g1
40004df8: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 40013e58 <rtems_libio_number_iops>
40004dfc: 80 a6 00 01 cmp %i0, %g1
40004e00: 1a 80 00 1b bcc 40004e6c <close+0x7c>
<== NEVER TAKEN
40004e04: 01 00 00 00 nop
return &rtems_libio_iops[ fd ];
40004e08: b7 2e 20 01 sll %i0, 1, %i3
40004e0c: b0 06 c0 18 add %i3, %i0, %i0
40004e10: 37 10 00 5b sethi %hi(0x40016c00), %i3
40004e14: b9 2e 20 04 sll %i0, 4, %i4
40004e18: b6 16 e0 f8 or %i3, 0xf8, %i3
40004e1c: b8 06 c0 1c add %i3, %i4, %i4
40004e20: c4 07 20 08 ld [ %i4 + 8 ], %g2
unsigned int actual;
(void) succ;
(void) fail;
_ISR_Local_disable( level );
actual = *obj;
40004e24: 10 80 00 0f b 40004e60 <close+0x70>
40004e28: ba 10 00 1c mov %i4, %i5
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004e2c: 91 d0 20 09 ta 9
<== NOT EXECUTED
40004e30: c6 07 60 08 ld [ %i5 + 8 ], %g3
success = ( actual == *expected );
if ( success ) {
40004e34: 80 a1 00 03 cmp %g4, %g3
40004e38: 12 80 00 03 bne 40004e44 <close+0x54>
<== NEVER TAKEN
40004e3c: 84 08 ae ff and %g2, 0xeff, %g2
<== NOT EXECUTED
*obj = desired;
40004e40: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004e44: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004e48: 01 00 00 00 nop
desired,
ATOMIC_ORDER_ACQ_REL,
ATOMIC_ORDER_RELAXED
);
if ( success ) {
40004e4c: 80 a1 00 03 cmp %g4, %g3
40004e50: 02 80 00 0d be 40004e84 <close+0x94>
<== ALWAYS TAKEN
40004e54: 80 88 f0 00 btst -4096, %g3
break;
}
if ( ( flags & ~( LIBIO_FLAGS_REFERENCE_INC - 1U ) ) != 0 ) {
40004e58: 12 80 00 16 bne 40004eb0 <close+0xc0>
<== NOT EXECUTED
40004e5c: 84 10 00 03 mov %g3, %g2
<== NOT EXECUTED
if ( ( flags & LIBIO_FLAGS_OPEN ) == 0 ) {
40004e60: 80 88 a1 00 btst 0x100, %g2
40004e64: 12 bf ff f2 bne 40004e2c <close+0x3c>
<== ALWAYS TAKEN
40004e68: 88 08 af ff and %g2, 0xfff, %g4
rtems_set_errno_and_return_minus_one( EBADF );
40004e6c: 40 00 35 82 call 40012474 <__errno>
<== NOT EXECUTED
40004e70: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004e74: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40004e78: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004e7c: 81 c7 e0 08 ret
<== NOT EXECUTED
40004e80: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
}
}
rc = (*iop->pathinfo.handlers->close_h)( iop );
40004e84: b1 2e 20 04 sll %i0, 4, %i0
40004e88: b6 06 c0 18 add %i3, %i0, %i3
40004e8c: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
40004e90: c2 00 60 04 ld [ %g1 + 4 ], %g1
40004e94: 9f c0 40 00 call %g1
40004e98: 90 10 00 1c mov %i4, %o0
40004e9c: b0 10 00 08 mov %o0, %i0
rtems_libio_free( iop );
40004ea0: 40 00 01 04 call 400052b0 <rtems_libio_free>
40004ea4: 90 10 00 1c mov %i4, %o0
return rc;
}
40004ea8: 81 c7 e0 08 ret
40004eac: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EBUSY );
40004eb0: 40 00 35 71 call 40012474 <__errno>
<== NOT EXECUTED
40004eb4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004eb8: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
40004ebc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004ec0: 81 c7 e0 08 ret
<== NOT EXECUTED
40004ec4: 81 e8 00 00 restore
<== NOT EXECUTED
4000ce60 <endgrent>:
void endgrent(void)
{
4000ce60: 9d e3 bf a0 save %sp, -96, %sp
grp_context *ctx = grp_get_context();
4000ce64: 7f ff ff b4 call 4000cd34 <grp_get_context>
4000ce68: 01 00 00 00 nop
if (ctx == NULL)
4000ce6c: ba 92 20 00 orcc %o0, 0, %i5
4000ce70: 02 80 00 0e be 4000cea8 <endgrent+0x48>
<== NEVER TAKEN
4000ce74: 01 00 00 00 nop
return;
if (ctx->fp != NULL) {
4000ce78: d0 07 40 00 ld [ %i5 ], %o0
4000ce7c: 80 a2 20 00 cmp %o0, 0
4000ce80: 02 80 00 04 be 4000ce90 <endgrent+0x30>
<== NEVER TAKEN
4000ce84: 01 00 00 00 nop
fclose(ctx->fp);
4000ce88: 40 00 06 34 call 4000e758 <fclose>
4000ce8c: 01 00 00 00 nop
}
free(ctx);
4000ce90: 7f ff dd 79 call 40004474 <free>
4000ce94: 90 10 00 1d mov %i5, %o0
pthread_setspecific(grp_key, NULL);
4000ce98: 03 10 00 56 sethi %hi(0x40015800), %g1
<== NOT EXECUTED
4000ce9c: f0 00 61 68 ld [ %g1 + 0x168 ], %i0 ! 40015968 <grp_key>
<== NOT EXECUTED
4000cea0: 7f ff e7 51 call 40006be4 <pthread_setspecific>
<== NOT EXECUTED
4000cea4: 93 e8 20 00 restore %g0, 0, %o1
}
4000cea8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ceac: 81 e8 00 00 restore
<== NOT EXECUTED
4002f9e0 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
4002f9e0: 9d e3 bf 98 save %sp, -104, %sp
int ret;
va_list ap;
va_start( ap, cmd );
4002f9e4: 86 07 a0 4c add %fp, 0x4c, %g3
4002f9e8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
LIBIO_GET_IOP( fd, iop );
4002f9ec: 09 10 00 c0 sethi %hi(0x40030000), %g4
va_start( ap, cmd );
4002f9f0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4002f9f4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4002f9f8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
LIBIO_GET_IOP( fd, iop );
4002f9fc: c2 01 22 e8 ld [ %g4 + 0x2e8 ], %g1
4002fa00: 80 a6 00 01 cmp %i0, %g1
4002fa04: 1a 80 00 df bcc 4002fd80 <fcntl+0x3a0>
<== NEVER TAKEN
4002fa08: c6 27 bf fc st %g3, [ %fp + -4 ]
<== NOT EXECUTED
4002fa0c: 83 2e 20 01 sll %i0, 1, %g1
<== NOT EXECUTED
4002fa10: 39 10 01 3a sethi %hi(0x4004e800), %i4
<== NOT EXECUTED
4002fa14: a0 00 40 18 add %g1, %i0, %l0
<== NOT EXECUTED
4002fa18: b8 17 20 68 or %i4, 0x68, %i4
<== NOT EXECUTED
4002fa1c: b7 2c 20 04 sll %l0, 4, %i3
<== NOT EXECUTED
4002fa20: ba 07 00 1b add %i4, %i3, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fa24: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4002fa28: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4002fa2c: b4 20 b0 00 sub %g2, -4096, %i2
<== NOT EXECUTED
4002fa30: f4 27 60 08 st %i2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002fa34: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002fa38: 01 00 00 00 nop
4002fa3c: 80 88 a1 00 btst 0x100, %g2
4002fa40: 02 80 00 d6 be 4002fd98 <fcntl+0x3b8>
<== NEVER TAKEN
4002fa44: 80 a6 60 14 cmp %i1, 0x14
switch ( cmd ) {
4002fa48: 18 80 00 b7 bgu 4002fd24 <fcntl+0x344>
<== NEVER TAKEN
4002fa4c: 85 2e 60 02 sll %i1, 2, %g2
4002fa50: 03 10 00 be sethi %hi(0x4002f800), %g1
4002fa54: 82 10 61 8c or %g1, 0x18c, %g1 ! 4002f98c <_calloc_r+0x14>
4002fa58: c2 00 40 02 ld [ %g1 + %g2 ], %g1
4002fa5c: 81 c0 40 00 jmp %g1
4002fa60: 01 00 00 00 nop
errno = ENOTSUP;
4002fa64: 7f ff c4 81 call 40020c68 <__errno>
<== NOT EXECUTED
4002fa68: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
4002fa6c: 82 10 20 86 mov 0x86, %g1
<== NOT EXECUTED
4002fa70: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fa74: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4002fa78: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4002fa7c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4002fa80: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002fa84: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002fa88: 01 00 00 00 nop
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
4002fa8c: 81 c7 e0 08 ret
4002fa90: 81 e8 00 00 restore
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
4002fa94: 7f ff 67 51 call 400097d8 <rtems_libio_fcntl_flags>
4002fa98: d0 00 c0 00 ld [ %g3 ], %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fa9c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val & arg;
4002faa0: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4002faa4: 84 08 bd fe and %g2, -514, %g2
<== NOT EXECUTED
4002faa8: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002faac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002fab0: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fab4: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val | arg;
4002fab8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
rtems_libio_iop_flags_set( iop, flags & mask );
4002fabc: 90 0a 22 01 and %o0, 0x201, %o0
<== NOT EXECUTED
4002fac0: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
4002fac4: d0 27 60 08 st %o0, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002fac8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002facc: 01 00 00 00 nop
int ret = 0;
4002fad0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
4002fad4: 83 2c 20 04 sll %l0, 4, %g1
4002fad8: b8 07 00 01 add %i4, %g1, %i4
4002fadc: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
4002fae0: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
4002fae4: 92 10 00 19 mov %i1, %o1
4002fae8: 9f c0 40 00 call %g1
4002faec: 90 10 00 1d mov %i5, %o0
if (err) {
4002faf0: b8 92 20 00 orcc %o0, 0, %i4
4002faf4: 02 bf ff e0 be 4002fa74 <fcntl+0x94>
<== ALWAYS TAKEN
4002faf8: 01 00 00 00 nop
errno = err;
4002fafc: 7f ff c4 5b call 40020c68 <__errno>
<== NOT EXECUTED
4002fb00: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
4002fb04: f8 22 00 00 st %i4, [ %o0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fb08: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4002fb0c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4002fb10: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4002fb14: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002fb18: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002fb1c: 01 00 00 00 nop
<== NOT EXECUTED
}
4002fb20: 81 c7 e0 08 ret
<== NOT EXECUTED
4002fb24: 81 e8 00 00 restore
<== NOT EXECUTED
fd2 = va_arg( ap, int );
4002fb28: e6 00 c0 00 ld [ %g3 ], %l3
<== NOT EXECUTED
if ( (uint32_t) fd2 >= rtems_libio_number_iops ) {
4002fb2c: c2 01 22 e8 ld [ %g4 + 0x2e8 ], %g1
<== NOT EXECUTED
4002fb30: 80 a4 c0 01 cmp %l3, %g1
<== NOT EXECUTED
4002fb34: 1a 80 00 a5 bcc 4002fdc8 <fcntl+0x3e8>
<== NOT EXECUTED
4002fb38: b5 2c e0 01 sll %l3, 1, %i2
<== NOT EXECUTED
4002fb3c: b4 06 80 13 add %i2, %l3, %i2
<== NOT EXECUTED
4002fb40: a3 2e a0 04 sll %i2, 4, %l1
<== NOT EXECUTED
4002fb44: a4 07 00 11 add %i4, %l1, %l2
<== NOT EXECUTED
if (iop != iop2)
4002fb48: 80 a7 40 12 cmp %i5, %l2
<== NOT EXECUTED
4002fb4c: 02 bf ff e2 be 4002fad4 <fcntl+0xf4>
<== NOT EXECUTED
4002fb50: b0 10 20 00 clr %i0
<== NOT EXECUTED
4002fb54: c2 04 a0 08 ld [ %l2 + 8 ], %g1
<== NOT EXECUTED
if ((rtems_libio_iop_flags( iop2 ) & LIBIO_FLAGS_OPEN) != 0) {
4002fb58: 80 88 61 00 btst 0x100, %g1
<== NOT EXECUTED
4002fb5c: 22 80 00 0a be,a 4002fb84 <fcntl+0x1a4>
<== NOT EXECUTED
4002fb60: d0 07 60 08 ld [ %i5 + 8 ], %o0
<== NOT EXECUTED
rv = (*iop2->pathinfo.handlers->close_h)( iop2 );
4002fb64: c2 04 a0 1c ld [ %l2 + 0x1c ], %g1
<== NOT EXECUTED
4002fb68: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4002fb6c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4002fb70: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
if (rv == 0) {
4002fb74: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4002fb78: 12 80 00 5d bne 4002fcec <fcntl+0x30c>
<== NOT EXECUTED
4002fb7c: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4002fb80: d0 07 60 08 ld [ %i5 + 8 ], %o0
<== NOT EXECUTED
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
4002fb84: 7f ff 67 22 call 4000980c <rtems_libio_to_fcntl_flags>
<== NOT EXECUTED
4002fb88: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_flags_set( iop2, rtems_libio_fcntl_flags( oflag ) );
4002fb8c: 7f ff 67 13 call 400097d8 <rtems_libio_fcntl_flags>
<== NOT EXECUTED
4002fb90: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fb94: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val | arg;
4002fb98: c4 04 a0 08 ld [ %l2 + 8 ], %g2
<== NOT EXECUTED
4002fb9c: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
4002fba0: d0 24 a0 08 st %o0, [ %l2 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002fba4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002fba8: 01 00 00 00 nop
<== NOT EXECUTED
4002fbac: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
4002fbb0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4002fbb4: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4002fbb8: 9f c0 40 00 call %g1
<== NOT EXECUTED
4002fbbc: b5 2e a0 04 sll %i2, 4, %i2
<== NOT EXECUTED
rtems_filesystem_location_clone( &iop2->pathinfo, &iop->pathinfo );
4002fbc0: 92 06 e0 0c add %i3, 0xc, %o1
<== NOT EXECUTED
4002fbc4: 90 04 60 0c add %l1, 0xc, %o0
<== NOT EXECUTED
4002fbc8: 92 07 00 09 add %i4, %o1, %o1
<== NOT EXECUTED
4002fbcc: 7f ff a3 75 call 400189a0 <rtems_filesystem_location_clone>
<== NOT EXECUTED
4002fbd0: 90 07 00 08 add %i4, %o0, %o0
<== NOT EXECUTED
4002fbd4: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
4002fbd8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4002fbdc: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4002fbe0: 9f c0 40 00 call %g1
<== NOT EXECUTED
4002fbe4: b4 07 00 1a add %i4, %i2, %i2
<== NOT EXECUTED
rv = (*iop2->pathinfo.handlers->open_h)( iop2, NULL, oflag, 0 );
4002fbe8: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
4002fbec: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4002fbf0: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
4002fbf4: 96 10 20 00 clr %o3
<== NOT EXECUTED
4002fbf8: 92 10 20 00 clr %o1
<== NOT EXECUTED
4002fbfc: 9f c0 40 00 call %g1
<== NOT EXECUTED
4002fc00: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
4002fc04: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4002fc08: 22 80 00 38 be,a 4002fce8 <fcntl+0x308>
<== NOT EXECUTED
4002fc0c: b0 10 00 13 mov %l3, %i0
<== NOT EXECUTED
if (ret >= 0) {
4002fc10: 10 80 00 37 b 4002fcec <fcntl+0x30c>
<== NOT EXECUTED
4002fc14: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4002fc18: d0 07 60 08 ld [ %i5 + 8 ], %o0
<== NOT EXECUTED
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
4002fc1c: 7f ff 66 fc call 4000980c <rtems_libio_to_fcntl_flags>
<== NOT EXECUTED
4002fc20: 01 00 00 00 nop
<== NOT EXECUTED
diop = rtems_libio_allocate();
4002fc24: 7f ff 67 0d call 40009858 <rtems_libio_allocate>
<== NOT EXECUTED
4002fc28: a2 10 00 08 mov %o0, %l1
<== NOT EXECUTED
if (diop != NULL) {
4002fc2c: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4002fc30: 02 bf ff 91 be 4002fa74 <fcntl+0x94>
<== NOT EXECUTED
4002fc34: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002fc38: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
4002fc3c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4002fc40: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4002fc44: 9f c0 40 00 call %g1
<== NOT EXECUTED
4002fc48: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
4002fc4c: 90 06 a0 0c add %i2, 0xc, %o0
<== NOT EXECUTED
4002fc50: 92 06 e0 0c add %i3, 0xc, %o1
<== NOT EXECUTED
4002fc54: 7f ff a3 53 call 400189a0 <rtems_filesystem_location_clone>
<== NOT EXECUTED
4002fc58: 92 07 00 09 add %i4, %o1, %o1
<== NOT EXECUTED
4002fc5c: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
4002fc60: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4002fc64: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4002fc68: 9f c0 40 00 call %g1
<== NOT EXECUTED
4002fc6c: 01 00 00 00 nop
<== NOT EXECUTED
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
4002fc70: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
4002fc74: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4002fc78: 96 10 20 00 clr %o3
<== NOT EXECUTED
4002fc7c: 94 10 00 11 mov %l1, %o2
<== NOT EXECUTED
4002fc80: 92 10 20 00 clr %o1
<== NOT EXECUTED
4002fc84: 9f c0 40 00 call %g1
<== NOT EXECUTED
4002fc88: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
4002fc8c: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4002fc90: 02 80 00 32 be 4002fd58 <fcntl+0x378>
<== NOT EXECUTED
4002fc94: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_free( diop );
4002fc98: 7f ff 67 05 call 400098ac <rtems_libio_free>
<== NOT EXECUTED
4002fc9c: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
if (ret >= 0) {
4002fca0: 10 80 00 13 b 4002fcec <fcntl+0x30c>
<== NOT EXECUTED
4002fca4: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
if ( va_arg( ap, int ) )
4002fca8: f0 00 c0 00 ld [ %g3 ], %i0
4002fcac: 80 a6 20 00 cmp %i0, 0
4002fcb0: 02 80 00 22 be 4002fd38 <fcntl+0x358>
<== NEVER TAKEN
4002fcb4: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fcb8: 91 d0 20 09 ta 9
<== NOT EXECUTED
4002fcbc: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4002fcc0: 84 10 a8 00 or %g2, 0x800, %g2
<== NOT EXECUTED
4002fcc4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002fcc8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002fccc: 01 00 00 00 nop
int ret = 0;
4002fcd0: 10 bf ff 81 b 4002fad4 <fcntl+0xf4>
4002fcd4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4002fcd8: d0 07 60 08 ld [ %i5 + 8 ], %o0
ret = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
4002fcdc: 7f ff 66 cc call 4000980c <rtems_libio_to_fcntl_flags>
4002fce0: 01 00 00 00 nop
4002fce4: b0 10 00 08 mov %o0, %i0
if (ret >= 0) {
4002fce8: 80 a6 20 00 cmp %i0, 0
4002fcec: 16 bf ff 7b bge 4002fad8 <fcntl+0xf8>
<== ALWAYS TAKEN
4002fcf0: 83 2c 20 04 sll %l0, 4, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fcf4: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4002fcf8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4002fcfc: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4002fd00: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002fd04: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002fd08: 01 00 00 00 nop
<== NOT EXECUTED
}
4002fd0c: 81 c7 e0 08 ret
<== NOT EXECUTED
4002fd10: 81 e8 00 00 restore
<== NOT EXECUTED
4002fd14: f0 07 60 08 ld [ %i5 + 8 ], %i0
<== NOT EXECUTED
ret = ((rtems_libio_iop_flags(iop) & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
4002fd18: b1 36 20 0b srl %i0, 0xb, %i0
<== NOT EXECUTED
4002fd1c: 10 bf ff 6e b 4002fad4 <fcntl+0xf4>
<== NOT EXECUTED
4002fd20: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
errno = EINVAL;
4002fd24: 7f ff c3 d1 call 40020c68 <__errno>
<== NOT EXECUTED
4002fd28: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002fd2c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4002fd30: 10 bf ff 51 b 4002fa74 <fcntl+0x94>
<== NOT EXECUTED
4002fd34: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fd38: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val & arg;
4002fd3c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4002fd40: 84 08 b7 ff and %g2, -2049, %g2
<== NOT EXECUTED
4002fd44: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002fd48: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002fd4c: 01 00 00 00 nop
<== NOT EXECUTED
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
4002fd50: 10 bf ff 62 b 4002fad8 <fcntl+0xf8>
<== NOT EXECUTED
4002fd54: 83 2c 20 04 sll %l0, 4, %g1
<== NOT EXECUTED
rtems_libio_fcntl_flags( oflag )
4002fd58: 7f ff 66 a0 call 400097d8 <rtems_libio_fcntl_flags>
<== NOT EXECUTED
4002fd5c: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
rv = rtems_libio_iop_to_descriptor( diop );
4002fd60: b0 26 80 1c sub %i2, %i4, %i0
<== NOT EXECUTED
_Atomic_Store_uint(
4002fd64: 90 12 21 00 or %o0, 0x100, %o0
<== NOT EXECUTED
4002fd68: 83 3e 20 04 sra %i0, 4, %g1
<== NOT EXECUTED
*obj = desired;
4002fd6c: d0 26 a0 08 st %o0, [ %i2 + 8 ]
<== NOT EXECUTED
4002fd70: 31 2a aa aa sethi %hi(0xaaaaa800), %i0
<== NOT EXECUTED
4002fd74: b0 16 22 ab or %i0, 0x2ab, %i0 ! aaaaaaab <RAM_END+0x6a6aaaab>
<== NOT EXECUTED
4002fd78: 10 bf ff dc b 4002fce8 <fcntl+0x308>
<== NOT EXECUTED
4002fd7c: b0 58 40 18 smul %g1, %i0, %i0
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
4002fd80: 7f ff c3 ba call 40020c68 <__errno>
<== NOT EXECUTED
4002fd84: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002fd88: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4002fd8c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4002fd90: 81 c7 e0 08 ret
<== NOT EXECUTED
4002fd94: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002fd98: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4002fd9c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4002fda0: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4002fda4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002fda8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4002fdac: 01 00 00 00 nop
<== NOT EXECUTED
4002fdb0: 7f ff c3 ae call 40020c68 <__errno>
<== NOT EXECUTED
4002fdb4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
4002fdb8: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4002fdbc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4002fdc0: 81 c7 e0 08 ret
<== NOT EXECUTED
4002fdc4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
4002fdc8: 7f ff c3 a8 call 40020c68 <__errno>
<== NOT EXECUTED
4002fdcc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002fdd0: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4002fdd4: 10 bf ff 28 b 4002fa74 <fcntl+0x94>
<== NOT EXECUTED
4002fdd8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004d98 <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
40004d98: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
int rv;
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40004d9c: 03 10 00 ea sethi %hi(0x4003a800), %g1
40004da0: c2 00 60 c0 ld [ %g1 + 0xc0 ], %g1 ! 4003a8c0 <rtems_libio_number_iops>
40004da4: 80 a6 00 01 cmp %i0, %g1
40004da8: 1a 80 00 24 bcc 40004e38 <fdatasync+0xa0>
<== NEVER TAKEN
40004dac: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
40004db0: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40004db4: 31 10 01 05 sethi %hi(0x40041400), %i0
<== NOT EXECUTED
40004db8: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40004dbc: b0 16 20 98 or %i0, 0x98, %i0
<== NOT EXECUTED
40004dc0: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004dc4: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40004dc8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40004dcc: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40004dd0: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004dd4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004dd8: 01 00 00 00 nop
40004ddc: 84 08 a1 04 and %g2, 0x104, %g2
40004de0: 80 a0 a1 04 cmp %g2, 0x104
40004de4: 12 80 00 0f bne 40004e20 <fdatasync+0x88>
<== NEVER TAKEN
40004de8: 01 00 00 00 nop
/*
* Now process the fdatasync().
*/
rv = (*iop->pathinfo.handlers->fdatasync_h)( iop );
40004dec: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40004df0: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40004df4: 9f c0 40 00 call %g1
40004df8: 90 10 00 1d mov %i5, %o0
40004dfc: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004e00: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40004e04: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40004e08: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40004e0c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004e10: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004e14: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
40004e18: 81 c7 e0 08 ret
40004e1c: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004e20: 91 d0 20 09 ta 9
<== NOT EXECUTED
40004e24: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40004e28: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40004e2c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004e30: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004e34: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40004e38: 40 00 9c 6a call 4002bfe0 <__errno>
<== NOT EXECUTED
40004e3c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40004e40: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40004e44: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004e48: 81 c7 e0 08 ret
<== NOT EXECUTED
40004e4c: 81 e8 00 00 restore
<== NOT EXECUTED
40011b2c <flockfile>:
* This is a non-functional stub
*/
void flockfile(FILE* file)
{
(void) file;
}
40011b2c: 81 c3 e0 08 retl
<== NOT EXECUTED
40011b30: 01 00 00 00 nop
<== NOT EXECUTED
40004f60 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40004f60: 9d e3 bf a0 save %sp, -96, %sp
if ( !ptr )
40004f64: ba 96 20 00 orcc %i0, 0, %i5
40004f68: 02 80 00 0d be 40004f9c <free+0x3c>
40004f6c: 01 00 00 00 nop
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _Malloc_System_state() != MALLOC_SYSTEM_STATE_NORMAL ) {
40004f70: 40 00 00 e0 call 400052f0 <_Malloc_System_state>
40004f74: 01 00 00 00 nop
40004f78: 80 a2 20 00 cmp %o0, 0
40004f7c: 12 80 00 0a bne 40004fa4 <free+0x44>
40004f80: 03 10 00 56 sethi %hi(0x40015800), %g1
_Malloc_Deferred_free(ptr);
return;
}
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
40004f84: d0 00 60 8c ld [ %g1 + 0x8c ], %o0 ! 4001588c <RTEMS_Malloc_Heap>
40004f88: 40 00 11 67 call 40009524 <_Protected_heap_Free>
40004f8c: 92 10 00 1d mov %i5, %o1
40004f90: 80 a2 20 00 cmp %o0, 0
40004f94: 02 80 00 06 be 40004fac <free+0x4c>
40004f98: 92 10 00 1d mov %i5, %o1
rtems_fatal( RTEMS_FATAL_SOURCE_INVALID_HEAP_FREE, (rtems_fatal_code) ptr );
}
}
40004f9c: 81 c7 e0 08 ret
40004fa0: 81 e8 00 00 restore
_Malloc_Deferred_free(ptr);
40004fa4: 40 00 01 35 call 40005478 <_Malloc_Deferred_free>
40004fa8: 81 e8 00 00 restore
40004fac: 40 00 0b df call 40007f28 <_Terminate>
40004fb0: 90 10 20 0c mov 0xc, %o0
40004fb4: 01 00 00 00 nop
<== NOT EXECUTED
40005a00 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
40005a00: 9d e3 bf a0 save %sp, -96, %sp
int rv;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
40005a04: 80 a6 60 00 cmp %i1, 0
40005a08: 02 80 00 32 be 40005ad0 <fstat+0xd0>
<== NEVER TAKEN
40005a0c: 03 10 00 52 sethi %hi(0x40014800), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
LIBIO_GET_IOP( fd, iop );
40005a10: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1 ! 40014af8 <rtems_libio_number_iops>
40005a14: 80 a6 00 01 cmp %i0, %g1
40005a18: 1a 80 00 28 bcc 40005ab8 <fstat+0xb8>
<== NEVER TAKEN
40005a1c: 91 2e 20 01 sll %i0, 1, %o0
<== NOT EXECUTED
40005a20: 39 10 00 5f sethi %hi(0x40017c00), %i4
<== NOT EXECUTED
40005a24: b0 02 00 18 add %o0, %i0, %i0
<== NOT EXECUTED
40005a28: b8 17 22 a8 or %i4, 0x2a8, %i4
<== NOT EXECUTED
40005a2c: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
40005a30: ba 06 00 1c add %i0, %i4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005a34: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40005a38: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40005a3c: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40005a40: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005a44: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005a48: 01 00 00 00 nop
40005a4c: 80 88 a1 00 btst 0x100, %g2
40005a50: 02 80 00 14 be 40005aa0 <fstat+0xa0>
<== NEVER TAKEN
40005a54: 94 10 20 60 mov 0x60, %o2
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
40005a58: 92 10 20 00 clr %o1
40005a5c: 40 00 35 e1 call 400131e0 <memset>
40005a60: 90 10 00 19 mov %i1, %o0
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
40005a64: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40005a68: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40005a6c: 90 06 20 0c add %i0, 0xc, %o0
40005a70: 92 10 00 19 mov %i1, %o1
40005a74: 9f c0 40 00 call %g1
40005a78: 90 07 00 08 add %i4, %o0, %o0
40005a7c: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005a80: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005a84: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005a88: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005a8c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005a90: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005a94: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
40005a98: 81 c7 e0 08 ret
40005a9c: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005aa0: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005aa4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005aa8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005aac: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005ab0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ab4: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
40005ab8: 40 00 35 51 call 40012ffc <__errno>
<== NOT EXECUTED
40005abc: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005ac0: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005ac4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005ac8: 81 c7 e0 08 ret
<== NOT EXECUTED
40005acc: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
40005ad0: 40 00 35 4b call 40012ffc <__errno>
<== NOT EXECUTED
40005ad4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005ad8: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
40005adc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005ae0: 81 c7 e0 08 ret
<== NOT EXECUTED
40005ae4: 81 e8 00 00 restore
<== NOT EXECUTED
40004e84 <fsync>:
* POSIX 1003.1b 6.6.1 - Synchronize the State of a File
*/
int fsync(
int fd
)
{
40004e84: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
int rv;
LIBIO_GET_IOP( fd, iop );
40004e88: 03 10 00 53 sethi %hi(0x40014c00), %g1
40004e8c: c2 00 61 b0 ld [ %g1 + 0x1b0 ], %g1 ! 40014db0 <rtems_libio_number_iops>
40004e90: 80 a6 00 01 cmp %i0, %g1
40004e94: 1a 80 00 23 bcc 40004f20 <fsync+0x9c>
<== NEVER TAKEN
40004e98: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
40004e9c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40004ea0: 31 10 00 5f sethi %hi(0x40017c00), %i0
<== NOT EXECUTED
40004ea4: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40004ea8: b0 16 20 c8 or %i0, 0xc8, %i0
<== NOT EXECUTED
40004eac: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004eb0: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40004eb4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40004eb8: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40004ebc: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004ec0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004ec4: 01 00 00 00 nop
40004ec8: 80 88 a1 00 btst 0x100, %g2
40004ecc: 02 80 00 0f be 40004f08 <fsync+0x84>
<== NEVER TAKEN
40004ed0: 01 00 00 00 nop
/*
* Now process the fsync().
*/
rv = (*iop->pathinfo.handlers->fsync_h)( iop );
40004ed4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40004ed8: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
40004edc: 9f c0 40 00 call %g1
40004ee0: 90 10 00 1d mov %i5, %o0
40004ee4: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004ee8: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40004eec: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40004ef0: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40004ef4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004ef8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004efc: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
40004f00: 81 c7 e0 08 ret
40004f04: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004f08: 91 d0 20 09 ta 9
<== NOT EXECUTED
40004f0c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40004f10: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40004f14: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004f18: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004f1c: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
40004f20: 40 00 37 68 call 40012cc0 <__errno>
<== NOT EXECUTED
40004f24: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40004f28: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40004f2c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004f30: 81 c7 e0 08 ret
<== NOT EXECUTED
40004f34: 81 e8 00 00 restore
<== NOT EXECUTED
400108bc <ftruncate>:
#include <unistd.h>
#include <rtems/libio_.h>
int ftruncate( int fd, off_t length )
{
400108bc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if ( length >= 0 ) {
400108c0: 80 a6 60 00 cmp %i1, 0
400108c4: 06 80 00 39 bl 400109a8 <ftruncate+0xec>
<== NEVER TAKEN
400108c8: 03 10 00 4f sethi %hi(0x40013c00), %g1
rtems_libio_t *iop;
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
400108cc: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 40013e58 <rtems_libio_number_iops>
400108d0: 80 a6 00 01 cmp %i0, %g1
400108d4: 1a 80 00 1f bcc 40010950 <ftruncate+0x94>
<== NEVER TAKEN
400108d8: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
400108dc: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400108e0: 31 10 00 5b sethi %hi(0x40016c00), %i0
<== NOT EXECUTED
400108e4: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400108e8: b0 16 20 f8 or %i0, 0xf8, %i0
<== NOT EXECUTED
400108ec: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400108f0: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400108f4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400108f8: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400108fc: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010900: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40010904: 01 00 00 00 nop
40010908: 82 08 a1 04 and %g2, 0x104, %g1
4001090c: 80 a0 61 04 cmp %g1, 0x104
40010910: 12 80 00 16 bne 40010968 <ftruncate+0xac>
<== NEVER TAKEN
40010914: 92 10 00 19 mov %i1, %o1
rv = (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
40010918: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4001091c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40010920: 94 10 00 1a mov %i2, %o2
40010924: 9f c0 40 00 call %g1
40010928: 90 10 00 1d mov %i5, %o0
4001092c: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40010930: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40010934: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40010938: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4001093c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010940: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40010944: 01 00 00 00 nop
40010948: 81 c7 e0 08 ret
4001094c: 81 e8 00 00 restore
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
40010950: 40 00 06 c9 call 40012474 <__errno>
<== NOT EXECUTED
40010954: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40010958: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4001095c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40010960: 81 c7 e0 08 ret
<== NOT EXECUTED
40010964: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40010968: 91 d0 20 09 ta 9
<== NOT EXECUTED
4001096c: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
40010970: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
40010974: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010978: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001097c: 01 00 00 00 nop
<== NOT EXECUTED
40010980: 84 08 a1 00 and %g2, 0x100, %g2
<== NOT EXECUTED
40010984: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
40010988: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4001098c: 40 00 06 ba call 40012474 <__errno>
<== NOT EXECUTED
40010990: ba 60 20 00 subx %g0, 0, %i5
<== NOT EXECUTED
40010994: ba 0f 60 0d and %i5, 0xd, %i5
<== NOT EXECUTED
40010998: ba 07 60 09 add %i5, 9, %i5
<== NOT EXECUTED
4001099c: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
400109a0: 81 c7 e0 08 ret
<== NOT EXECUTED
400109a4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
} else {
errno = EINVAL;
400109a8: 40 00 06 b3 call 40012474 <__errno>
<== NOT EXECUTED
400109ac: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400109b0: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400109b4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
400109b8: 81 c7 e0 08 ret
<== NOT EXECUTED
400109bc: 81 e8 00 00 restore
<== NOT EXECUTED
40011bd4 <funlockfile>:
* This is a non-functional stub
*/
void funlockfile(FILE* file)
{
(void) file;
}
40011bd4: 81 c3 e0 08 retl
<== NOT EXECUTED
40011bd8: 01 00 00 00 nop
<== NOT EXECUTED
40004fb8 <getchark>:
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
40004fb8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( BSP_poll_char )
40004fbc: 03 10 00 57 sethi %hi(0x40015c00), %g1
<== NOT EXECUTED
40004fc0: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 40015c88 <BSP_poll_char>
<== NOT EXECUTED
40004fc4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40004fc8: 02 80 00 06 be 40004fe0 <getchark+0x28>
<== NOT EXECUTED
40004fcc: 01 00 00 00 nop
<== NOT EXECUTED
return (*BSP_poll_char)();
40004fd0: 9f c2 00 00 call %o0
<== NOT EXECUTED
40004fd4: 01 00 00 00 nop
<== NOT EXECUTED
40004fd8: 81 c7 e0 08 ret
<== NOT EXECUTED
40004fdc: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
return -1;
}
40004fe0: 81 c7 e0 08 ret
<== NOT EXECUTED
40004fe4: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
4002fdec <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
4002fdec: 9d e3 bf 40 save %sp, -192, %sp
4002fdf0: 91 2e 20 01 sll %i0, 1, %o0
st.st_mode = 0;
4002fdf4: c0 27 bf ac clr [ %fp + -84 ]
4002fdf8: b0 02 00 18 add %o0, %i0, %i0
return &rtems_libio_iops[ fd ];
4002fdfc: 11 10 01 3a sethi %hi(0x4004e800), %o0
4002fe00: b1 2e 20 04 sll %i0, 4, %i0
4002fe04: 90 12 20 68 or %o0, 0x68, %o0
4002fe08: ba 06 00 08 add %i0, %o0, %i5
(void) ( *loc->handlers->fstat_h )( loc, &st );
4002fe0c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4002fe10: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_location_type( &iop->pathinfo );
4002fe14: b0 06 20 0c add %i0, 0xc, %i0
4002fe18: 92 07 bf a0 add %fp, -96, %o1
4002fe1c: 9f c0 40 00 call %g1
4002fe20: 90 02 00 18 add %o0, %i0, %o0
if ( !S_ISDIR( type ) )
4002fe24: 05 00 00 3c sethi %hi(0xf000), %g2
4002fe28: c2 07 bf ac ld [ %fp + -84 ], %g1
4002fe2c: 82 08 40 02 and %g1, %g2, %g1
4002fe30: 05 00 00 10 sethi %hi(0x4000), %g2
4002fe34: 80 a0 40 02 cmp %g1, %g2
4002fe38: 12 80 00 09 bne 4002fe5c <getdents+0x70>
<== NEVER TAKEN
4002fe3c: 94 10 00 1a mov %i2, %o2
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
4002fe40: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4002fe44: c2 00 60 08 ld [ %g1 + 8 ], %g1
4002fe48: 92 10 00 19 mov %i1, %o1
4002fe4c: 9f c0 40 00 call %g1
4002fe50: 90 10 00 1d mov %i5, %o0
}
4002fe54: 81 c7 e0 08 ret
4002fe58: 91 e8 00 08 restore %g0, %o0, %o0
rtems_set_errno_and_return_minus_one( ENOTDIR );
4002fe5c: 7f ff c3 83 call 40020c68 <__errno>
<== NOT EXECUTED
4002fe60: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002fe64: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
4002fe68: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4002fe6c: 81 c7 e0 08 ret
<== NOT EXECUTED
4002fe70: 81 e8 00 00 restore
<== NOT EXECUTED
4000cd78 <getgrent>:
}
struct group *getgrent(void)
{
4000cd78: 9d e3 bf a0 save %sp, -96, %sp
grp_context *ctx = grp_get_context();
4000cd7c: 7f ff ff ee call 4000cd34 <grp_get_context>
4000cd80: 01 00 00 00 nop
if (ctx == NULL)
4000cd84: 80 a2 20 00 cmp %o0, 0
4000cd88: 02 80 00 10 be 4000cdc8 <getgrent+0x50>
<== NEVER TAKEN
4000cd8c: 01 00 00 00 nop
return NULL;
if (ctx->fp == NULL)
4000cd90: c2 02 00 00 ld [ %o0 ], %g1
4000cd94: 80 a0 60 00 cmp %g1, 0
4000cd98: 02 80 00 0c be 4000cdc8 <getgrent+0x50>
<== NEVER TAKEN
4000cd9c: 94 02 20 04 add %o0, 4, %o2
return NULL;
if (!_libcsupport_scangr(ctx->fp, &ctx->grp, ctx->buf, sizeof(ctx->buf)))
4000cda0: b0 02 21 04 add %o0, 0x104, %i0
4000cda4: 96 10 21 00 mov 0x100, %o3
4000cda8: 92 10 00 18 mov %i0, %o1
4000cdac: 7f ff e2 3e call 400056a4 <_libcsupport_scangr>
4000cdb0: 90 10 00 01 mov %g1, %o0
4000cdb4: 80 a2 20 00 cmp %o0, 0
4000cdb8: 02 80 00 04 be 4000cdc8 <getgrent+0x50>
4000cdbc: 01 00 00 00 nop
return NULL;
return &ctx->grp;
}
4000cdc0: 81 c7 e0 08 ret
4000cdc4: 81 e8 00 00 restore
return NULL;
4000cdc8: 81 c7 e0 08 ret
4000cdcc: 91 e8 20 00 restore %g0, 0, %o0
40011c44 <getpwnam>:
static struct passwd pwent;
struct passwd *getpwnam(
const char *name
)
{
40011c44: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
40011c48: 96 10 20 c8 mov 0xc8, %o3
<== NOT EXECUTED
40011c4c: 98 07 bf fc add %fp, -4, %o4
<== NOT EXECUTED
40011c50: 15 10 01 ae sethi %hi(0x4006b800), %o2
<== NOT EXECUTED
40011c54: 13 10 01 ae sethi %hi(0x4006b800), %o1
<== NOT EXECUTED
40011c58: 94 12 a2 38 or %o2, 0x238, %o2
<== NOT EXECUTED
40011c5c: 92 12 62 1c or %o1, 0x21c, %o1
<== NOT EXECUTED
40011c60: 40 00 04 54 call 40012db0 <getpwnam_r>
<== NOT EXECUTED
40011c64: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40011c68: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40011c6c: 12 80 00 05 bne 40011c80 <getpwnam+0x3c>
<== NOT EXECUTED
40011c70: 01 00 00 00 nop
<== NOT EXECUTED
return NULL;
return p;
40011c74: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
40011c78: 81 c7 e0 08 ret
<== NOT EXECUTED
40011c7c: 81 e8 00 00 restore
<== NOT EXECUTED
}
40011c80: 81 c7 e0 08 ret
<== NOT EXECUTED
40011c84: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40005018 <gettimeofday>:
*/
int gettimeofday(
struct timeval *__restrict tp,
void *__restrict __tz RTEMS_UNUSED
)
{
40005018: 9d e3 bf a0 save %sp, -96, %sp
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
4000501c: 80 a6 20 00 cmp %i0, 0
40005020: 02 80 00 06 be 40005038 <gettimeofday+0x20>
<== NEVER TAKEN
40005024: 90 10 00 18 mov %i0, %o0
RTEMS_INLINE_ROUTINE void _TOD_Get_timeval(
struct timeval *time
)
{
_Timecounter_Microtime( time );
40005028: 40 00 0f 6e call 40008de0 <_Timecounter_Microtime>
4000502c: 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;
}
40005030: 81 c7 e0 08 ret
40005034: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EFAULT );
40005038: 40 00 35 0f call 40012474 <__errno>
<== NOT EXECUTED
4000503c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005040: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
40005044: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005048: 81 c7 e0 08 ret
<== NOT EXECUTED
4000504c: 81 e8 00 00 restore
<== NOT EXECUTED
40005088 <ioctl>:
int ioctl(
int fd,
ioctl_command_t command,
...
)
{
40005088: 9d e3 bf 98 save %sp, -104, %sp
rtems_libio_t *iop;
void *buffer;
LIBIO_GET_IOP( fd, iop );
va_start(ap, command);
4000508c: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
LIBIO_GET_IOP( fd, iop );
40005090: 03 10 00 4f sethi %hi(0x40013c00), %g1
va_start(ap, command);
40005094: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40005098: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
LIBIO_GET_IOP( fd, iop );
4000509c: c2 00 62 58 ld [ %g1 + 0x258 ], %g1
400050a0: 80 a6 00 01 cmp %i0, %g1
400050a4: 1a 80 00 27 bcc 40005140 <ioctl+0xb8>
400050a8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
400050ac: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
400050b0: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400050b4: 31 10 00 5b sethi %hi(0x40016c00), %i0
<== NOT EXECUTED
400050b8: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400050bc: b0 16 20 f8 or %i0, 0xf8, %i0
<== NOT EXECUTED
400050c0: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400050c4: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400050c8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400050cc: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400050d0: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400050d4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400050d8: 01 00 00 00 nop
400050dc: 80 88 a1 00 btst 0x100, %g2
400050e0: 02 80 00 12 be 40005128 <ioctl+0xa0>
<== NEVER TAKEN
400050e4: 84 07 a0 4c add %fp, 0x4c, %g2
buffer = va_arg(ap, void *);
/*
* Now process the ioctl().
*/
rc = (*iop->pathinfo.handlers->ioctl_h)( iop, command, buffer );
400050e8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400050ec: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
400050f0: d4 07 a0 4c ld [ %fp + 0x4c ], %o2
400050f4: 92 10 00 19 mov %i1, %o1
va_start(ap, command);
400050f8: c4 27 bf fc st %g2, [ %fp + -4 ]
rc = (*iop->pathinfo.handlers->ioctl_h)( iop, command, buffer );
400050fc: 9f c0 40 00 call %g1
40005100: 90 10 00 1d mov %i5, %o0
40005104: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005108: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000510c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005110: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005114: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005118: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000511c: 01 00 00 00 nop
va_end( ap );
rtems_libio_iop_drop( iop );
return rc;
}
40005120: 81 c7 e0 08 ret
40005124: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005128: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000512c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005130: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005134: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005138: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000513c: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
40005140: 40 00 34 cd call 40012474 <__errno>
40005144: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40005148: 82 10 20 09 mov 9, %g1
4000514c: c2 22 00 00 st %g1, [ %o0 ]
40005150: 81 c7 e0 08 ret
40005154: 81 e8 00 00 restore
4000caec <issetugid>:
* Dummy version of BSD routine
*/
int issetugid (void)
{
return 0;
}
4000caec: 81 c3 e0 08 retl
<== NOT EXECUTED
4000caf0: 90 10 20 00 clr %o0
<== NOT EXECUTED
40005e20 <lseek>:
#include <unistd.h>
#include <rtems/libio_.h>
off_t lseek( int fd, off_t offset, int whence )
{
40005e20: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
off_t rv;
LIBIO_GET_IOP( fd, iop );
40005e24: 03 10 00 52 sethi %hi(0x40014800), %g1
40005e28: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1 ! 40014af8 <rtems_libio_number_iops>
40005e2c: 80 a6 00 01 cmp %i0, %g1
40005e30: 1a 80 00 26 bcc 40005ec8 <lseek+0xa8>
<== NEVER TAKEN
40005e34: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
40005e38: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40005e3c: 31 10 00 5f sethi %hi(0x40017c00), %i0
<== NOT EXECUTED
40005e40: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40005e44: b0 16 22 a8 or %i0, 0x2a8, %i0
<== NOT EXECUTED
40005e48: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005e4c: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40005e50: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40005e54: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40005e58: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005e5c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005e60: 01 00 00 00 nop
40005e64: 80 88 a1 00 btst 0x100, %g2
40005e68: 02 80 00 12 be 40005eb0 <lseek+0x90>
<== NEVER TAKEN
40005e6c: 96 10 00 1b mov %i3, %o3
rv = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
40005e70: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40005e74: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40005e78: 92 10 00 19 mov %i1, %o1
40005e7c: 94 10 00 1a mov %i2, %o2
40005e80: 9f c0 40 00 call %g1
40005e84: 90 10 00 1d mov %i5, %o0
40005e88: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
40005e8c: b2 10 00 09 mov %o1, %i1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005e90: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005e94: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005e98: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005e9c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005ea0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ea4: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
40005ea8: 81 c7 e0 08 ret
40005eac: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005eb0: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005eb4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005eb8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005ebc: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005ec0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ec4: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
40005ec8: 40 00 34 4d call 40012ffc <__errno>
<== NOT EXECUTED
40005ecc: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005ed0: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005ed4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005ed8: 81 c7 e0 08 ret
<== NOT EXECUTED
40005edc: 93 e8 3f ff restore %g0, -1, %o1
<== NOT EXECUTED
400056a4 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
400056a4: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
400056a8: 80 a6 e0 01 cmp %i3, 1
400056ac: 18 80 00 b2 bgu 40005974 <mount+0x2d0>
<== NEVER TAKEN
400056b0: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
400056b4: 40 00 2d 04 call 40010ac4 <rtems_filesystem_get_mount_handler>
400056b8: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
400056bc: a2 92 20 00 orcc %o0, 0, %l1
400056c0: 02 80 00 ad be 40005974 <mount+0x2d0>
<== NEVER TAKEN
400056c4: 80 a6 60 00 cmp %i1, 0
const char *target = target_or_null != NULL ? target_or_null : "/";
400056c8: 02 80 00 78 be 400058a8 <mount+0x204>
400056cc: 90 10 00 19 mov %i1, %o0
400056d0: 40 00 34 db call 40012a3c <strlen>
400056d4: a6 10 00 19 mov %i1, %l3
400056d8: a4 02 20 01 add %o0, 1, %l2
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
400056dc: 40 00 34 d8 call 40012a3c <strlen>
400056e0: 90 10 00 1a mov %i2, %o0
strlen( source_or_null ) + 1 : 0;
400056e4: 80 a6 20 00 cmp %i0, 0
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
400056e8: a8 02 20 01 add %o0, 1, %l4
strlen( source_or_null ) + 1 : 0;
400056ec: 02 80 00 61 be 40005870 <mount+0x1cc>
400056f0: ba 02 20 65 add %o0, 0x65, %i5
400056f4: 40 00 34 d2 call 40012a3c <strlen>
400056f8: 90 10 00 18 mov %i0, %o0
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
400056fc: 92 07 40 12 add %i5, %l2, %o1
strlen( source_or_null ) + 1 : 0;
40005700: a0 02 20 01 add %o0, 1, %l0
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
40005704: 90 10 20 01 mov 1, %o0
40005708: 7f ff fd 95 call 40004d5c <calloc>
4000570c: 92 02 40 10 add %o1, %l0, %o1
if ( mt_entry != NULL ) {
40005710: ba 92 20 00 orcc %o0, 0, %i5
40005714: 12 80 00 08 bne 40005734 <mount+0x90>
<== ALWAYS TAKEN
40005718: 84 07 60 64 add %i5, 0x64, %g2
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
4000571c: 40 00 33 56 call 40012474 <__errno>
<== NOT EXECUTED
40005720: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005724: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40005728: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000572c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005730: 81 e8 00 00 restore
<== NOT EXECUTED
memcpy( str, filesystemtype, filesystemtype_size );
40005734: 92 10 00 1a mov %i2, %o1
40005738: 94 10 00 14 mov %l4, %o2
4000573c: 40 00 33 8b call 40012568 <memcpy>
40005740: 90 10 00 02 mov %g2, %o0
mt_entry->type = str;
40005744: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
str += filesystemtype_size;
40005748: 84 02 00 14 add %o0, %l4, %g2
memcpy( str, source_or_null, source_size );
4000574c: 94 10 00 10 mov %l0, %o2
40005750: 92 10 00 18 mov %i0, %o1
40005754: 40 00 33 85 call 40012568 <memcpy>
40005758: 90 10 00 02 mov %g2, %o0
mt_entry->dev = str;
4000575c: d0 27 60 38 st %o0, [ %i5 + 0x38 ]
rtems_filesystem_global_location_t *mt_fs_root =
40005760: b4 07 60 40 add %i5, 0x40, %i2
str += source_size;
40005764: a0 02 00 10 add %o0, %l0, %l0
memcpy( str, target, target_size );
40005768: 94 10 00 12 mov %l2, %o2
4000576c: 92 10 00 13 mov %l3, %o1
40005770: 40 00 33 7e call 40012568 <memcpy>
40005774: 90 10 00 10 mov %l0, %o0
mt_entry->mounted = true;
40005778: 82 10 20 01 mov 1, %g1
4000577c: c2 2f 60 28 stb %g1, [ %i5 + 0x28 ]
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40005780: 03 10 00 50 sethi %hi(0x40014000), %g1
40005784: 82 10 62 20 or %g1, 0x220, %g1 ! 40014220 <rtems_filesystem_default_pathconf>
mt_entry->target = str;
40005788: e0 27 60 30 st %l0, [ %i5 + 0x30 ]
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize(
4000578c: 96 10 20 24 mov 0x24, %o3
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40005790: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->reference_count = 1;
40005794: 82 10 20 01 mov 1, %g1
mt_entry->mt_fs_root = mt_fs_root;
40005798: f4 27 60 24 st %i2, [ %i5 + 0x24 ]
4000579c: 94 10 20 01 mov 1, %o2
mt_fs_root->reference_count = 1;
400057a0: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
400057a4: 92 10 00 1a mov %i2, %o1
mt_fs_root->location.mt_entry = mt_entry;
400057a8: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
400057ac: 90 07 60 14 add %i5, 0x14, %o0
400057b0: 40 00 07 b7 call 4000768c <_Chain_Initialize>
400057b4: b6 0e e0 01 and %i3, 1, %i3
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
400057b8: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
400057bc: 92 10 00 1c mov %i4, %o1
400057c0: 9f c4 40 00 call %l1
400057c4: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
400057c8: b0 92 20 00 orcc %o0, 0, %i0
400057cc: 12 80 00 25 bne 40005860 <mount+0x1bc>
400057d0: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
400057d4: 02 80 00 48 be 400058f4 <mount+0x250>
400057d8: 94 10 20 1f mov 0x1f, %o2
rtems_filesystem_location_info_t *currentloc =
400057dc: 92 10 00 19 mov %i1, %o1
400057e0: 40 00 03 48 call 40006500 <rtems_filesystem_eval_path_start>
400057e4: 90 07 bf c8 add %fp, -56, %o0
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
400057e8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
400057ec: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400057f0: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
400057f4: 9f c0 80 00 call %g2
400057f8: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
400057fc: 80 a2 20 00 cmp %o0, 0
40005800: 12 80 00 63 bne 4000598c <mount+0x2e8>
<== NEVER TAKEN
40005804: 92 07 bf e0 add %fp, -32, %o1
rtems_filesystem_location_copy_and_detach(
40005808: 40 00 04 d7 call 40006b64 <rtems_filesystem_location_copy_and_detach>
4000580c: 90 07 bf b0 add %fp, -80, %o0
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40005810: 40 00 05 00 call 40006c10 <rtems_filesystem_location_transform_to_global>
40005814: 90 07 bf b0 add %fp, -80, %o0
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40005818: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000581c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
mt_entry->mt_point_node = mt_point_node;
40005820: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40005824: b8 10 00 08 mov %o0, %i4
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40005828: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
4000582c: 9f c0 40 00 call %g1
40005830: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40005834: b0 92 20 00 orcc %o0, 0, %i0
40005838: 02 80 00 20 be 400058b8 <mount+0x214>
<== ALWAYS TAKEN
4000583c: 90 10 00 1c mov %i4, %o0
rtems_filesystem_global_location_release( mt_point_node, true );
40005840: 40 00 04 84 call 40006a50 <rtems_filesystem_global_location_release>
<== NOT EXECUTED
40005844: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40005848: 40 00 03 78 call 40006628 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
4000584c: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40005850: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
40005854: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
<== NOT EXECUTED
40005858: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000585c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
free( mt_entry );
40005860: 7f ff fd c0 call 40004f60 <free>
40005864: 90 10 00 1d mov %i5, %o0
errno = EINVAL;
rv = -1;
}
return rv;
}
40005868: 81 c7 e0 08 ret
4000586c: 81 e8 00 00 restore
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
40005870: 92 07 40 12 add %i5, %l2, %o1
40005874: 7f ff fd 3a call 40004d5c <calloc>
40005878: 90 10 20 01 mov 1, %o0
if ( mt_entry != NULL ) {
4000587c: ba 92 20 00 orcc %o0, 0, %i5
40005880: 02 bf ff a7 be 4000571c <mount+0x78>
<== NEVER TAKEN
40005884: 84 07 60 64 add %i5, 0x64, %g2
memcpy( str, filesystemtype, filesystemtype_size );
40005888: 92 10 00 1a mov %i2, %o1
4000588c: 94 10 00 14 mov %l4, %o2
40005890: 90 10 00 02 mov %g2, %o0
40005894: 40 00 33 35 call 40012568 <memcpy>
40005898: b4 07 60 40 add %i5, 0x40, %i2
str += filesystemtype_size;
4000589c: a0 02 00 14 add %o0, %l4, %l0
mt_entry->type = str;
400058a0: 10 bf ff b2 b 40005768 <mount+0xc4>
400058a4: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
const char *target = target_or_null != NULL ? target_or_null : "/";
400058a8: 27 10 00 4f sethi %hi(0x40013c00), %l3
400058ac: a4 10 20 02 mov 2, %l2
400058b0: 10 bf ff 8b b 400056dc <mount+0x38>
400058b4: a6 14 e1 c8 or %l3, 0x1c8, %l3
rtems_libio_lock();
400058b8: 7f ff fe 52 call 40005200 <rtems_libio_lock>
400058bc: 01 00 00 00 nop
old_last = tail->previous;
400058c0: 03 10 00 56 sethi %hi(0x40015800), %g1
400058c4: 82 10 60 d8 or %g1, 0xd8, %g1 ! 400158d8 <rtems_filesystem_mount_table>
400058c8: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
400058cc: 86 00 60 04 add %g1, 4, %g3
tail->previous = the_node;
400058d0: fa 20 60 08 st %i5, [ %g1 + 8 ]
the_node->next = tail;
400058d4: c6 27 40 00 st %g3, [ %i5 ]
old_last->next = the_node;
400058d8: fa 20 80 00 st %i5, [ %g2 ]
rtems_libio_unlock();
400058dc: 7f ff fe 4e call 40005214 <rtems_libio_unlock>
400058e0: c4 27 60 04 st %g2, [ %i5 + 4 ]
rtems_filesystem_eval_path_cleanup( &ctx );
400058e4: 40 00 03 51 call 40006628 <rtems_filesystem_eval_path_cleanup>
400058e8: 90 07 bf c8 add %fp, -56, %o0
400058ec: 81 c7 e0 08 ret
400058f0: 81 e8 00 00 restore
rtems_libio_lock();
400058f4: 7f ff fe 43 call 40005200 <rtems_libio_lock>
400058f8: 01 00 00 00 nop
return _Chain_Immutable_head( the_chain )->next;
400058fc: 03 10 00 56 sethi %hi(0x40015800), %g1
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
40005900: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2 ! 400158d8 <rtems_filesystem_mount_table>
40005904: 82 10 60 d8 or %g1, 0xd8, %g1
40005908: 86 00 60 04 add %g1, 4, %g3
4000590c: 80 a0 80 03 cmp %g2, %g3
40005910: 12 80 00 27 bne 400059ac <mount+0x308>
<== NEVER TAKEN
40005914: 01 00 00 00 nop
old_last = tail->previous;
40005918: c6 00 60 08 ld [ %g1 + 8 ], %g3
the_node->next = tail;
4000591c: c4 27 40 00 st %g2, [ %i5 ]
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
40005920: b8 07 60 24 add %i5, 0x24, %i4
tail->previous = the_node;
40005924: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
40005928: fa 20 c0 00 st %i5, [ %g3 ]
rtems_libio_unlock();
4000592c: 7f ff fe 3a call 40005214 <rtems_libio_unlock>
40005930: c6 27 60 04 st %g3, [ %i5 + 4 ]
rtems_filesystem_global_location_t *new_fs_root =
40005934: 40 00 04 0d call 40006968 <rtems_filesystem_global_location_obtain>
40005938: 90 10 00 1c mov %i4, %o0
4000593c: b6 10 00 08 mov %o0, %i3
rtems_filesystem_global_location_t *new_fs_current =
40005940: 40 00 04 0a call 40006968 <rtems_filesystem_global_location_obtain>
40005944: 90 10 00 1c mov %i4, %o0
&rtems_filesystem_root,
40005948: 40 00 00 fa call 40005d30 <rtems_current_user_env_get>
4000594c: ba 10 00 08 mov %o0, %i5
rtems_filesystem_global_location_assign(
40005950: 92 10 00 1b mov %i3, %o1
40005954: 40 00 04 59 call 40006ab8 <rtems_filesystem_global_location_assign>
40005958: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_current,
4000595c: 40 00 00 f5 call 40005d30 <rtems_current_user_env_get>
40005960: 01 00 00 00 nop
rtems_filesystem_global_location_assign(
40005964: 40 00 04 55 call 40006ab8 <rtems_filesystem_global_location_assign>
40005968: 92 10 00 1d mov %i5, %o1
4000596c: 81 c7 e0 08 ret
40005970: 81 e8 00 00 restore
errno = EINVAL;
40005974: 40 00 32 c0 call 40012474 <__errno>
<== NOT EXECUTED
40005978: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000597c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40005980: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return rv;
40005984: 81 c7 e0 08 ret
<== NOT EXECUTED
40005988: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_eval_path_error( &ctx, EBUSY );
4000598c: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
40005990: 40 00 02 21 call 40006214 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005994: 92 10 20 10 mov 0x10, %o1
<== NOT EXECUTED
rv = -1;
40005998: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
4000599c: 40 00 03 23 call 40006628 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
400059a0: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
400059a4: 10 bf ff ac b 40005854 <mount+0x1b0>
<== NOT EXECUTED
400059a8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
errno = EINVAL;
400059ac: 40 00 32 b2 call 40012474 <__errno>
<== NOT EXECUTED
400059b0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400059b4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400059b8: 7f ff fe 17 call 40005214 <rtems_libio_unlock>
<== NOT EXECUTED
400059bc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
400059c0: 10 bf ff a5 b 40005854 <mount+0x1b0>
<== NOT EXECUTED
400059c4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
40009d80 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40009d80: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
40009d84: 90 96 60 00 orcc %i1, 0, %o0
40009d88: 02 80 00 0b be 40009db4 <mount_and_make_target_path+0x34>
<== NEVER TAKEN
40009d8c: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
40009d90: 40 00 02 83 call 4000a79c <rtems_mkdir>
40009d94: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xaf>
if (rv == 0) {
40009d98: 80 a2 20 00 cmp %o0, 0
40009d9c: 02 80 00 04 be 40009dac <mount_and_make_target_path+0x2c>
<== ALWAYS TAKEN
40009da0: 01 00 00 00 nop
} else {
errno = EINVAL;
}
return rv;
}
40009da4: 81 c7 e0 08 ret
<== NOT EXECUTED
40009da8: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
rv = mount(
40009dac: 40 00 00 08 call 40009dcc <mount>
<== NOT EXECUTED
40009db0: 81 e8 00 00 restore
errno = EINVAL;
40009db4: 40 00 5b ad call 40020c68 <__errno>
<== NOT EXECUTED
40009db8: 01 00 00 00 nop
<== NOT EXECUTED
40009dbc: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40009dc0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return rv;
40009dc4: 10 bf ff f8 b 40009da4 <mount_and_make_target_path+0x24>
<== NOT EXECUTED
40009dc8: 90 10 3f ff mov -1, %o0
<== NOT EXECUTED
40005ac4 <open>:
/**
* POSIX 1003.1 5.3.1 - Open a File
*/
int open( const char *path, int oflag, ... )
{
40005ac4: 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 );
40005ac8: 82 07 a0 50 add %fp, 0x50, %g1
va_start( ap, oflag );
40005acc: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
40005ad0: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40005ad4: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40005ad8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
iop = rtems_libio_allocate();
40005adc: 7f ff fd e0 call 4000525c <rtems_libio_allocate>
40005ae0: c2 27 bf 64 st %g1, [ %fp + -156 ]
if ( iop != NULL ) {
40005ae4: ba 92 20 00 orcc %o0, 0, %i5
40005ae8: 02 80 00 76 be 40005cc0 <open+0x1fc>
<== NEVER TAKEN
40005aec: 82 06 60 01 add %i1, 1, %g1
bool make = (oflag & O_CREAT) == O_CREAT;
40005af0: 86 0e 62 00 and %i1, 0x200, %g3
bool read_access = (rwflag & _FREAD) == _FREAD;
40005af4: 94 08 60 01 and %g1, 1, %o2
bool exclusive = (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
40005af8: 84 0e 6a 00 and %i1, 0xa00, %g2
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40005afc: 94 02 bf ff add %o2, -1, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40005b00: b8 88 60 02 andcc %g1, 2, %i4
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40005b04: 94 0a bf fc and %o2, -4, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40005b08: 02 80 00 03 be 40005b14 <open+0x50>
40005b0c: 94 02 a0 1c add %o2, 0x1c, %o2
40005b10: 94 12 a0 02 or %o2, 2, %o2
| (make ? RTEMS_FS_MAKE : 0)
40005b14: 80 a0 e0 00 cmp %g3, 0
40005b18: 32 80 00 02 bne,a 40005b20 <open+0x5c>
40005b1c: 94 12 a0 20 or %o2, 0x20, %o2
| (exclusive ? RTEMS_FS_EXCLUSIVE : 0);
40005b20: 80 a0 aa 00 cmp %g2, 0xa00
40005b24: 22 80 00 02 be,a 40005b2c <open+0x68>
40005b28: 94 12 a0 40 or %o2, 0x40, %o2
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
40005b2c: 92 10 00 18 mov %i0, %o1
40005b30: 40 00 02 74 call 40006500 <rtems_filesystem_eval_path_start>
40005b34: 90 07 bf 68 add %fp, -152, %o0
40005b38: f6 07 bf 74 ld [ %fp + -140 ], %i3
if ( rtems_filesystem_eval_path_has_token( &ctx ) ) {
40005b3c: 80 a6 e0 00 cmp %i3, 0
40005b40: 12 80 00 45 bne 40005c54 <open+0x190>
40005b44: 80 a7 20 00 cmp %i4, 0
if ( write_access ) {
40005b48: 02 80 00 0e be 40005b80 <open+0xbc>
40005b4c: c2 07 bf 90 ld [ %fp + -112 ], %g1
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
40005b50: c0 27 bf ac clr [ %fp + -84 ]
(void) ( *loc->handlers->fstat_h )( loc, &st );
40005b54: 92 07 bf a0 add %fp, -96, %o1
40005b58: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40005b5c: 9f c0 40 00 call %g1
40005b60: 90 07 bf 80 add %fp, -128, %o0
if ( S_ISDIR( type ) ) {
40005b64: 05 00 00 3c sethi %hi(0xf000), %g2
40005b68: c2 07 bf ac ld [ %fp + -84 ], %g1
40005b6c: 82 08 40 02 and %g1, %g2, %g1
40005b70: 05 00 00 10 sethi %hi(0x4000), %g2
40005b74: 80 a0 40 02 cmp %g1, %g2
40005b78: 02 80 00 4e be 40005cb0 <open+0x1ec>
<== NEVER TAKEN
40005b7c: 92 10 20 15 mov 0x15, %o1
rtems_filesystem_location_copy_and_detach(
40005b80: 92 07 bf 80 add %fp, -128, %o1
40005b84: 40 00 03 f8 call 40006b64 <rtems_filesystem_location_copy_and_detach>
40005b88: 90 07 60 0c add %i5, 0xc, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
40005b8c: 40 00 02 a7 call 40006628 <rtems_filesystem_eval_path_cleanup>
40005b90: 90 07 bf 68 add %fp, -152, %o0
_Atomic_Store_uint(
40005b94: 7f ff fd a5 call 40005228 <rtems_libio_fcntl_flags>
40005b98: 90 10 00 19 mov %i1, %o0
rv = (*iop->pathinfo.handlers->open_h)( iop, path, oflag, mode );
40005b9c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
*obj = desired;
40005ba0: d0 27 60 08 st %o0, [ %i5 + 8 ]
40005ba4: 92 10 00 18 mov %i0, %o1
40005ba8: c2 00 40 00 ld [ %g1 ], %g1
40005bac: 96 10 00 1a mov %i2, %o3
40005bb0: 94 10 00 19 mov %i1, %o2
40005bb4: 9f c0 40 00 call %g1
40005bb8: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40005bbc: b0 92 20 00 orcc %o0, 0, %i0
40005bc0: 12 80 00 13 bne 40005c0c <open+0x148>
40005bc4: 80 a6 20 00 cmp %i0, 0
int fd = rtems_libio_iop_to_descriptor( iop );
40005bc8: 31 10 00 5b sethi %hi(0x40016c00), %i0
40005bcc: 03 2a aa aa sethi %hi(0xaaaaa800), %g1
40005bd0: b0 16 20 f8 or %i0, 0xf8, %i0
40005bd4: 82 10 62 ab or %g1, 0x2ab, %g1
<== NOT EXECUTED
40005bd8: b0 27 40 18 sub %i5, %i0, %i0
<== NOT EXECUTED
40005bdc: b1 3e 20 04 sra %i0, 4, %i0
<== NOT EXECUTED
40005be0: b0 5e 00 01 smul %i0, %g1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005be4: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val | arg;
40005be8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005bec: 84 10 a1 00 or %g2, 0x100, %g2
<== NOT EXECUTED
40005bf0: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005bf4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005bf8: 01 00 00 00 nop
if ( truncate ) {
40005bfc: 80 8e 64 00 btst 0x400, %i1
40005c00: 12 80 00 07 bne 40005c1c <open+0x158>
40005c04: 92 10 20 00 clr %o1
if ( rv < 0 ) {
40005c08: 80 a6 20 00 cmp %i0, 0
40005c0c: 06 80 00 0e bl 40005c44 <open+0x180>
40005c10: 01 00 00 00 nop
}
va_end( ap );
return rv;
}
40005c14: 81 c7 e0 08 ret
40005c18: 81 e8 00 00 restore
rv = ftruncate( fd, 0 );
40005c1c: 94 10 20 00 clr %o2
40005c20: 40 00 2b 27 call 400108bc <ftruncate>
40005c24: 90 10 00 18 mov %i0, %o0
if ( rv != 0 ) {
40005c28: 80 a2 20 00 cmp %o0, 0
40005c2c: 02 bf ff f7 be 40005c08 <open+0x144>
<== ALWAYS TAKEN
40005c30: 90 10 00 1d mov %i5, %o0
(*iop->pathinfo.handlers->close_h)( iop );
40005c34: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
40005c38: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
40005c3c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005c40: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_libio_free( iop );
40005c44: 7f ff fd 9b call 400052b0 <rtems_libio_free>
40005c48: 90 10 00 1d mov %i5, %o0
40005c4c: 81 c7 e0 08 ret
40005c50: 81 e8 00 00 restore
40005c54: e0 07 bf 70 ld [ %fp + -144 ], %l0
rv = rtems_filesystem_mknod(
40005c58: 98 10 20 00 clr %o4
40005c5c: 9a 10 20 00 clr %o5
40005c60: 17 00 00 20 sethi %hi(0x8000), %o3
40005c64: 94 10 00 1b mov %i3, %o2
40005c68: 96 16 80 0b or %i2, %o3, %o3
40005c6c: 92 10 00 10 mov %l0, %o1
40005c70: 7f ff fe 4c call 400055a0 <rtems_filesystem_mknod>
40005c74: 90 07 bf 80 add %fp, -128, %o0
if ( rv == 0 ) {
40005c78: 80 a2 20 00 cmp %o0, 0
40005c7c: 02 80 00 06 be 40005c94 <open+0x1d0>
40005c80: 92 10 20 00 clr %o1
rtems_filesystem_eval_path_error( ctx, 0 );
40005c84: 40 00 01 64 call 40006214 <rtems_filesystem_eval_path_error>
40005c88: 90 07 bf 68 add %fp, -152, %o0
if ( write_access ) {
40005c8c: 10 bf ff af b 40005b48 <open+0x84>
40005c90: 80 a7 20 00 cmp %i4, 0
ctx->flags = flags;
40005c94: c0 27 bf 78 clr [ %fp + -136 ]
rtems_filesystem_eval_path_continue( ctx );
40005c98: 90 07 bf 68 add %fp, -152, %o0
ctx->path = path;
40005c9c: e0 27 bf 68 st %l0, [ %fp + -152 ]
40005ca0: 40 00 01 a5 call 40006334 <rtems_filesystem_eval_path_continue>
40005ca4: f6 27 bf 6c st %i3, [ %fp + -148 ]
if ( write_access ) {
40005ca8: 10 bf ff a8 b 40005b48 <open+0x84>
40005cac: 80 a7 20 00 cmp %i4, 0
rtems_filesystem_eval_path_error( &ctx, EISDIR );
40005cb0: 40 00 01 59 call 40006214 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005cb4: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
rtems_filesystem_location_copy_and_detach(
40005cb8: 10 bf ff b3 b 40005b84 <open+0xc0>
<== NOT EXECUTED
40005cbc: 92 07 bf 80 add %fp, -128, %o1
<== NOT EXECUTED
errno = ENFILE;
40005cc0: 40 00 31 ed call 40012474 <__errno>
<== NOT EXECUTED
40005cc4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005cc8: 82 10 20 17 mov 0x17, %g1
<== NOT EXECUTED
40005ccc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40005cd0: 81 c7 e0 08 ret
<== NOT EXECUTED
40005cd4: 81 e8 00 00 restore
<== NOT EXECUTED
40007c7c <posix_memalign>:
void **pointer,
size_t alignment,
size_t size
)
{
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
40007c7c: 84 02 7f ff add %o1, -1, %g2
40007c80: 80 88 80 09 btst %g2, %o1
40007c84: 12 80 00 07 bne 40007ca0 <posix_memalign+0x24>
<== NEVER TAKEN
40007c88: 80 a2 60 03 cmp %o1, 3
40007c8c: 08 80 00 05 bleu 40007ca0 <posix_memalign+0x24>
40007c90: 01 00 00 00 nop
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
40007c94: 82 13 c0 00 mov %o7, %g1
40007c98: 40 00 00 d2 call 40007fe0 <rtems_memalign>
40007c9c: 9e 10 40 00 mov %g1, %o7
}
40007ca0: 81 c3 e0 08 retl
40007ca4: 90 10 20 16 mov 0x16, %o0
400069c4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
400069c4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
400069c8: 80 a6 60 00 cmp %i1, 0
400069cc: 02 80 00 32 be 40006a94 <read+0xd0>
<== NEVER TAKEN
400069d0: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
400069d4: 02 80 00 22 be 40006a5c <read+0x98>
400069d8: 84 10 20 00 clr %g2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
400069dc: 03 10 00 52 sethi %hi(0x40014800), %g1
400069e0: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1 ! 40014af8 <rtems_libio_number_iops>
400069e4: 80 a6 00 01 cmp %i0, %g1
400069e8: 1a 80 00 25 bcc 40006a7c <read+0xb8>
<== NEVER TAKEN
400069ec: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
400069f0: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400069f4: 31 10 00 5f sethi %hi(0x40017c00), %i0
<== NOT EXECUTED
400069f8: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400069fc: b0 16 22 a8 or %i0, 0x2a8, %i0
<== NOT EXECUTED
40006a00: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006a04: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40006a08: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40006a0c: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40006a10: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006a14: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006a18: 01 00 00 00 nop
40006a1c: 84 08 a1 02 and %g2, 0x102, %g2
40006a20: 80 a0 a1 02 cmp %g2, 0x102
40006a24: 12 80 00 10 bne 40006a64 <read+0xa0>
<== NEVER TAKEN
40006a28: 94 10 00 1a mov %i2, %o2
/*
* Now process the read().
*/
n = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
40006a2c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40006a30: c2 00 60 08 ld [ %g1 + 8 ], %g1
40006a34: 92 10 00 19 mov %i1, %o1
40006a38: 9f c0 40 00 call %g1
40006a3c: 90 10 00 1d mov %i5, %o0
40006a40: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006a44: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40006a48: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
40006a4c: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
40006a50: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006a54: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006a58: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return n;
}
40006a5c: 81 c7 e0 08 ret
40006a60: 91 e8 00 02 restore %g0, %g2, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006a64: 91 d0 20 09 ta 9
<== NOT EXECUTED
40006a68: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40006a6c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40006a70: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006a74: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006a78: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
40006a7c: 40 00 31 60 call 40012ffc <__errno>
<== NOT EXECUTED
40006a80: 01 00 00 00 nop
<== NOT EXECUTED
40006a84: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
40006a88: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40006a8c: 10 bf ff f4 b 40006a5c <read+0x98>
<== NOT EXECUTED
40006a90: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_libio_check_buffer( buffer );
40006a94: 40 00 31 5a call 40012ffc <__errno>
<== NOT EXECUTED
40006a98: 01 00 00 00 nop
<== NOT EXECUTED
40006a9c: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40006aa0: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40006aa4: 10 bf ff ee b 40006a5c <read+0x98>
<== NOT EXECUTED
40006aa8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005d84 <realloc>:
return new_ptr;
}
void *realloc( void *ptr, size_t size )
{
40005d84: 9d e3 bf 98 save %sp, -104, %sp
Heap_Control *heap;
Heap_Resize_status status;
uintptr_t old_size;
uintptr_t avail_size;
if ( size == 0 ) {
40005d88: 80 a6 60 00 cmp %i1, 0
40005d8c: 02 80 00 40 be 40005e8c <realloc+0x108>
<== NEVER TAKEN
40005d90: 80 a6 20 00 cmp %i0, 0
free( ptr );
return NULL;
}
if ( ptr == NULL ) {
40005d94: 02 80 00 34 be 40005e64 <realloc+0xe0>
40005d98: 03 10 00 56 sethi %hi(0x40015800), %g1
return malloc( size );
}
heap = RTEMS_Malloc_Heap;
switch ( _Malloc_System_state() ) {
40005d9c: 7f ff fd 55 call 400052f0 <_Malloc_System_state>
40005da0: fa 00 60 8c ld [ %g1 + 0x8c ], %i5 ! 4001588c <RTEMS_Malloc_Heap>
40005da4: 80 a2 20 00 cmp %o0, 0
40005da8: 02 80 00 21 be 40005e2c <realloc+0xa8>
40005dac: 01 00 00 00 nop
40005db0: 80 a2 20 01 cmp %o0, 1
40005db4: 32 80 00 2e bne,a 40005e6c <realloc+0xe8>
<== NEVER TAKEN
40005db8: 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 );
40005dbc: 98 07 bf fc add %fp, -4, %o4
40005dc0: 96 07 bf f8 add %fp, -8, %o3
40005dc4: 94 10 00 19 mov %i1, %o2
40005dc8: 92 10 00 18 mov %i0, %o1
40005dcc: 40 00 08 0d call 40007e00 <_Heap_Resize_block>
40005dd0: 90 10 00 1d mov %i5, %o0
40005dd4: b8 10 00 08 mov %o0, %i4
break;
default:
return NULL;
}
switch ( status ) {
40005dd8: 80 a7 20 00 cmp %i4, 0
40005ddc: 02 80 00 12 be 40005e24 <realloc+0xa0>
40005de0: ba 10 00 18 mov %i0, %i5
40005de4: 80 a7 20 01 cmp %i4, 1
40005de8: 12 80 00 23 bne 40005e74 <realloc+0xf0>
40005dec: f8 07 bf f8 ld [ %fp + -8 ], %i4
new_ptr = malloc( new_size );
40005df0: 7f ff fd d1 call 40005534 <malloc>
40005df4: 90 10 00 19 mov %i1, %o0
if ( new_ptr == NULL ) {
40005df8: ba 92 20 00 orcc %o0, 0, %i5
40005dfc: 02 80 00 0a be 40005e24 <realloc+0xa0>
40005e00: 80 a7 00 19 cmp %i4, %i1
memcpy( new_ptr, old_ptr, ( new_size < old_size ) ? new_size : old_size );
40005e04: 08 80 00 03 bleu 40005e10 <realloc+0x8c>
<== ALWAYS TAKEN
40005e08: 94 10 00 1c mov %i4, %o2
40005e0c: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
40005e10: 92 10 00 18 mov %i0, %o1
40005e14: 40 00 31 d5 call 40012568 <memcpy>
40005e18: 90 10 00 1d mov %i5, %o0
free( old_ptr );
40005e1c: 7f ff fc 51 call 40004f60 <free>
40005e20: 90 10 00 18 mov %i0, %o0
return new_alloc( ptr, size, old_size );
default:
errno = EINVAL;
return NULL;
}
}
40005e24: 81 c7 e0 08 ret
40005e28: 91 e8 00 1d restore %g0, %i5, %o0
_RTEMS_Lock_allocator();
40005e2c: 40 00 05 f6 call 40007604 <_RTEMS_Lock_allocator>
40005e30: 01 00 00 00 nop
_Malloc_Process_deferred_frees();
40005e34: 7f ff fd 3e call 4000532c <_Malloc_Process_deferred_frees>
40005e38: 01 00 00 00 nop
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
40005e3c: 98 07 bf fc add %fp, -4, %o4
40005e40: 96 07 bf f8 add %fp, -8, %o3
40005e44: 94 10 00 19 mov %i1, %o2
40005e48: 92 10 00 18 mov %i0, %o1
40005e4c: 40 00 07 ed call 40007e00 <_Heap_Resize_block>
40005e50: 90 10 00 1d mov %i5, %o0
_RTEMS_Unlock_allocator();
40005e54: 40 00 05 f1 call 40007618 <_RTEMS_Unlock_allocator>
40005e58: b8 10 00 08 mov %o0, %i4
break;
40005e5c: 10 bf ff e0 b 40005ddc <realloc+0x58>
40005e60: 80 a7 20 00 cmp %i4, 0
return malloc( size );
40005e64: 7f ff fd b4 call 40005534 <malloc>
40005e68: 91 e8 00 19 restore %g0, %i1, %o0
}
40005e6c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005e70: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
errno = EINVAL;
40005e74: 40 00 31 80 call 40012474 <__errno>
40005e78: ba 10 20 00 clr %i5
40005e7c: 82 10 20 16 mov 0x16, %g1
40005e80: c2 22 00 00 st %g1, [ %o0 ]
}
40005e84: 81 c7 e0 08 ret
40005e88: 91 e8 00 1d restore %g0, %i5, %o0
free( ptr );
40005e8c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40005e90: 7f ff fc 34 call 40004f60 <free>
<== NOT EXECUTED
40005e94: ba 10 20 00 clr %i5
<== NOT EXECUTED
return NULL;
40005e98: 30 bf ff e3 b,a 40005e24 <realloc+0xa0>
<== NOT EXECUTED
400053cc <rmdir>:
/**
* POSIX 1003.1b - 5.2.2 - Remove a Directory
*/
int rmdir( const char *path )
{
400053cc: 9d e3 be f0 save %sp, -272, %sp
int eval_flags = RTEMS_FS_REJECT_TERMINAL_DOT;
rtems_filesystem_location_info_t parentloc;
int parent_eval_flags = RTEMS_FS_PERMS_WRITE
| RTEMS_FS_PERMS_EXEC
| RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
400053d0: 98 10 20 1b mov 0x1b, %o4
400053d4: 94 10 21 00 mov 0x100, %o2
400053d8: 92 10 00 18 mov %i0, %o1
400053dc: 96 07 bf 50 add %fp, -176, %o3
400053e0: 40 00 02 36 call 40005cb8 <rtems_filesystem_eval_path_start_with_parent>
400053e4: 90 07 bf 68 add %fp, -152, %o0
path,
eval_flags,
&parentloc,
parent_eval_flags
);
const rtems_filesystem_operations_table *ops = currentloc->mt_entry->ops;
400053e8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
400053ec: f8 00 60 0c ld [ %g1 + 0xc ], %i4
(void) ( *loc->handlers->fstat_h )( loc, &st );
400053f0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
st.st_mode = 0;
400053f4: c0 27 bf ac clr [ %fp + -84 ]
const rtems_filesystem_location_info_t *currentloc =
400053f8: ba 10 00 08 mov %o0, %i5
(void) ( *loc->handlers->fstat_h )( loc, &st );
400053fc: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40005400: 9f c0 40 00 call %g1
40005404: 92 07 bf a0 add %fp, -96, %o1
mode_t type = rtems_filesystem_location_type( currentloc );
if ( S_ISDIR( type ) ) {
40005408: 05 00 00 3c sethi %hi(0xf000), %g2
4000540c: c2 07 bf ac ld [ %fp + -84 ], %g1
40005410: 82 08 40 02 and %g1, %g2, %g1
40005414: 05 00 00 10 sethi %hi(0x4000), %g2
40005418: 80 a0 40 02 cmp %g1, %g2
4000541c: 12 80 00 15 bne 40005470 <rmdir+0xa4>
<== NEVER TAKEN
40005420: 92 10 20 14 mov 0x14, %o1
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40005424: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
40005428: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000542c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
40005430: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
40005434: 9f c0 80 00 call %g2
40005438: 90 10 00 1d mov %i5, %o0
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
4000543c: 80 a2 20 00 cmp %o0, 0
40005440: 12 80 00 11 bne 40005484 <rmdir+0xb8>
<== NEVER TAKEN
40005444: 92 10 20 10 mov 0x10, %o1
rv = (*ops->rmnod_h)( &parentloc, currentloc );
40005448: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
4000544c: 92 10 00 1d mov %i5, %o1
40005450: 9f c0 40 00 call %g1
40005454: 90 07 bf 50 add %fp, -176, %o0
40005458: b0 10 00 08 mov %o0, %i0
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTDIR );
rv = -1;
}
rtems_filesystem_eval_path_cleanup_with_parent( &ctx, &parentloc );
4000545c: 92 07 bf 50 add %fp, -176, %o1
40005460: 40 00 02 63 call 40005dec <rtems_filesystem_eval_path_cleanup_with_parent>
40005464: 90 07 bf 68 add %fp, -152, %o0
return rv;
}
40005468: 81 c7 e0 08 ret
4000546c: 81 e8 00 00 restore
rtems_filesystem_eval_path_error( &ctx, ENOTDIR );
40005470: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
40005474: 40 00 01 4a call 4000599c <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005478: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup_with_parent( &ctx, &parentloc );
4000547c: 10 bf ff f9 b 40005460 <rmdir+0x94>
<== NOT EXECUTED
40005480: 92 07 bf 50 add %fp, -176, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error( &ctx, EBUSY );
40005484: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
40005488: 40 00 01 45 call 4000599c <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
4000548c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup_with_parent( &ctx, &parentloc );
40005490: 10 bf ff f4 b 40005460 <rmdir+0x94>
<== NOT EXECUTED
40005494: 92 07 bf 50 add %fp, -176, %o1
<== NOT EXECUTED
40015994 <rtems_assoc_32_to_string>:
const rtems_assoc_32_pair *pairs,
size_t pair_count,
const char *separator,
const char *fallback
)
{
40015994: 9d e3 bf a0 save %sp, -96, %sp
40015998: a2 10 00 19 mov %i1, %l1
size_t len;
size_t i;
len = 0;
for ( i = 0; i < pair_count ; ++i ) {
4001599c: 80 a7 20 00 cmp %i4, 0
400159a0: 02 80 00 25 be 40015a34 <rtems_assoc_32_to_string+0xa0>
<== NEVER TAKEN
400159a4: f2 07 a0 5c ld [ %fp + 0x5c ], %i1
400159a8: b9 2f 20 03 sll %i4, 3, %i4
len = 0;
400159ac: a0 10 20 00 clr %l0
400159b0: b8 06 c0 1c add %i3, %i4, %i4
const rtems_assoc_32_pair *p;
p = &pairs[ i ];
if ( ( value & p->bits ) != 0 ) {
400159b4: c2 06 c0 00 ld [ %i3 ], %g1
400159b8: 80 8e 00 01 btst %i0, %g1
400159bc: 22 80 00 16 be,a 40015a14 <rtems_assoc_32_to_string+0x80>
<== ALWAYS TAKEN
400159c0: b6 06 e0 08 add %i3, 8, %i3
if ( len > 0 ) {
400159c4: 80 a4 20 00 cmp %l0, 0
<== NOT EXECUTED
400159c8: 02 80 00 0b be 400159f4 <rtems_assoc_32_to_string+0x60>
<== NOT EXECUTED
400159cc: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
if ( len < buffer_size ) {
400159d0: 80 a6 80 10 cmp %i2, %l0
<== NOT EXECUTED
len += strlcpy( &buffer[ len ], separator, space( buffer_size, len ) );
400159d4: 90 04 40 10 add %l1, %l0, %o0
<== NOT EXECUTED
if ( len < buffer_size ) {
400159d8: 08 80 00 03 bleu 400159e4 <rtems_assoc_32_to_string+0x50>
<== NOT EXECUTED
400159dc: 94 10 20 00 clr %o2
<== NOT EXECUTED
return buffer_size - len;
400159e0: 94 26 80 10 sub %i2, %l0, %o2
<== NOT EXECUTED
len += strlcpy( &buffer[ len ], separator, space( buffer_size, len ) );
400159e4: 40 00 10 ef call 40019da0 <strlcpy>
<== NOT EXECUTED
400159e8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
400159ec: a0 04 00 08 add %l0, %o0, %l0
<== NOT EXECUTED
400159f0: 90 04 40 10 add %l1, %l0, %o0
<== NOT EXECUTED
}
len += strlcpy( &buffer[ len ], p->name, space( buffer_size, len ) );
400159f4: d2 06 e0 04 ld [ %i3 + 4 ], %o1
<== NOT EXECUTED
if ( len < buffer_size ) {
400159f8: 80 a4 00 1a cmp %l0, %i2
<== NOT EXECUTED
400159fc: 1a 80 00 03 bcc 40015a08 <rtems_assoc_32_to_string+0x74>
<== NOT EXECUTED
40015a00: 94 10 20 00 clr %o2
<== NOT EXECUTED
return buffer_size - len;
40015a04: 94 26 80 10 sub %i2, %l0, %o2
<== NOT EXECUTED
len += strlcpy( &buffer[ len ], p->name, space( buffer_size, len ) );
40015a08: 40 00 10 e6 call 40019da0 <strlcpy>
<== NOT EXECUTED
40015a0c: b6 06 e0 08 add %i3, 8, %i3
<== NOT EXECUTED
40015a10: a0 04 00 08 add %l0, %o0, %l0
<== NOT EXECUTED
for ( i = 0; i < pair_count ; ++i ) {
40015a14: 80 a7 00 1b cmp %i4, %i3
40015a18: 32 bf ff e8 bne,a 400159b8 <rtems_assoc_32_to_string+0x24>
40015a1c: c2 06 c0 00 ld [ %i3 ], %g1
}
}
if ( len == 0 ) {
40015a20: 80 a4 20 00 cmp %l0, 0
40015a24: 02 80 00 04 be 40015a34 <rtems_assoc_32_to_string+0xa0>
<== ALWAYS TAKEN
40015a28: b0 10 00 10 mov %l0, %i0
len += strlcpy( buffer, fallback, buffer_size );
}
return len;
}
40015a2c: 81 c7 e0 08 ret
<== NOT EXECUTED
40015a30: 81 e8 00 00 restore
<== NOT EXECUTED
len += strlcpy( buffer, fallback, buffer_size );
40015a34: 40 00 10 db call 40019da0 <strlcpy>
40015a38: 91 e8 00 11 restore %g0, %l1, %o0
400106fc <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
400106fc: 9d e3 bf a0 save %sp, -96, %sp
40010700: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t local_value = 0;
40010704: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1) {
40010708: 10 80 00 04 b 40010718 <rtems_assoc_local_by_remote_bitfield+0x1c>
4001070c: ba 10 20 01 mov 1, %i5
40010710: 02 80 00 0c be 40010740 <rtems_assoc_local_by_remote_bitfield+0x44>
40010714: bb 2f 60 01 sll %i5, 1, %i5
if (b & remote_value)
40010718: 80 8e 40 1d btst %i1, %i5
4001071c: 22 bf ff fd be,a 40010710 <rtems_assoc_local_by_remote_bitfield+0x14>
40010720: b8 87 3f ff addcc %i4, -1, %i4
local_value |= rtems_assoc_local_by_remote(ap, b);
40010724: 92 10 00 1d mov %i5, %o1
40010728: 40 00 00 08 call 40010748 <rtems_assoc_local_by_remote>
4001072c: 90 10 00 18 mov %i0, %o0
for (b = 1; b; b <<= 1) {
40010730: bb 2f 60 01 sll %i5, 1, %i5
40010734: b8 87 3f ff addcc %i4, -1, %i4
40010738: 12 bf ff f8 bne 40010718 <rtems_assoc_local_by_remote_bitfield+0x1c>
<== ALWAYS TAKEN
4001073c: b6 16 c0 08 or %i3, %o0, %i3
}
return local_value;
}
40010740: 81 c7 e0 08 ret
40010744: 91 e8 00 1b restore %g0, %i3, %o0
40015a88 <rtems_assoc_name_bad>:
sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value);
#else
static char bad_buffer[40] = "<assocnamebad.c: : BAD NAME>";
#endif
return bad_buffer;
40015a88: 11 10 00 af sethi %hi(0x4002bc00), %o0
<== NOT EXECUTED
}
40015a8c: 81 c3 e0 08 retl
<== NOT EXECUTED
40015a90: 90 12 20 00 mov %o0, %o0 ! 4002bc00 <bad_buffer.5658>
<== NOT EXECUTED
40012cb0 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
40012cb0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
40012cb4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40012cb8: 40 00 00 0a call 40012ce0 <rtems_assoc_ptr_by_local>
<== NOT EXECUTED
40012cbc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (nap)
40012cc0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40012cc4: 02 80 00 05 be 40012cd8 <rtems_assoc_name_by_local+0x28>
<== NOT EXECUTED
40012cc8: 01 00 00 00 nop
<== NOT EXECUTED
return nap->name;
40012ccc: f0 02 00 00 ld [ %o0 ], %i0
<== NOT EXECUTED
return rtems_assoc_name_bad(local_value);
}
40012cd0: 81 c7 e0 08 ret
<== NOT EXECUTED
40012cd4: 81 e8 00 00 restore
<== NOT EXECUTED
return rtems_assoc_name_bad(local_value);
40012cd8: 40 00 0b 6c call 40015a88 <rtems_assoc_name_bad>
<== NOT EXECUTED
40012cdc: 91 e8 00 19 restore %g0, %i1, %o0
<== NOT EXECUTED
40012ce0 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
40012ce0: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
40012ce4: d0 06 00 00 ld [ %i0 ], %o0
{
40012ce8: ba 10 00 18 mov %i0, %i5
if (rtems_assoc_is_default(ap))
40012cec: 80 a2 20 00 cmp %o0, 0
40012cf0: 02 80 00 16 be 40012d48 <rtems_assoc_ptr_by_local+0x68>
<== NEVER TAKEN
40012cf4: b0 10 20 00 clr %i0
40012cf8: 13 10 00 a4 sethi %hi(0x40029000), %o1
40012cfc: 40 00 1a 2a call 400195a4 <strcmp>
40012d00: 92 12 62 90 or %o1, 0x290, %o1 ! 40029290 <IMFS_LIMITS_AND_OPTIONS+0x34>
40012d04: 80 a2 20 00 cmp %o0, 0
40012d08: 22 80 00 12 be,a 40012d50 <rtems_assoc_ptr_by_local+0x70>
<== NEVER TAKEN
40012d0c: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
40012d10: c2 07 60 04 ld [ %i5 + 4 ], %g1
40012d14: 80 a6 40 01 cmp %i1, %g1
40012d18: 32 80 00 08 bne,a 40012d38 <rtems_assoc_ptr_by_local+0x58>
40012d1c: ba 07 60 0c add %i5, 0xc, %i5
for ( ; ap->name; ap++)
40012d20: 81 c7 e0 08 ret
40012d24: 91 e8 00 1d restore %g0, %i5, %o0
if (ap->local_value == local_value)
40012d28: 80 a0 40 19 cmp %g1, %i1
40012d2c: 22 80 00 07 be,a 40012d48 <rtems_assoc_ptr_by_local+0x68>
40012d30: b0 10 00 1d mov %i5, %i0
for ( ; ap->name; ap++)
40012d34: ba 07 60 0c add %i5, 0xc, %i5
40012d38: c2 07 40 00 ld [ %i5 ], %g1
40012d3c: 80 a0 60 00 cmp %g1, 0
40012d40: 32 bf ff fa bne,a 40012d28 <rtems_assoc_ptr_by_local+0x48>
40012d44: c2 07 60 04 ld [ %i5 + 4 ], %g1
40012d48: 81 c7 e0 08 ret
40012d4c: 81 e8 00 00 restore
default_ap = ap++;
40012d50: 82 07 60 0c add %i5, 0xc, %g1
<== NOT EXECUTED
for ( ; ap->name; ap++)
40012d54: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
40012d58: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40012d5c: 12 bf ff ed bne 40012d10 <rtems_assoc_ptr_by_local+0x30>
<== NOT EXECUTED
40012d60: ba 10 00 01 mov %g1, %i5
<== NOT EXECUTED
40012d64: 81 c7 e0 08 ret
<== NOT EXECUTED
40012d68: 81 e8 00 00 restore
<== NOT EXECUTED
40010770 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
40010770: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
40010774: d0 06 00 00 ld [ %i0 ], %o0
{
40010778: ba 10 00 18 mov %i0, %i5
if (rtems_assoc_is_default(ap))
4001077c: 80 a2 20 00 cmp %o0, 0
40010780: 02 80 00 16 be 400107d8 <rtems_assoc_ptr_by_remote+0x68>
<== NEVER TAKEN
40010784: b0 10 20 00 clr %i0
40010788: 13 10 00 51 sethi %hi(0x40014400), %o1
4001078c: 40 00 08 3e call 40012884 <strcmp>
40010790: 92 12 61 d0 or %o1, 0x1d0, %o1 ! 400145d0 <IMFS_LIMITS_AND_OPTIONS+0x30>
40010794: 80 a2 20 00 cmp %o0, 0
40010798: 22 80 00 12 be,a 400107e0 <rtems_assoc_ptr_by_remote+0x70>
<== NEVER TAKEN
4001079c: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
400107a0: c2 07 60 08 ld [ %i5 + 8 ], %g1
400107a4: 80 a6 40 01 cmp %i1, %g1
400107a8: 32 80 00 08 bne,a 400107c8 <rtems_assoc_ptr_by_remote+0x58>
400107ac: ba 07 60 0c add %i5, 0xc, %i5
for ( ; ap->name; ap++)
400107b0: 81 c7 e0 08 ret
400107b4: 91 e8 00 1d restore %g0, %i5, %o0
if (ap->remote_value == remote_value)
400107b8: 80 a0 40 19 cmp %g1, %i1
400107bc: 22 80 00 07 be,a 400107d8 <rtems_assoc_ptr_by_remote+0x68>
400107c0: b0 10 00 1d mov %i5, %i0
for ( ; ap->name; ap++)
400107c4: ba 07 60 0c add %i5, 0xc, %i5
400107c8: c2 07 40 00 ld [ %i5 ], %g1
400107cc: 80 a0 60 00 cmp %g1, 0
400107d0: 32 bf ff fa bne,a 400107b8 <rtems_assoc_ptr_by_remote+0x48>
400107d4: c2 07 60 08 ld [ %i5 + 8 ], %g1
400107d8: 81 c7 e0 08 ret
400107dc: 81 e8 00 00 restore
default_ap = ap++;
400107e0: 82 07 60 0c add %i5, 0xc, %g1
<== NOT EXECUTED
for ( ; ap->name; ap++)
400107e4: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
400107e8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400107ec: 12 bf ff ed bne 400107a0 <rtems_assoc_ptr_by_remote+0x30>
<== NOT EXECUTED
400107f0: ba 10 00 01 mov %g1, %i5
<== NOT EXECUTED
400107f4: 81 c7 e0 08 ret
<== NOT EXECUTED
400107f8: 81 e8 00 00 restore
<== NOT EXECUTED
400107fc <rtems_cache_aligned_malloc>:
#include <rtems.h>
#include <rtems/malloc.h>
void *rtems_cache_aligned_malloc( size_t nbytes )
{
400107fc: 9d e3 bf a0 save %sp, -96, %sp
size_t line_size = rtems_cache_get_maximal_line_size();
40010800: 40 00 0c 2f call 400138bc <rtems_cache_get_maximal_line_size>
40010804: 01 00 00 00 nop
if ( line_size > 0 ) {
40010808: b2 92 20 00 orcc %o0, 0, %i1
4001080c: 02 80 00 05 be 40010820 <rtems_cache_aligned_malloc+0x24>
<== NEVER TAKEN
40010810: 82 06 3f ff add %i0, -1, %g1
/* Assume that the cache line size is a power of two */
size_t m = line_size - 1;
nbytes = (nbytes + m) & ~m;
40010814: b0 20 00 19 neg %i1, %i0
40010818: 82 00 40 19 add %g1, %i1, %g1
4001081c: b0 0e 00 01 and %i0, %g1, %i0
}
return rtems_heap_allocate_aligned_with_boundary( nbytes, line_size, 0 );
40010820: 7f ff d2 dc call 40005390 <rtems_heap_allocate_aligned_with_boundary>
40010824: 95 e8 20 00 restore %g0, 0, %o2
4000d4a8 <rtems_current_user_env_getgroups>:
#include <sys/types.h>
#include <unistd.h>
void rtems_current_user_env_getgroups(void)
{
4000d4a8: 9d e3 bf a0 save %sp, -96, %sp
rtems_user_env_t *uenv = rtems_current_user_env_get();
4000d4ac: 7f ff df 33 call 40005178 <rtems_current_user_env_get>
4000d4b0: 01 00 00 00 nop
4000d4b4: ba 10 00 08 mov %o0, %i5
int ngroups = (int) RTEMS_ARRAY_SIZE( uenv->groups );
ngroups = getgroups( ngroups, &uenv->groups[ 0 ] );
4000d4b8: 90 10 20 10 mov 0x10, %o0
4000d4bc: 40 00 05 63 call 4000ea48 <getgroups>
4000d4c0: 92 07 60 28 add %i5, 0x28, %o1
if ( ngroups > 0 ) {
4000d4c4: 80 a2 20 00 cmp %o0, 0
4000d4c8: 24 80 00 03 ble,a 4000d4d4 <rtems_current_user_env_getgroups+0x2c>
4000d4cc: c0 27 60 24 clr [ %i5 + 0x24 ]
uenv->ngroups = (size_t) ngroups;
4000d4d0: d0 27 60 24 st %o0, [ %i5 + 0x24 ]
4000d4d4: 81 c7 e0 08 ret
4000d4d8: 81 e8 00 00 restore
} else {
uenv->ngroups = 0;
}
}
4000d4dc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d4e0: 81 e8 00 00 restore
<== NOT EXECUTED
40013040 <rtems_error>:
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
40013040: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
40013044: 82 07 a0 4c add %fp, 0x4c, %g1
<== NOT EXECUTED
40013048: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
<== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
4001304c: 94 10 00 01 mov %g1, %o2
<== NOT EXECUTED
va_start(arglist, printf_format);
40013050: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
40013054: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
va_start(arglist, printf_format);
40013058: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
<== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
4001305c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
va_start(arglist, printf_format);
40013060: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
<== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
40013064: 7f ff ff 87 call 40012e80 <rtems_verror>
<== NOT EXECUTED
40013068: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
<== NOT EXECUTED
va_end(arglist);
if (error_flag & RTEMS_ERROR_PANIC) {
4001306c: 03 08 00 00 sethi %hi(0x20000000), %g1
<== NOT EXECUTED
40013070: 80 8e 00 01 btst %i0, %g1
<== NOT EXECUTED
40013074: 12 80 00 07 bne 40013090 <rtems_error+0x50>
<== NOT EXECUTED
40013078: 03 04 00 00 sethi %hi(0x10000000), %g1
<== NOT EXECUTED
rtems_error(0, "fatal error, exiting");
_exit(errno);
}
if (error_flag & RTEMS_ERROR_ABORT) {
4001307c: 80 8e 00 01 btst %i0, %g1
<== NOT EXECUTED
40013080: 12 80 00 0c bne 400130b0 <rtems_error+0x70>
<== NOT EXECUTED
40013084: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
rtems_error(0, "fatal error, aborting");
abort();
}
return chars_written;
}
40013088: 81 c7 e0 08 ret
<== NOT EXECUTED
4001308c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_error(0, "fatal error, exiting");
40013090: 13 10 00 a5 sethi %hi(0x40029400), %o1
<== NOT EXECUTED
40013094: 92 12 60 50 or %o1, 0x50, %o1 ! 40029450 <state_pairs+0xf0>
<== NOT EXECUTED
40013098: 7f ff ff ea call 40013040 <rtems_error>
<== NOT EXECUTED
4001309c: 90 10 20 00 clr %o0
<== NOT EXECUTED
_exit(errno);
400130a0: 40 00 0b 32 call 40015d68 <__errno>
<== NOT EXECUTED
400130a4: 01 00 00 00 nop
<== NOT EXECUTED
400130a8: 40 00 00 dd call 4001341c <_exit>
<== NOT EXECUTED
400130ac: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
rtems_error(0, "fatal error, aborting");
400130b0: 13 10 00 a5 sethi %hi(0x40029400), %o1
<== NOT EXECUTED
400130b4: 92 12 60 68 or %o1, 0x68, %o1 ! 40029468 <state_pairs+0x108>
<== NOT EXECUTED
400130b8: 7f ff ff e2 call 40013040 <rtems_error>
<== NOT EXECUTED
400130bc: 90 10 20 00 clr %o0
<== NOT EXECUTED
abort();
400130c0: 40 00 0b 1d call 40015d34 <abort>
<== NOT EXECUTED
400130c4: 01 00 00 00 nop
<== NOT EXECUTED
400130c8: 01 00 00 00 nop
<== NOT EXECUTED
400091c4 <rtems_filesystem_chdir>:
#include <unistd.h>
#include <rtems/libio_.h>
int rtems_filesystem_chdir( rtems_filesystem_location_info_t *loc )
{
400091c4: 9d e3 bf 40 save %sp, -192, %sp
int rv = 0;
rtems_filesystem_global_location_t *global_loc =
400091c8: 40 00 09 63 call 4000b754 <rtems_filesystem_location_transform_to_global>
400091cc: 90 10 00 18 mov %i0, %o0
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
400091d0: c0 27 bf ac clr [ %fp + -84 ]
400091d4: ba 10 00 08 mov %o0, %i5
(void) ( *loc->handlers->fstat_h )( loc, &st );
400091d8: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
400091dc: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
400091e0: 9f c0 40 00 call %g1
400091e4: 92 07 bf a0 add %fp, -96, %o1
rtems_filesystem_location_transform_to_global( loc );
mode_t type = rtems_filesystem_location_type( &global_loc->location );
if ( S_ISDIR( type ) ) {
400091e8: 05 00 00 3c sethi %hi(0xf000), %g2
400091ec: c2 07 bf ac ld [ %fp + -84 ], %g1
400091f0: 82 08 40 02 and %g1, %g2, %g1
400091f4: 05 00 00 10 sethi %hi(0x4000), %g2
400091f8: 80 a0 40 02 cmp %g1, %g2
400091fc: 32 80 00 08 bne,a 4000921c <rtems_filesystem_chdir+0x58>
<== NEVER TAKEN
40009200: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
<== NOT EXECUTED
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
40009204: 40 00 04 95 call 4000a458 <rtems_current_user_env_get>
40009208: b0 10 20 00 clr %i0
rtems_filesystem_global_location_assign(
4000920c: 40 00 08 fc call 4000b5fc <rtems_filesystem_global_location_assign>
40009210: 92 10 00 1d mov %i5, %o1
40009214: 81 c7 e0 08 ret
40009218: 81 e8 00 00 restore
if ( !rtems_filesystem_location_is_null( loc ) ) {
4000921c: 03 10 00 c5 sethi %hi(0x40031400), %g1
<== NOT EXECUTED
40009220: 82 10 63 54 or %g1, 0x354, %g1 ! 40031754 <rtems_filesystem_null_handlers>
<== NOT EXECUTED
40009224: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
40009228: 02 80 00 07 be 40009244 <rtems_filesystem_chdir+0x80>
<== NOT EXECUTED
4000922c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
errno = eno;
40009230: 40 00 5e 8e call 40020c68 <__errno>
<== NOT EXECUTED
40009234: 01 00 00 00 nop
<== NOT EXECUTED
40009238: 82 10 20 14 mov 0x14, %g1 ! 14 <_TLS_Alignment+0x13>
<== NOT EXECUTED
4000923c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
global_loc
);
} else {
rtems_filesystem_location_error( &global_loc->location, ENOTDIR );
rtems_filesystem_global_location_release( global_loc, true );
40009240: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
40009244: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40009248: 40 00 08 d3 call 4000b594 <rtems_filesystem_global_location_release>
<== NOT EXECUTED
4000924c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40009250: 81 c7 e0 08 ret
<== NOT EXECUTED
40009254: 81 e8 00 00 restore
<== NOT EXECUTED
40005ed4 <rtems_filesystem_check_access>:
int flags,
mode_t object_mode,
uid_t object_uid,
gid_t object_gid
)
{
40005ed4: 9d e3 bf a0 save %sp, -96, %sp
const rtems_user_env_t *uenv = rtems_current_user_env_get();
40005ed8: 7f ff ff 96 call 40005d30 <rtems_current_user_env_get>
40005edc: 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) {
40005ee0: c2 12 20 10 lduh [ %o0 + 0x10 ], %g1
40005ee4: 80 a0 60 00 cmp %g1, 0
40005ee8: 02 80 00 24 be 40005f78 <rtems_filesystem_check_access+0xa4>
40005eec: 80 a0 40 1a cmp %g1, %i2
40005ef0: 22 80 00 23 be,a 40005f7c <rtems_filesystem_check_access+0xa8>
<== NEVER TAKEN
40005ef4: 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
40005ef8: c2 12 20 12 lduh [ %o0 + 0x12 ], %g1
if (
40005efc: 80 a0 60 00 cmp %g1, 0
40005f00: 02 80 00 18 be 40005f60 <rtems_filesystem_check_access+0x8c>
40005f04: 80 a0 40 1b cmp %g1, %i3
40005f08: 22 80 00 17 be,a 40005f64 <rtems_filesystem_check_access+0x90>
<== NEVER TAKEN
40005f0c: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
40005f10: c6 02 20 24 ld [ %o0 + 0x24 ], %g3
40005f14: 80 a0 e0 00 cmp %g3, 0
40005f18: 22 80 00 14 be,a 40005f68 <rtems_filesystem_check_access+0x94>
40005f1c: b0 2e 00 19 andn %i0, %i1, %i0
if (uenv->groups[i] == object_gid) {
40005f20: c2 12 20 28 lduh [ %o0 + 0x28 ], %g1
40005f24: 80 a0 40 1b cmp %g1, %i3
40005f28: 02 80 00 0e be 40005f60 <rtems_filesystem_check_access+0x8c>
<== NEVER TAKEN
40005f2c: 90 02 20 2a add %o0, 0x2a, %o0
for (i = 0; i < uenv->ngroups; ++i) {
40005f30: 10 80 00 06 b 40005f48 <rtems_filesystem_check_access+0x74>
40005f34: 82 10 20 00 clr %g1
if (uenv->groups[i] == object_gid) {
40005f38: c4 12 3f fe lduh [ %o0 + -2 ], %g2
40005f3c: 80 a0 80 1b cmp %g2, %i3
40005f40: 22 80 00 09 be,a 40005f64 <rtems_filesystem_check_access+0x90>
<== NEVER TAKEN
40005f44: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
40005f48: 82 00 60 01 inc %g1
40005f4c: 80 a0 40 03 cmp %g1, %g3
40005f50: 12 bf ff fa bne 40005f38 <rtems_filesystem_check_access+0x64>
40005f54: 90 02 20 02 add %o0, 2, %o0
} else {
access_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (access_flags & object_mode) == access_flags;
40005f58: 10 80 00 04 b 40005f68 <rtems_filesystem_check_access+0x94>
40005f5c: b0 2e 00 19 andn %i0, %i1, %i0
access_flags <<= RTEMS_FS_GRP_SHIFT;
40005f60: b1 2e 20 03 sll %i0, 3, %i0
return (access_flags & object_mode) == access_flags;
40005f64: b0 2e 00 19 andn %i0, %i1, %i0
}
40005f68: 80 a0 00 18 cmp %g0, %i0
40005f6c: b0 60 3f ff subx %g0, -1, %i0
40005f70: 81 c7 e0 08 ret
40005f74: 81 e8 00 00 restore
access_flags <<= RTEMS_FS_USR_SHIFT;
40005f78: b1 2e 20 06 sll %i0, 6, %i0
return (access_flags & object_mode) == access_flags;
40005f7c: b0 2e 00 19 andn %i0, %i1, %i0
}
40005f80: 80 a0 00 18 cmp %g0, %i0
40005f84: b0 60 3f ff subx %g0, -1, %i0
40005f88: 81 c7 e0 08 ret
40005f8c: 81 e8 00 00 restore
4000c6bc <rtems_filesystem_chmod>:
int rtems_filesystem_chmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4000c6bc: 9d e3 bf 40 save %sp, -192, %sp
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000c6c0: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
<== NOT EXECUTED
int rv;
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
4000c6c4: c2 0f 20 29 ldub [ %i4 + 0x29 ], %g1
<== NOT EXECUTED
{
4000c6c8: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
4000c6cc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000c6d0: 12 80 00 07 bne 4000c6ec <rtems_filesystem_chmod+0x30>
<== NOT EXECUTED
4000c6d4: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
<== NOT EXECUTED
4000c6d8: 03 10 01 59 sethi %hi(0x40056400), %g1
<== NOT EXECUTED
4000c6dc: 82 10 62 fc or %g1, 0x2fc, %g1 ! 400566fc <rtems_filesystem_null_handlers>
<== NOT EXECUTED
4000c6e0: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4000c6e4: 12 80 00 3d bne 4000c7d8 <rtems_filesystem_chmod+0x11c>
<== NOT EXECUTED
4000c6e8: 01 00 00 00 nop
<== NOT EXECUTED
struct stat st;
memset( &st, 0, sizeof(st) );
4000c6ec: c0 27 bf a0 clr [ %fp + -96 ]
<== NOT EXECUTED
rv = (*loc->handlers->fstat_h)( loc, &st );
4000c6f0: 92 07 bf a0 add %fp, -96, %o1
<== NOT EXECUTED
memset( &st, 0, sizeof(st) );
4000c6f4: c0 27 bf a4 clr [ %fp + -92 ]
<== NOT EXECUTED
4000c6f8: c0 27 bf a8 clr [ %fp + -88 ]
<== NOT EXECUTED
4000c6fc: c0 27 bf ac clr [ %fp + -84 ]
<== NOT EXECUTED
4000c700: c0 27 bf b0 clr [ %fp + -80 ]
<== NOT EXECUTED
4000c704: c0 27 bf b4 clr [ %fp + -76 ]
<== NOT EXECUTED
4000c708: c0 27 bf b8 clr [ %fp + -72 ]
<== NOT EXECUTED
4000c70c: c0 27 bf bc clr [ %fp + -68 ]
<== NOT EXECUTED
4000c710: c0 27 bf c0 clr [ %fp + -64 ]
<== NOT EXECUTED
4000c714: c0 27 bf c4 clr [ %fp + -60 ]
<== NOT EXECUTED
4000c718: c0 27 bf c8 clr [ %fp + -56 ]
<== NOT EXECUTED
4000c71c: c0 27 bf cc clr [ %fp + -52 ]
<== NOT EXECUTED
4000c720: c0 27 bf d0 clr [ %fp + -48 ]
<== NOT EXECUTED
4000c724: c0 27 bf d4 clr [ %fp + -44 ]
<== NOT EXECUTED
4000c728: c0 27 bf d8 clr [ %fp + -40 ]
<== NOT EXECUTED
4000c72c: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
4000c730: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4000c734: c0 27 bf e4 clr [ %fp + -28 ]
<== NOT EXECUTED
4000c738: c0 27 bf e8 clr [ %fp + -24 ]
<== NOT EXECUTED
4000c73c: c0 27 bf ec clr [ %fp + -20 ]
<== NOT EXECUTED
4000c740: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
4000c744: c0 27 bf f4 clr [ %fp + -12 ]
<== NOT EXECUTED
4000c748: c0 27 bf f8 clr [ %fp + -8 ]
<== NOT EXECUTED
4000c74c: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
rv = (*loc->handlers->fstat_h)( loc, &st );
4000c750: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1
<== NOT EXECUTED
4000c754: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000c758: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
4000c75c: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4000c760: 02 80 00 04 be 4000c770 <rtems_filesystem_chmod+0xb4>
<== NOT EXECUTED
4000c764: 01 00 00 00 nop
<== NOT EXECUTED
errno = EROFS;
rv = -1;
}
return rv;
}
4000c768: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c76c: 81 e8 00 00 restore
<== NOT EXECUTED
uid_t uid = geteuid();
4000c770: 40 00 00 87 call 4000c98c <geteuid>
<== NOT EXECUTED
4000c774: 01 00 00 00 nop
<== NOT EXECUTED
if ( uid == 0 || st.st_uid == uid ) {
4000c778: 91 2a 20 10 sll %o0, 0x10, %o0
<== NOT EXECUTED
4000c77c: 91 32 20 10 srl %o0, 0x10, %o0
<== NOT EXECUTED
4000c780: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000c784: 12 80 00 0c bne 4000c7b4 <rtems_filesystem_chmod+0xf8>
<== NOT EXECUTED
4000c788: c2 17 bf b2 lduh [ %fp + -78 ], %g1
<== NOT EXECUTED
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
4000c78c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
<== NOT EXECUTED
mode = (st.st_mode & ~mask) | (mode & mask);
4000c790: d2 07 bf ac ld [ %fp + -84 ], %o1
<== NOT EXECUTED
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
4000c794: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
mode = (st.st_mode & ~mask) | (mode & mask);
4000c798: b2 0e 6f ff and %i1, 0xfff, %i1
<== NOT EXECUTED
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
4000c79c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
mode = (st.st_mode & ~mask) | (mode & mask);
4000c7a0: 92 0a 70 00 and %o1, -4096, %o1
<== NOT EXECUTED
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
4000c7a4: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000c7a8: 92 12 40 19 or %o1, %i1, %o1
<== NOT EXECUTED
if ( uid == 0 || st.st_uid == uid ) {
4000c7ac: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c7b0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000c7b4: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000c7b8: 22 bf ff f6 be,a 4000c790 <rtems_filesystem_chmod+0xd4>
<== NOT EXECUTED
4000c7bc: c2 07 20 0c ld [ %i4 + 0xc ], %g1
<== NOT EXECUTED
errno = EPERM;
4000c7c0: 40 00 b6 ec call 4003a370 <__errno>
<== NOT EXECUTED
4000c7c4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000c7c8: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4000c7cc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
4000c7d0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c7d4: 81 e8 00 00 restore
<== NOT EXECUTED
errno = EROFS;
4000c7d8: 40 00 b6 e6 call 4003a370 <__errno>
<== NOT EXECUTED
4000c7dc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000c7e0: 82 10 20 1e mov 0x1e, %g1
<== NOT EXECUTED
4000c7e4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
4000c7e8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c7ec: 81 e8 00 00 restore
<== NOT EXECUTED
4000c7b0 <rtems_filesystem_chown>:
int rtems_filesystem_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
4000c7b0: 9d e3 bf 40 save %sp, -192, %sp
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000c7b4: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
<== NOT EXECUTED
int rv;
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
4000c7b8: c2 0f 20 29 ldub [ %i4 + 0x29 ], %g1
<== NOT EXECUTED
{
4000c7bc: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
4000c7c0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000c7c4: 12 80 00 07 bne 4000c7e0 <rtems_filesystem_chown+0x30>
<== NOT EXECUTED
4000c7c8: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
<== NOT EXECUTED
4000c7cc: 03 10 00 51 sethi %hi(0x40014400), %g1
<== NOT EXECUTED
4000c7d0: 82 10 61 e8 or %g1, 0x1e8, %g1 ! 400145e8 <rtems_filesystem_null_handlers>
<== NOT EXECUTED
4000c7d4: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4000c7d8: 12 80 00 3b bne 4000c8c4 <rtems_filesystem_chown+0x114>
<== NOT EXECUTED
4000c7dc: 01 00 00 00 nop
<== NOT EXECUTED
struct stat st;
memset( &st, 0, sizeof(st) );
4000c7e0: c0 27 bf a0 clr [ %fp + -96 ]
<== NOT EXECUTED
rv = (*loc->handlers->fstat_h)( loc, &st );
4000c7e4: 92 07 bf a0 add %fp, -96, %o1
<== NOT EXECUTED
memset( &st, 0, sizeof(st) );
4000c7e8: c0 27 bf a4 clr [ %fp + -92 ]
<== NOT EXECUTED
4000c7ec: c0 27 bf a8 clr [ %fp + -88 ]
<== NOT EXECUTED
4000c7f0: c0 27 bf ac clr [ %fp + -84 ]
<== NOT EXECUTED
4000c7f4: c0 27 bf b0 clr [ %fp + -80 ]
<== NOT EXECUTED
4000c7f8: c0 27 bf b4 clr [ %fp + -76 ]
<== NOT EXECUTED
4000c7fc: c0 27 bf b8 clr [ %fp + -72 ]
<== NOT EXECUTED
4000c800: c0 27 bf bc clr [ %fp + -68 ]
<== NOT EXECUTED
4000c804: c0 27 bf c0 clr [ %fp + -64 ]
<== NOT EXECUTED
4000c808: c0 27 bf c4 clr [ %fp + -60 ]
<== NOT EXECUTED
4000c80c: c0 27 bf c8 clr [ %fp + -56 ]
<== NOT EXECUTED
4000c810: c0 27 bf cc clr [ %fp + -52 ]
<== NOT EXECUTED
4000c814: c0 27 bf d0 clr [ %fp + -48 ]
<== NOT EXECUTED
4000c818: c0 27 bf d4 clr [ %fp + -44 ]
<== NOT EXECUTED
4000c81c: c0 27 bf d8 clr [ %fp + -40 ]
<== NOT EXECUTED
4000c820: c0 27 bf dc clr [ %fp + -36 ]
<== NOT EXECUTED
4000c824: c0 27 bf e0 clr [ %fp + -32 ]
<== NOT EXECUTED
4000c828: c0 27 bf e4 clr [ %fp + -28 ]
<== NOT EXECUTED
4000c82c: c0 27 bf e8 clr [ %fp + -24 ]
<== NOT EXECUTED
4000c830: c0 27 bf ec clr [ %fp + -20 ]
<== NOT EXECUTED
4000c834: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
4000c838: c0 27 bf f4 clr [ %fp + -12 ]
<== NOT EXECUTED
4000c83c: c0 27 bf f8 clr [ %fp + -8 ]
<== NOT EXECUTED
4000c840: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
rv = (*loc->handlers->fstat_h)( loc, &st );
4000c844: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1
<== NOT EXECUTED
4000c848: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000c84c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
4000c850: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
4000c854: 02 80 00 04 be 4000c864 <rtems_filesystem_chown+0xb4>
<== NOT EXECUTED
4000c858: 01 00 00 00 nop
<== NOT EXECUTED
errno = EROFS;
rv = -1;
}
return rv;
}
4000c85c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c860: 81 e8 00 00 restore
<== NOT EXECUTED
uid_t uid = geteuid();
4000c864: 7f ff df 38 call 40004544 <geteuid>
<== NOT EXECUTED
4000c868: 01 00 00 00 nop
<== NOT EXECUTED
if ( uid == 0 || st.st_uid == uid ) {
4000c86c: 91 2a 20 10 sll %o0, 0x10, %o0
<== NOT EXECUTED
4000c870: 91 32 20 10 srl %o0, 0x10, %o0
<== NOT EXECUTED
4000c874: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000c878: 12 80 00 0a bne 4000c8a0 <rtems_filesystem_chown+0xf0>
<== NOT EXECUTED
4000c87c: c2 17 bf b2 lduh [ %fp + -78 ], %g1
<== NOT EXECUTED
rv = (*mt_entry->ops->chown_h)( loc, owner, group );
4000c880: c2 07 20 0c ld [ %i4 + 0xc ], %g1
<== NOT EXECUTED
4000c884: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
<== NOT EXECUTED
4000c888: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000c88c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000c890: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000c894: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000c898: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c89c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
if ( uid == 0 || st.st_uid == uid ) {
4000c8a0: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
4000c8a4: 22 bf ff f8 be,a 4000c884 <rtems_filesystem_chown+0xd4>
<== NOT EXECUTED
4000c8a8: c2 07 20 0c ld [ %i4 + 0xc ], %g1
<== NOT EXECUTED
errno = EPERM;
4000c8ac: 40 00 0a 79 call 4000f290 <__errno>
<== NOT EXECUTED
4000c8b0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000c8b4: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4000c8b8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
4000c8bc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c8c0: 81 e8 00 00 restore
<== NOT EXECUTED
errno = EROFS;
4000c8c4: 40 00 0a 73 call 4000f290 <__errno>
<== NOT EXECUTED
4000c8c8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000c8cc: 82 10 20 1e mov 0x1e, %g1
<== NOT EXECUTED
4000c8d0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
4000c8d4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c8d8: 81 e8 00 00 restore
<== NOT EXECUTED
40014220 <rtems_filesystem_default_pathconf>:
40014220: 00 00 00 05 00 00 00 80 00 00 00 07 00 00 00 ff ................
40014230: 00 00 00 ff 00 00 04 00 00 00 00 00 00 00 00 00 ................
40014240: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
40014250: 2e 00 00 00 00 00 00 00 2e 2e 00 00 ............
40006844 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40006844: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_lock();
40006848: 7f ff fa 6e call 40005200 <rtems_libio_lock>
4000684c: 01 00 00 00 nop
next = the_node->next;
40006850: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
40006854: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
40006858: c2 20 a0 04 st %g1, [ %g2 + 4 ]
rtems_libio_unlock();
4000685c: 7f ff fa 6e call 40005214 <rtems_libio_unlock>
40006860: c4 20 40 00 st %g2, [ %g1 ]
release_with_count(global_loc, 1);
40006864: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
40006868: 40 00 00 14 call 400068b8 <release_with_count>
4000686c: 92 10 20 01 mov 1, %o1
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);
40006870: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40006874: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40006878: 9f c0 40 00 call %g1
4000687c: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
40006880: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
40006884: 80 a2 20 00 cmp %o0, 0
40006888: 02 80 00 07 be 400068a4 <rtems_filesystem_do_unmount+0x60>
<== NEVER TAKEN
4000688c: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(
rtems_id id
)
{
return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT );
40006890: 40 00 02 4c call 400071c0 <rtems_event_system_send>
40006894: 13 20 00 00 sethi %hi(0x80000000), %o1
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
40006898: 80 a2 20 00 cmp %o0, 0
4000689c: 32 80 00 04 bne,a 400068ac <rtems_filesystem_do_unmount+0x68>
<== NEVER TAKEN
400068a0: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
<== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
400068a4: 7f ff f9 af call 40004f60 <free>
400068a8: 81 e8 00 00 restore
rtems_fatal_error_occurred(0xdeadbeef);
400068ac: 40 00 02 b5 call 40007380 <rtems_fatal_error_occurred>
<== NOT EXECUTED
400068b0: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
400068b4: 01 00 00 00 nop
<== NOT EXECUTED
40005f90 <rtems_filesystem_eval_path_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
40005f90: 9d e3 bf a0 save %sp, -96, %sp
bool access_ok = rtems_filesystem_check_access(
40005f94: 96 10 00 1c mov %i4, %o3
40005f98: 94 10 00 1b mov %i3, %o2
40005f9c: 92 10 00 1a mov %i2, %o1
40005fa0: 7f ff ff cd call 40005ed4 <rtems_filesystem_check_access>
40005fa4: 90 10 00 19 mov %i1, %o0
node_mode,
node_uid,
node_gid
);
if (!access_ok) {
40005fa8: ba 92 20 00 orcc %o0, 0, %i5
40005fac: 12 80 00 04 bne 40005fbc <rtems_filesystem_eval_path_check_access+0x2c>
<== ALWAYS TAKEN
40005fb0: 92 10 20 0d mov 0xd, %o1
rtems_filesystem_eval_path_error(ctx, EACCES);
40005fb4: 40 00 00 98 call 40006214 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005fb8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
return access_ok;
}
40005fbc: 81 c7 e0 08 ret
40005fc0: 91 e8 00 1d restore %g0, %i5, %o0
40006cbc <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;
40006cbc: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
40006cc0: c4 02 20 04 ld [ %o0 + 4 ], %g2
40006cc4: 86 00 40 02 add %g1, %g2, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006cc8: 80 a0 40 03 cmp %g1, %g3
40006ccc: 22 80 00 17 be,a 40006d28 <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NEVER TAKEN
40006cd0: 84 10 20 00 clr %g2
<== NOT EXECUTED
return c == '/' || c == '\\';
40006cd4: c8 48 40 00 ldsb [ %g1 ], %g4
40006cd8: 80 a1 20 2f cmp %g4, 0x2f
40006cdc: 02 80 00 04 be 40006cec <rtems_filesystem_eval_path_eat_delimiter+0x30>
<== ALWAYS TAKEN
40006ce0: 80 a1 20 5c cmp %g4, 0x5c
40006ce4: 32 80 00 11 bne,a 40006d28 <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
40006ce8: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
++current;
40006cec: 82 00 60 01 inc %g1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006cf0: 80 a0 c0 01 cmp %g3, %g1
40006cf4: 02 80 00 0d be 40006d28 <rtems_filesystem_eval_path_eat_delimiter+0x6c>
40006cf8: 84 10 20 00 clr %g2
40006cfc: c4 48 40 00 ldsb [ %g1 ], %g2
40006d00: 80 a0 a0 2f cmp %g2, 0x2f
40006d04: 02 bf ff fa be 40006cec <rtems_filesystem_eval_path_eat_delimiter+0x30>
<== NEVER TAKEN
40006d08: 80 a0 a0 5c cmp %g2, 0x5c
40006d0c: 22 bf ff f9 be,a 40006cf0 <rtems_filesystem_eval_path_eat_delimiter+0x34>
<== NEVER TAKEN
40006d10: 82 00 60 01 inc %g1
<== NOT EXECUTED
40006d14: 84 20 c0 01 sub %g3, %g1, %g2
++current;
40006d18: 86 10 00 01 mov %g1, %g3
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
40006d1c: c4 22 20 04 st %g2, [ %o0 + 4 ]
}
40006d20: 81 c3 e0 08 retl
40006d24: c6 22 00 00 st %g3, [ %o0 ]
ctx->path = current;
40006d28: c6 22 00 00 st %g3, [ %o0 ]
}
40006d2c: 81 c3 e0 08 retl
40006d30: c4 22 20 04 st %g2, [ %o0 + 4 ]
40005fc4 <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
)
{
40005fc4: 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);
40005fc8: 21 10 00 50 sethi %hi(0x40014000), %l0
{
40005fcc: ba 10 00 18 mov %i0, %i5
return &ctx->currentloc;
40005fd0: a2 06 20 18 add %i0, 0x18, %l1
status = (*config->eval_token)(ctx, arg, "..", 2);
40005fd4: a0 14 22 58 or %l0, 0x258, %l0
status = (*config->eval_token)(ctx, arg, ".", 1);
40005fd8: 31 10 00 50 sethi %hi(0x40014000), %i0
40005fdc: b0 16 22 50 or %i0, 0x250, %i0 ! 40014250 <rtems_filesystem_default_pathconf+0x30>
rtems_filesystem_eval_path_next_token(ctx);
40005fe0: 40 00 03 55 call 40006d34 <rtems_filesystem_eval_path_next_token>
40005fe4: 90 10 00 1d mov %i5, %o0
*tokenlen = ctx->tokenlen;
40005fe8: f8 07 60 0c ld [ %i5 + 0xc ], %i4
if (tokenlen > 0) {
40005fec: 80 a7 20 00 cmp %i4, 0
40005ff0: 02 80 00 19 be 40006054 <rtems_filesystem_eval_path_generic+0x90>
40005ff4: f6 07 60 08 ld [ %i5 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
40005ff8: c2 06 80 00 ld [ %i2 ], %g1
40005ffc: 92 10 00 19 mov %i1, %o1
40006000: 9f c0 40 00 call %g1
40006004: 90 10 00 1d mov %i5, %o0
40006008: 80 a2 20 00 cmp %o0, 0
4000600c: 02 80 00 60 be 4000618c <rtems_filesystem_eval_path_generic+0x1c8>
<== NEVER TAKEN
40006010: 80 a7 20 01 cmp %i4, 1
return tokenlen == 1 && token [0] == '.';
40006014: 02 80 00 12 be 4000605c <rtems_filesystem_eval_path_generic+0x98>
40006018: 80 a7 20 02 cmp %i4, 2
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
4000601c: 22 80 00 33 be,a 400060e8 <rtems_filesystem_eval_path_generic+0x124>
40006020: c2 4e c0 00 ldsb [ %i3 ], %g1
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
40006024: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40006028: 96 10 00 1c mov %i4, %o3
4000602c: 94 10 00 1b mov %i3, %o2
40006030: 92 10 00 19 mov %i1, %o1
40006034: 9f c0 40 00 call %g1
40006038: 90 10 00 1d mov %i5, %o0
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
4000603c: 80 a2 20 02 cmp %o0, 2
40006040: 22 80 00 19 be,a 400060a4 <rtems_filesystem_eval_path_generic+0xe0>
40006044: c2 07 60 04 ld [ %i5 + 4 ], %g1
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
40006048: 80 a2 20 00 cmp %o0, 0
4000604c: 02 bf ff e5 be 40005fe0 <rtems_filesystem_eval_path_generic+0x1c>
40006050: 01 00 00 00 nop
40006054: 81 c7 e0 08 ret
40006058: 81 e8 00 00 restore
return tokenlen == 1 && token [0] == '.';
4000605c: c2 4e c0 00 ldsb [ %i3 ], %g1
40006060: 80 a0 60 2e cmp %g1, 0x2e
40006064: 32 bf ff f1 bne,a 40006028 <rtems_filesystem_eval_path_generic+0x64>
40006068: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (rtems_filesystem_eval_path_has_path(ctx)) {
4000606c: c2 07 60 04 ld [ %i5 + 4 ], %g1
40006070: 80 a0 60 00 cmp %g1, 0
40006074: 22 80 00 40 be,a 40006174 <rtems_filesystem_eval_path_generic+0x1b0>
<== ALWAYS TAKEN
40006078: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
status = (*config->eval_token)(ctx, arg, ".", 1);
4000607c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
40006080: 96 10 20 01 mov 1, %o3
40006084: 94 10 00 18 mov %i0, %o2
40006088: 92 10 00 19 mov %i1, %o1
4000608c: 9f c0 40 00 call %g1
40006090: 90 10 00 1d mov %i5, %o0
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
40006094: 80 a2 20 02 cmp %o0, 2
40006098: 12 bf ff ed bne 4000604c <rtems_filesystem_eval_path_generic+0x88>
<== ALWAYS TAKEN
4000609c: 80 a2 20 00 cmp %o0, 0
if (rtems_filesystem_eval_path_has_path(ctx)) {
400060a0: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
400060a4: 80 a0 60 00 cmp %g1, 0
400060a8: 12 80 00 04 bne 400060b8 <rtems_filesystem_eval_path_generic+0xf4>
400060ac: 01 00 00 00 nop
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
400060b0: 81 c7 e0 08 ret
400060b4: 81 e8 00 00 restore
rtems_filesystem_eval_path_eat_delimiter(ctx);
400060b8: 40 00 03 01 call 40006cbc <rtems_filesystem_eval_path_eat_delimiter>
400060bc: 90 10 00 1d mov %i5, %o0
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
400060c0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
if (
400060c4: 80 88 60 80 btst 0x80, %g1
400060c8: 02 80 00 06 be 400060e0 <rtems_filesystem_eval_path_generic+0x11c>
400060cc: b2 10 20 02 mov 2, %i1
|| rtems_filesystem_eval_path_has_path(ctx)
400060d0: c2 07 60 04 ld [ %i5 + 4 ], %g1
400060d4: 80 a0 60 00 cmp %g1, 0
400060d8: 02 bf ff f6 be 400060b0 <rtems_filesystem_eval_path_generic+0xec>
<== ALWAYS TAKEN
400060dc: 01 00 00 00 nop
rtems_filesystem_eval_path_error(ctx, ENOENT);
400060e0: 40 00 00 4d call 40006214 <rtems_filesystem_eval_path_error>
400060e4: 91 e8 00 1d restore %g0, %i5, %o0
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
400060e8: 80 a0 60 2e cmp %g1, 0x2e
400060ec: 32 bf ff cf bne,a 40006028 <rtems_filesystem_eval_path_generic+0x64>
<== NEVER TAKEN
400060f0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
400060f4: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
400060f8: 80 a0 60 2e cmp %g1, 0x2e
400060fc: 32 bf ff cb bne,a 40006028 <rtems_filesystem_eval_path_generic+0x64>
<== NEVER TAKEN
40006100: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40006104: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40006108: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
4000610c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
40006110: c6 02 60 14 ld [ %o1 + 0x14 ], %g3
40006114: 80 a0 40 03 cmp %g1, %g3
40006118: 12 80 00 0a bne 40006140 <rtems_filesystem_eval_path_generic+0x17c>
<== ALWAYS TAKEN
4000611c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
40006120: 9f c0 80 00 call %g2
<== NOT EXECUTED
40006124: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
40006128: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000612c: 32 bf ff d5 bne,a 40006080 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
40006130: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
40006134: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40006138: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
4000613c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
40006140: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
40006144: 9f c0 80 00 call %g2
40006148: 90 10 00 11 mov %l1, %o0
} else if (is_fs_root(currentloc)) {
4000614c: 80 a2 20 00 cmp %o0, 0
40006150: 12 80 00 12 bne 40006198 <rtems_filesystem_eval_path_generic+0x1d4>
<== NEVER TAKEN
40006154: 96 10 20 02 mov 2, %o3
status = (*config->eval_token)(ctx, arg, "..", 2);
40006158: c2 06 a0 04 ld [ %i2 + 4 ], %g1
4000615c: 94 10 00 10 mov %l0, %o2
40006160: 92 10 00 19 mov %i1, %o1
40006164: 9f c0 40 00 call %g1
40006168: 90 10 00 1d mov %i5, %o0
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
4000616c: 10 bf ff b5 b 40006040 <rtems_filesystem_eval_path_generic+0x7c>
40006170: 80 a2 20 02 cmp %o0, 2
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
40006174: 80 88 61 00 btst 0x100, %g1
40006178: 22 bf ff c2 be,a 40006080 <rtems_filesystem_eval_path_generic+0xbc>
<== ALWAYS TAKEN
4000617c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
rtems_filesystem_eval_path_error(ctx, EINVAL);
40006180: b2 10 20 16 mov 0x16, %i1
<== NOT EXECUTED
40006184: 40 00 00 24 call 40006214 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40006188: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
4000618c: b2 10 20 14 mov 0x14, %i1
<== NOT EXECUTED
40006190: 40 00 00 21 call 40006214 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40006194: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
if (currentloc->mt_entry->mt_point_node != NULL) {
40006198: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
4000619c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
<== NOT EXECUTED
400061a0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400061a4: 22 bf ff b7 be,a 40006080 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
400061a8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
size_t tokenlen = ctx->tokenlen;
400061ac: c8 07 60 0c ld [ %i5 + 0xc ], %g4
<== NOT EXECUTED
ctx->path -= tokenlen;
400061b0: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
ctx->pathlen += tokenlen;
400061b4: c4 07 60 04 ld [ %i5 + 4 ], %g2
<== NOT EXECUTED
ctx->path -= tokenlen;
400061b8: 86 20 c0 04 sub %g3, %g4, %g3
<== NOT EXECUTED
ctx->pathlen += tokenlen;
400061bc: 84 00 80 04 add %g2, %g4, %g2
<== NOT EXECUTED
ctx->path -= tokenlen;
400061c0: c6 27 40 00 st %g3, [ %i5 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_restart(
400061c4: b2 00 60 20 add %g1, 0x20, %i1
<== NOT EXECUTED
ctx->pathlen += tokenlen;
400061c8: c4 27 60 04 st %g2, [ %i5 + 4 ]
<== NOT EXECUTED
ctx->tokenlen = 0;
400061cc: c0 27 60 0c clr [ %i5 + 0xc ]
<== NOT EXECUTED
400061d0: 40 00 01 2a call 40006678 <rtems_filesystem_eval_path_restart>
<== NOT EXECUTED
400061d4: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40006d34 <rtems_filesystem_eval_path_next_token>:
const char *current = ctx->path;
40006d34: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
40006d38: c6 02 20 04 ld [ %o0 + 4 ], %g3
40006d3c: 86 00 40 03 add %g1, %g3, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006d40: 80 a0 40 03 cmp %g1, %g3
40006d44: 32 80 00 09 bne,a 40006d68 <rtems_filesystem_eval_path_next_token+0x34>
<== ALWAYS TAKEN
40006d48: c4 48 40 00 ldsb [ %g1 ], %g2
40006d4c: 10 80 00 20 b 40006dcc <rtems_filesystem_eval_path_next_token+0x98>
<== NOT EXECUTED
40006d50: 9a 10 20 00 clr %o5
<== NOT EXECUTED
++current;
40006d54: 82 00 60 01 inc %g1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006d58: 80 a0 c0 01 cmp %g3, %g1
40006d5c: 22 80 00 22 be,a 40006de4 <rtems_filesystem_eval_path_next_token+0xb0>
40006d60: 82 10 00 03 mov %g3, %g1
40006d64: c4 48 40 00 ldsb [ %g1 ], %g2
40006d68: 80 a0 a0 2f cmp %g2, 0x2f
40006d6c: 02 bf ff fa be 40006d54 <rtems_filesystem_eval_path_next_token+0x20>
40006d70: 80 a0 a0 5c cmp %g2, 0x5c
40006d74: 22 bf ff f9 be,a 40006d58 <rtems_filesystem_eval_path_next_token+0x24>
<== NEVER TAKEN
40006d78: 82 00 60 01 inc %g1
<== NOT EXECUTED
ctx->path = current;
40006d7c: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
40006d80: 9a 20 c0 01 sub %g3, %g1, %o5
40006d84: da 22 20 04 st %o5, [ %o0 + 4 ]
40006d88: 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)) {
40006d8c: 80 a0 a0 5c cmp %g2, 0x5c
40006d90: 02 80 00 1f be 40006e0c <rtems_filesystem_eval_path_next_token+0xd8>
<== NEVER TAKEN
40006d94: 80 a0 a0 2f cmp %g2, 0x2f
40006d98: 02 80 00 1e be 40006e10 <rtems_filesystem_eval_path_next_token+0xdc>
<== NEVER TAKEN
40006d9c: 88 10 00 0d mov %o5, %g4
40006da0: 10 80 00 07 b 40006dbc <rtems_filesystem_eval_path_next_token+0x88>
40006da4: 84 10 00 01 mov %g1, %g2
40006da8: 80 a1 20 2f cmp %g4, 0x2f
40006dac: 02 80 00 10 be 40006dec <rtems_filesystem_eval_path_next_token+0xb8>
40006db0: 80 a1 20 5c cmp %g4, 0x5c
40006db4: 02 80 00 0f be 40006df0 <rtems_filesystem_eval_path_next_token+0xbc>
<== NEVER TAKEN
40006db8: 88 20 c0 02 sub %g3, %g2, %g4
++current;
40006dbc: 84 00 a0 01 inc %g2
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40006dc0: 80 a0 80 03 cmp %g2, %g3
40006dc4: 32 bf ff f9 bne,a 40006da8 <rtems_filesystem_eval_path_next_token+0x74>
40006dc8: c8 48 80 00 ldsb [ %g2 ], %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006dcc: 88 10 20 00 clr %g4
}
ctx->path = current;
40006dd0: c6 22 00 00 st %g3, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
40006dd4: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
40006dd8: 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);
}
40006ddc: 81 c3 e0 08 retl
40006de0: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006de4: 10 bf ff fa b 40006dcc <rtems_filesystem_eval_path_next_token+0x98>
40006de8: 9a 10 20 00 clr %o5
40006dec: 88 20 c0 02 sub %g3, %g2, %g4
40006df0: 9a 20 80 01 sub %g2, %g1, %o5
++current;
40006df4: 86 10 00 02 mov %g2, %g3
ctx->pathlen = (size_t) (end - current);
40006df8: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->path = current;
40006dfc: c6 22 00 00 st %g3, [ %o0 ]
ctx->token = begin;
40006e00: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
40006e04: 81 c3 e0 08 retl
40006e08: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40006e0c: 88 10 00 0d mov %o5, %g4
<== NOT EXECUTED
40006e10: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
40006e14: 10 bf ff ef b 40006dd0 <rtems_filesystem_eval_path_next_token+0x9c>
<== NOT EXECUTED
40006e18: 9a 10 20 00 clr %o5
<== NOT EXECUTED
400066dc <rtems_filesystem_eval_path_recursive>:
{
400066dc: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
400066e0: 80 a6 a0 00 cmp %i2, 0
400066e4: 02 80 00 22 be 4000676c <rtems_filesystem_eval_path_recursive+0x90>
<== NEVER TAKEN
400066e8: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
400066ec: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400066f0: 80 a0 60 1f cmp %g1, 0x1f
400066f4: 14 80 00 20 bg 40006774 <rtems_filesystem_eval_path_recursive+0x98>
<== NEVER TAKEN
400066f8: 01 00 00 00 nop
return c == '/' || c == '\\';
400066fc: c4 4e 40 00 ldsb [ %i1 ], %g2
const char *saved_path = ctx->path;
40006700: f6 06 00 00 ld [ %i0 ], %i3
if (rtems_filesystem_is_delimiter(path [0])) {
40006704: 80 a0 a0 2f cmp %g2, 0x2f
40006708: 02 80 00 1d be 4000677c <rtems_filesystem_eval_path_recursive+0xa0>
<== NEVER TAKEN
4000670c: f8 06 20 04 ld [ %i0 + 4 ], %i4
40006710: 80 a0 a0 5c cmp %g2, 0x5c
40006714: 02 80 00 1b be 40006780 <rtems_filesystem_eval_path_recursive+0xa4>
<== NEVER TAKEN
40006718: 92 07 60 30 add %i5, 0x30, %o1
++ctx->recursionlevel;
4000671c: 82 00 60 01 inc %g1
ctx->path = path;
40006720: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
40006724: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
40006728: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
4000672c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40006730: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40006734: c2 00 60 08 ld [ %g1 + 8 ], %g1
40006738: 9f c0 40 00 call %g1
4000673c: 90 10 00 1d mov %i5, %o0
while (ctx->pathlen > 0) {
40006740: c2 07 60 04 ld [ %i5 + 4 ], %g1
40006744: 80 a0 60 00 cmp %g1, 0
40006748: 32 bf ff fa bne,a 40006730 <rtems_filesystem_eval_path_recursive+0x54>
<== NEVER TAKEN
4000674c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
--ctx->recursionlevel;
40006750: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40006754: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
40006758: f6 27 40 00 st %i3, [ %i5 ]
--ctx->recursionlevel;
4000675c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
ctx->pathlen = saved_pathlen;
40006760: f8 27 60 04 st %i4, [ %i5 + 4 ]
}
40006764: 81 c7 e0 08 ret
40006768: 81 e8 00 00 restore
rtems_filesystem_eval_path_error(ctx, ENOENT);
4000676c: 7f ff fe aa call 40006214 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40006770: 93 e8 20 02 restore %g0, 2, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ELOOP);
40006774: 7f ff fe a8 call 40006214 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40006778: 93 e8 20 5c restore %g0, 0x5c, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
4000677c: 92 07 60 30 add %i5, 0x30, %o1
<== NOT EXECUTED
40006780: 7f ff ff be call 40006678 <rtems_filesystem_eval_path_restart>
<== NOT EXECUTED
40006784: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40006788: 10 bf ff e5 b 4000671c <rtems_filesystem_eval_path_recursive+0x40>
<== NOT EXECUTED
4000678c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
40006530 <rtems_filesystem_eval_path_start_with_parent>:
{
40006530: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
40006534: 40 00 31 42 call 40012a3c <strlen>
40006538: 90 10 00 19 mov %i1, %o0
while (pathlen > 0) {
4000653c: a0 92 20 00 orcc %o0, 0, %l0
40006540: 02 80 00 32 be 40006608 <rtems_filesystem_eval_path_start_with_parent+0xd8>
<== NEVER TAKEN
40006544: a2 10 00 19 mov %i1, %l1
size_t i = pathlen - 1;
40006548: ba 04 3f ff add %l0, -1, %i5
return c == '/' || c == '\\';
4000654c: c2 4e 40 1d ldsb [ %i1 + %i5 ], %g1
if (rtems_filesystem_is_delimiter(path [i])) {
40006550: 80 a0 60 2f cmp %g1, 0x2f
40006554: 02 80 00 30 be 40006614 <rtems_filesystem_eval_path_start_with_parent+0xe4>
<== NEVER TAKEN
40006558: 80 a0 60 5c cmp %g1, 0x5c
4000655c: 12 80 00 0c bne 4000658c <rtems_filesystem_eval_path_start_with_parent+0x5c>
<== ALWAYS TAKEN
40006560: 80 a7 60 00 cmp %i5, 0
40006564: 10 80 00 2e b 4000661c <rtems_filesystem_eval_path_start_with_parent+0xec>
<== NOT EXECUTED
40006568: ba 10 00 10 mov %l0, %i5
<== NOT EXECUTED
4000656c: c4 4e 40 01 ldsb [ %i1 + %g1 ], %g2
40006570: 80 a0 a0 2f cmp %g2, 0x2f
40006574: 02 80 00 21 be 400065f8 <rtems_filesystem_eval_path_start_with_parent+0xc8>
40006578: 80 a0 a0 5c cmp %g2, 0x5c
4000657c: 02 80 00 20 be 400065fc <rtems_filesystem_eval_path_start_with_parent+0xcc>
<== NEVER TAKEN
40006580: a2 10 00 19 mov %i1, %l1
size_t i = pathlen - 1;
40006584: ba 10 00 01 mov %g1, %i5
while (pathlen > 0) {
40006588: 80 a7 60 00 cmp %i5, 0
4000658c: 12 bf ff f8 bne 4000656c <rtems_filesystem_eval_path_start_with_parent+0x3c>
40006590: 82 07 7f ff add %i5, -1, %g1
parentpath = ".";
40006594: 23 10 00 50 sethi %hi(0x40014000), %l1
parentpathlen = 1;
40006598: ba 10 20 01 mov 1, %i5
parentpath = ".";
4000659c: a2 14 62 50 or %l1, 0x250, %l1
&rtems_filesystem_root,
400065a0: 7f ff fd e4 call 40005d30 <rtems_current_user_env_get>
400065a4: 01 00 00 00 nop
&rtems_filesystem_current
400065a8: 7f ff fd e2 call 40005d30 <rtems_current_user_env_get>
400065ac: a4 10 00 08 mov %o0, %l2
currentloc = rtems_filesystem_eval_path_start_with_root_and_current(
400065b0: 98 04 a0 04 add %l2, 4, %o4
400065b4: 9a 10 00 08 mov %o0, %o5
400065b8: 96 10 00 1c mov %i4, %o3
400065bc: 94 10 00 1d mov %i5, %o2
400065c0: 92 10 00 11 mov %l1, %o1
400065c4: 7f ff ff 79 call 400063a8 <rtems_filesystem_eval_path_start_with_root_and_current>
400065c8: 90 10 00 18 mov %i0, %o0
rtems_filesystem_location_clone(parentloc, currentloc);
400065cc: 92 10 00 08 mov %o0, %o1
400065d0: 40 00 28 96 call 40010828 <rtems_filesystem_location_clone>
400065d4: 90 10 00 1b mov %i3, %o0
ctx->path = name;
400065d8: f2 26 00 00 st %i1, [ %i0 ]
rtems_filesystem_eval_path_continue(ctx);
400065dc: 90 10 00 18 mov %i0, %o0
ctx->pathlen = namelen;
400065e0: e0 26 20 04 st %l0, [ %i0 + 4 ]
return &ctx->currentloc;
400065e4: b0 06 20 18 add %i0, 0x18, %i0
rtems_filesystem_eval_path_continue(ctx);
400065e8: 7f ff ff 53 call 40006334 <rtems_filesystem_eval_path_continue>
400065ec: f4 26 3f f8 st %i2, [ %i0 + -8 ]
}
400065f0: 81 c7 e0 08 ret
400065f4: 81 e8 00 00 restore
name = path + parentpathlen;
400065f8: a2 10 00 19 mov %i1, %l1
400065fc: a0 24 00 1d sub %l0, %i5, %l0
40006600: 10 bf ff e8 b 400065a0 <rtems_filesystem_eval_path_start_with_parent+0x70>
40006604: b2 06 40 1d add %i1, %i5, %i1
return 0;
40006608: ba 10 20 00 clr %i5
<== NOT EXECUTED
const char *name = NULL;
4000660c: 10 bf ff e5 b 400065a0 <rtems_filesystem_eval_path_start_with_parent+0x70>
<== NOT EXECUTED
40006610: b2 10 20 00 clr %i1
<== NOT EXECUTED
if (rtems_filesystem_is_delimiter(path [i])) {
40006614: ba 10 00 10 mov %l0, %i5
<== NOT EXECUTED
name = path + parentpathlen;
40006618: a2 10 00 19 mov %i1, %l1
<== NOT EXECUTED
if (rtems_filesystem_is_delimiter(path [i])) {
4000661c: a0 10 20 00 clr %l0
<== NOT EXECUTED
name = path + parentpathlen;
40006620: 10 bf ff e0 b 400065a0 <rtems_filesystem_eval_path_start_with_parent+0x70>
<== NOT EXECUTED
40006624: b2 06 40 1d add %i1, %i5, %i1
<== NOT EXECUTED
400063a8 <rtems_filesystem_eval_path_start_with_root_and_current>:
{
400063a8: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
400063ac: 94 10 20 30 mov 0x30, %o2
400063b0: 92 10 20 00 clr %o1
400063b4: 40 00 30 a9 call 40012658 <memset>
400063b8: 90 06 20 08 add %i0, 8, %o0
ctx->path = path;
400063bc: f2 26 00 00 st %i1, [ %i0 ]
if (ctx->pathlen > 0) {
400063c0: 80 a6 a0 00 cmp %i2, 0
ctx->pathlen = pathlen;
400063c4: f4 26 20 04 st %i2, [ %i0 + 4 ]
if (ctx->pathlen > 0) {
400063c8: 02 80 00 1d be 4000643c <rtems_filesystem_eval_path_start_with_root_and_current+0x94>
<== NEVER TAKEN
400063cc: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
400063d0: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
400063d4: 40 00 01 65 call 40006968 <rtems_filesystem_global_location_obtain>
400063d8: 90 10 00 1c mov %i4, %o0
return c == '/' || c == '\\';
400063dc: 83 2e e0 18 sll %i3, 0x18, %g1
400063e0: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
400063e4: 80 a0 60 2f cmp %g1, 0x2f
400063e8: 02 80 00 2f be 400064a4 <rtems_filesystem_eval_path_start_with_root_and_current+0xfc>
400063ec: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
400063f0: 80 a0 60 5c cmp %g1, 0x5c
400063f4: 22 80 00 2d be,a 400064a8 <rtems_filesystem_eval_path_start_with_root_and_current+0x100>
<== NEVER TAKEN
400063f8: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain(
400063fc: 40 00 01 5b call 40006968 <rtems_filesystem_global_location_obtain>
40006400: 90 10 00 1d mov %i5, %o0
40006404: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
40006408: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
4000640c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40006410: c2 00 40 00 ld [ %g1 ], %g1
40006414: 9f c0 40 00 call %g1
40006418: ba 06 20 18 add %i0, 0x18, %i5
rtems_filesystem_location_clone(
4000641c: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40006420: 40 00 29 02 call 40010828 <rtems_filesystem_location_clone>
40006424: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
40006428: 90 10 00 18 mov %i0, %o0
4000642c: 7f ff ff c2 call 40006334 <rtems_filesystem_eval_path_continue>
40006430: b0 10 00 1d mov %i5, %i0
}
40006434: 81 c7 e0 08 ret
40006438: 81 e8 00 00 restore
rtems_filesystem_global_location_t *global_loc = NULL;
4000643c: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
40006440: 40 00 01 4a call 40006968 <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40006444: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
40006448: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
<== NOT EXECUTED
4000644c: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
40006450: 40 00 01 46 call 40006968 <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40006454: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain_null();
40006458: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
<== NOT EXECUTED
errno = ENOENT;
4000645c: 40 00 30 06 call 40012474 <__errno>
<== NOT EXECUTED
40006460: ba 06 20 18 add %i0, 0x18, %i5
<== NOT EXECUTED
40006464: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
40006468: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000646c: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
<== NOT EXECUTED
40006470: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
40006474: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40006478: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4000647c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40006480: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_clone(
40006484: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
<== NOT EXECUTED
40006488: 40 00 28 e8 call 40010828 <rtems_filesystem_location_clone>
<== NOT EXECUTED
4000648c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_continue(ctx);
40006490: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40006494: 7f ff ff a8 call 40006334 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
40006498: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4000649c: 81 c7 e0 08 ret
<== NOT EXECUTED
400064a0: 81 e8 00 00 restore
<== NOT EXECUTED
++ctx->path;
400064a4: c4 06 00 00 ld [ %i0 ], %g2
--ctx->pathlen;
400064a8: c2 06 20 04 ld [ %i0 + 4 ], %g1
++ctx->path;
400064ac: 84 00 a0 01 inc %g2
--ctx->pathlen;
400064b0: 82 00 7f ff add %g1, -1, %g1
++ctx->path;
400064b4: c4 26 00 00 st %g2, [ %i0 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
400064b8: 90 06 20 30 add %i0, 0x30, %o0
--ctx->pathlen;
400064bc: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
400064c0: 40 00 01 2a call 40006968 <rtems_filesystem_global_location_obtain>
400064c4: ba 06 20 18 add %i0, 0x18, %i5
400064c8: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
400064cc: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
400064d0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400064d4: c2 00 40 00 ld [ %g1 ], %g1
400064d8: 9f c0 40 00 call %g1
400064dc: 01 00 00 00 nop
rtems_filesystem_location_clone(
400064e0: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
400064e4: 40 00 28 d1 call 40010828 <rtems_filesystem_location_clone>
400064e8: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
400064ec: 90 10 00 18 mov %i0, %o0
400064f0: 7f ff ff 91 call 40006334 <rtems_filesystem_eval_path_continue>
400064f4: b0 10 00 1d mov %i5, %i0
}
400064f8: 81 c7 e0 08 ret
400064fc: 81 e8 00 00 restore
40010ac4 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
40010ac4: 9d e3 bf 98 save %sp, -104, %sp
40010ac8: 82 10 00 18 mov %i0, %g1
find_arg fa = {
40010acc: c0 27 bf fc clr [ %fp + -4 ]
40010ad0: b0 10 20 00 clr %i0
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
40010ad4: 80 a0 60 00 cmp %g1, 0
40010ad8: 02 80 00 07 be 40010af4 <rtems_filesystem_get_mount_handler+0x30>
<== NEVER TAKEN
40010adc: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_filesystem_iterate( find_handler, &fa );
40010ae0: 92 07 bf f8 add %fp, -8, %o1
40010ae4: 11 10 00 42 sethi %hi(0x40010800), %o0
40010ae8: 7f ff ff cb call 40010a14 <rtems_filesystem_iterate>
40010aec: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 400109e0 <find_handler>
40010af0: f0 07 bf fc ld [ %fp + -4 ], %i0
}
return fa.mount_h;
}
40010af4: 81 c7 e0 08 ret
40010af8: 81 e8 00 00 restore
40006ab8 <rtems_filesystem_global_location_assign>:
{
40006ab8: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006abc: 91 d0 20 09 ta 9
<== NOT EXECUTED
lhs_global_loc = *lhs_global_loc_ptr;
40006ac0: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
*lhs_global_loc_ptr = rhs_global_loc;
40006ac4: d2 20 80 00 st %o1, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006ac8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006acc: 01 00 00 00 nop
rtems_filesystem_global_location_release(lhs_global_loc, true);
40006ad0: 92 10 20 01 mov 1, %o1 ! 1 <_TLS_Alignment>
40006ad4: 82 13 c0 00 mov %o7, %g1
40006ad8: 7f ff ff de call 40006a50 <rtems_filesystem_global_location_release>
40006adc: 9e 10 40 00 mov %g1, %o7
40006968 <rtems_filesystem_global_location_obtain>:
{
40006968: 9d e3 bf 98 save %sp, -104, %sp
if (deferred_released_global_locations != NULL) {
4000696c: 3b 10 00 5a sethi %hi(0x40016800), %i5
40006970: c2 07 61 d4 ld [ %i5 + 0x1d4 ], %g1 ! 400169d4 <deferred_released_global_locations>
40006974: 80 a0 60 00 cmp %g1, 0
40006978: 02 80 00 1e be 400069f0 <rtems_filesystem_global_location_obtain+0x88>
4000697c: 01 00 00 00 nop
40006980: ba 17 61 d4 or %i5, 0x1d4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006984: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
40006988: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
4000698c: 80 a2 20 00 cmp %o0, 0
40006990: 02 80 00 07 be 400069ac <rtems_filesystem_global_location_obtain+0x44>
<== NEVER TAKEN
40006994: 92 10 20 00 clr %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
40006998: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
<== NOT EXECUTED
count = current->deferred_released_count;
4000699c: d2 02 20 20 ld [ %o0 + 0x20 ], %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
400069a0: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
current->deferred_released_next = NULL;
400069a4: c0 22 20 1c clr [ %o0 + 0x1c ]
<== NOT EXECUTED
current->deferred_released_count = 0;
400069a8: c0 22 20 20 clr [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400069ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400069b0: 01 00 00 00 nop
if (current != NULL) {
400069b4: 80 a2 20 00 cmp %o0, 0
400069b8: 02 80 00 0e be 400069f0 <rtems_filesystem_global_location_obtain+0x88>
<== NEVER TAKEN
400069bc: 01 00 00 00 nop
release_with_count(current, count);
400069c0: 7f ff ff be call 400068b8 <release_with_count>
400069c4: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400069c8: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
400069cc: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
400069d0: 80 a2 20 00 cmp %o0, 0
400069d4: 12 bf ff f1 bne 40006998 <rtems_filesystem_global_location_obtain+0x30>
<== NEVER TAKEN
400069d8: 92 10 20 00 clr %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400069dc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400069e0: 01 00 00 00 nop
if (current != NULL) {
400069e4: 80 a2 20 00 cmp %o0, 0
400069e8: 12 bf ff f6 bne 400069c0 <rtems_filesystem_global_location_obtain+0x58>
<== NEVER TAKEN
400069ec: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400069f0: 91 d0 20 09 ta 9
<== NOT EXECUTED
global_loc = *global_loc_ptr;
400069f4: f0 06 00 00 ld [ %i0 ], %i0
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
400069f8: 80 a6 20 00 cmp %i0, 0
400069fc: 02 80 00 07 be 40006a18 <rtems_filesystem_global_location_obtain+0xb0>
<== NEVER TAKEN
40006a00: 01 00 00 00 nop
40006a04: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
40006a08: c4 08 a0 28 ldub [ %g2 + 0x28 ], %g2
40006a0c: 80 a0 a0 00 cmp %g2, 0
40006a10: 32 80 00 0a bne,a 40006a38 <rtems_filesystem_global_location_obtain+0xd0>
<== ALWAYS TAKEN
40006a14: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
errno = ENXIO;
40006a18: 40 00 2e 97 call 40012474 <__errno>
<== NOT EXECUTED
40006a1c: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
40006a20: 84 10 20 06 mov 6, %g2
<== NOT EXECUTED
40006a24: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
global_loc = &rtems_filesystem_global_location_null;
40006a28: 31 10 00 56 sethi %hi(0x40015800), %i0
<== NOT EXECUTED
40006a2c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
40006a30: b0 16 21 2c or %i0, 0x12c, %i0
<== NOT EXECUTED
++global_loc->reference_count;
40006a34: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
<== NOT EXECUTED
40006a38: 84 00 a0 01 inc %g2
<== NOT EXECUTED
40006a3c: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006a40: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006a44: 01 00 00 00 nop
}
40006a48: 81 c7 e0 08 ret
40006a4c: 81 e8 00 00 restore
40006a50 <rtems_filesystem_global_location_release>:
if (!deferred) {
40006a50: 80 a2 60 00 cmp %o1, 0
40006a54: 22 80 00 16 be,a 40006aac <rtems_filesystem_global_location_release+0x5c>
40006a58: 92 10 20 01 mov 1, %o1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006a5c: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (global_loc->deferred_released_count == 0) {
40006a60: c6 02 20 20 ld [ %o0 + 0x20 ], %g3
40006a64: 80 a0 e0 00 cmp %g3, 0
40006a68: 22 80 00 08 be,a 40006a88 <rtems_filesystem_global_location_release+0x38>
40006a6c: 07 10 00 5a sethi %hi(0x40016800), %g3
++global_loc->deferred_released_count;
40006a70: 86 00 e0 01 inc %g3
<== NOT EXECUTED
40006a74: c6 22 20 20 st %g3, [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006a78: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006a7c: 01 00 00 00 nop
}
40006a80: 81 c3 e0 08 retl
40006a84: 01 00 00 00 nop
rtems_filesystem_global_location_t *head =
40006a88: c8 00 e1 d4 ld [ %g3 + 0x1d4 ], %g4
<== NOT EXECUTED
global_loc->deferred_released_next = head;
40006a8c: c8 22 20 1c st %g4, [ %o0 + 0x1c ]
<== NOT EXECUTED
global_loc->deferred_released_count = 1;
40006a90: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
deferred_released_global_locations = global_loc;
40006a94: d0 20 e1 d4 st %o0, [ %g3 + 0x1d4 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 1;
40006a98: c8 22 20 20 st %g4, [ %o0 + 0x20 ]
<== NOT EXECUTED
40006a9c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006aa0: 01 00 00 00 nop
}
40006aa4: 81 c3 e0 08 retl
40006aa8: 01 00 00 00 nop
release_with_count(global_loc, 1);
40006aac: 82 13 c0 00 mov %o7, %g1
40006ab0: 7f ff ff 82 call 400068b8 <release_with_count>
40006ab4: 9e 10 40 00 mov %g1, %o7
40004d88 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40004d88: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40004d8c: 05 10 00 4f sethi %hi(0x40013c00), %g2
40004d90: 82 10 a1 cc or %g2, 0x1cc, %g1 ! 40013dcc <rtems_filesystem_root_configuration>
40004d94: d0 00 a1 cc ld [ %g2 + 0x1cc ], %o0
40004d98: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
40004d9c: d6 00 60 0c ld [ %g1 + 0xc ], %o3
40004da0: d4 00 60 08 ld [ %g1 + 8 ], %o2
40004da4: 40 00 02 40 call 400056a4 <mount>
40004da8: d2 00 60 04 ld [ %g1 + 4 ], %o1
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
40004dac: 80 a2 20 00 cmp %o0, 0
40004db0: 12 80 00 0a bne 40004dd8 <rtems_filesystem_initialize+0x50>
<== NEVER TAKEN
40004db4: 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 );
40004db8: 11 10 00 50 sethi %hi(0x40014000), %o0
40004dbc: 40 00 01 f2 call 40005584 <mkdir>
40004dc0: 90 12 21 28 or %o0, 0x128, %o0 ! 40014128 <IMFS_node_control_sym_link+0x14>
if ( rv != 0 )
40004dc4: 80 a2 20 00 cmp %o0, 0
40004dc8: 12 80 00 07 bne 40004de4 <rtems_filesystem_initialize+0x5c>
<== NEVER TAKEN
40004dcc: 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.
*/
}
40004dd0: 81 c7 e0 08 ret
40004dd4: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xABCD0002 );
40004dd8: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
<== NOT EXECUTED
40004ddc: 40 00 09 69 call 40007380 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40004de0: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0x6b8d0002>
<== NOT EXECUTED
rtems_fatal_error_occurred( 0xABCD0003 );
40004de4: 40 00 09 67 call 40007380 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40004de8: 90 12 20 03 or %o0, 3, %o0
<== NOT EXECUTED
40004dec: 01 00 00 00 nop
<== NOT EXECUTED
40010a14 <rtems_filesystem_iterate>:
{
40010a14: 9d e3 bf a0 save %sp, -96, %sp
while ( table_entry->type && !stop ) {
40010a18: 3b 10 00 4f sethi %hi(0x40013c00), %i5
40010a1c: c2 07 62 48 ld [ %i5 + 0x248 ], %g1 ! 40013e48 <rtems_filesystem_table>
40010a20: 80 a0 60 00 cmp %g1, 0
40010a24: 12 80 00 06 bne 40010a3c <rtems_filesystem_iterate+0x28>
<== ALWAYS TAKEN
40010a28: ba 17 62 48 or %i5, 0x248, %i5
40010a2c: 30 80 00 0f b,a 40010a68 <rtems_filesystem_iterate+0x54>
<== NOT EXECUTED
40010a30: 80 a2 20 00 cmp %o0, 0
40010a34: 32 80 00 22 bne,a 40010abc <rtems_filesystem_iterate+0xa8>
40010a38: b8 0f 20 ff and %i4, 0xff, %i4
stop = (*routine)( table_entry, routine_arg );
40010a3c: 90 10 00 1d mov %i5, %o0
40010a40: 9f c6 00 00 call %i0
40010a44: 92 10 00 19 mov %i1, %o1
++table_entry;
40010a48: ba 07 60 08 add %i5, 8, %i5
while ( table_entry->type && !stop ) {
40010a4c: c2 07 40 00 ld [ %i5 ], %g1
40010a50: 80 a0 60 00 cmp %g1, 0
40010a54: 12 bf ff f7 bne 40010a30 <rtems_filesystem_iterate+0x1c>
40010a58: b8 10 00 08 mov %o0, %i4
if ( !stop ) {
40010a5c: b8 8a 20 ff andcc %o0, 0xff, %i4
40010a60: 12 80 00 17 bne 40010abc <rtems_filesystem_iterate+0xa8>
<== ALWAYS TAKEN
40010a64: 01 00 00 00 nop
rtems_libio_lock();
40010a68: 7f ff d1 e6 call 40005200 <rtems_libio_lock>
<== NOT EXECUTED
40010a6c: 37 10 00 56 sethi %hi(0x40015800), %i3
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40010a70: fa 06 e2 bc ld [ %i3 + 0x2bc ], %i5 ! 40015abc <filesystem_chain>
<== NOT EXECUTED
40010a74: b6 16 e2 bc or %i3, 0x2bc, %i3
<== NOT EXECUTED
for (
40010a78: b6 06 e0 04 add %i3, 4, %i3
<== NOT EXECUTED
40010a7c: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
40010a80: 12 80 00 06 bne 40010a98 <rtems_filesystem_iterate+0x84>
<== NOT EXECUTED
40010a84: b8 10 20 00 clr %i4
<== NOT EXECUTED
40010a88: 30 80 00 0b b,a 40010ab4 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
!rtems_chain_is_tail( chain, node ) && !stop;
40010a8c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40010a90: 12 80 00 09 bne 40010ab4 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
40010a94: 01 00 00 00 nop
<== NOT EXECUTED
stop = (*routine)( &fsn->entry, routine_arg );
40010a98: 90 07 60 08 add %i5, 8, %o0
<== NOT EXECUTED
40010a9c: 9f c6 00 00 call %i0
<== NOT EXECUTED
40010aa0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40010aa4: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
for (
40010aa8: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
40010aac: 12 bf ff f8 bne 40010a8c <rtems_filesystem_iterate+0x78>
<== NOT EXECUTED
40010ab0: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rtems_libio_unlock();
40010ab4: 7f ff d1 d8 call 40005214 <rtems_libio_unlock>
<== NOT EXECUTED
40010ab8: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
}
40010abc: 81 c7 e0 08 ret
40010ac0: 91 e8 00 1c restore %g0, %i4, %o0
40006790 <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;
40006790: da 02 60 08 ld [ %o1 + 8 ], %o5
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40006794: c8 02 60 0c ld [ %o1 + 0xc ], %g4
<== NOT EXECUTED
dst->handlers = src->handlers;
40006798: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
4000679c: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
<== NOT EXECUTED
400067a0: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
400067a4: da 22 20 08 st %o5, [ %o0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
400067a8: c8 22 20 0c st %g4, [ %o0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
400067ac: c6 22 20 10 st %g3, [ %o0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400067b0: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
400067b4: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
old_last = tail->previous;
400067b8: c8 00 e0 1c ld [ %g3 + 0x1c ], %g4
return &the_chain->Tail.Node;
400067bc: 9a 00 e0 18 add %g3, 0x18, %o5
the_node->next = tail;
400067c0: da 22 00 00 st %o5, [ %o0 ]
tail->previous = the_node;
400067c4: d0 20 e0 1c st %o0, [ %g3 + 0x1c ]
old_last->next = the_node;
400067c8: d0 21 00 00 st %o0, [ %g4 ]
the_node->previous = old_last;
400067cc: c8 22 20 04 st %g4, [ %o0 + 4 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400067d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400067d4: 01 00 00 00 nop
rtems_chain_initialize_node(&dst->mt_entry_node);
rtems_filesystem_location_add_to_mt_entry(dst);
return dst;
}
400067d8: 81 c3 e0 08 retl
400067dc: 01 00 00 00 nop
40006b64 <rtems_filesystem_location_copy_and_detach>:
{
40006b64: 9d e3 bf a0 save %sp, -96, %sp
dst->node_access = src->node_access;
40006b68: c8 06 60 08 ld [ %i1 + 8 ], %g4
dst->node_access_2 = src->node_access_2;
40006b6c: c6 06 60 0c ld [ %i1 + 0xc ], %g3
dst->handlers = src->handlers;
40006b70: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
dst->mt_entry = src->mt_entry;
40006b74: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
40006b78: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
dst->node_access = src->node_access;
40006b7c: c8 26 20 08 st %g4, [ %i0 + 8 ]
dst->node_access_2 = src->node_access_2;
40006b80: c6 26 20 0c st %g3, [ %i0 + 0xc ]
dst->handlers = src->handlers;
40006b84: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006b88: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
40006b8c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40006b90: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006b94: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006b98: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
40006b9c: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40006ba0: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006ba4: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006ba8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006bac: 01 00 00 00 nop
rtems_filesystem_location_remove_from_mt_entry(detach);
40006bb0: 7f ff ff cc call 40006ae0 <rtems_filesystem_location_remove_from_mt_entry>
40006bb4: 90 10 00 19 mov %i1, %o0
dst->node_access = src->node_access;
40006bb8: 03 10 00 56 sethi %hi(0x40015800), %g1
40006bbc: 82 10 61 2c or %g1, 0x12c, %g1 ! 4001592c <rtems_filesystem_global_location_null>
40006bc0: c4 00 60 08 ld [ %g1 + 8 ], %g2
40006bc4: c4 26 60 08 st %g2, [ %i1 + 8 ]
dst->node_access_2 = src->node_access_2;
40006bc8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40006bcc: c4 26 60 0c st %g2, [ %i1 + 0xc ]
dst->handlers = src->handlers;
40006bd0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
dst->mt_entry = src->mt_entry;
40006bd4: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40006bd8: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
dst->handlers = src->handlers;
40006bdc: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006be0: 91 d0 20 09 ta 9
<== NOT EXECUTED
40006be4: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40006be8: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006bec: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006bf0: c8 26 40 00 st %g4, [ %i1 ]
<== NOT EXECUTED
tail->previous = the_node;
40006bf4: f2 20 a0 1c st %i1, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40006bf8: f2 20 c0 00 st %i1, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006bfc: c6 26 60 04 st %g3, [ %i1 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006c00: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006c04: 01 00 00 00 nop
}
40006c08: 81 c7 e0 08 ret
40006c0c: 81 e8 00 00 restore
400067e0 <rtems_filesystem_location_detach>:
void rtems_filesystem_location_detach(
rtems_filesystem_location_info_t *detach
)
{
400067e0: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_free(detach);
400067e4: 40 00 28 24 call 40010874 <rtems_filesystem_location_free>
400067e8: 90 10 00 18 mov %i0, %o0
dst->node_access = src->node_access;
400067ec: 03 10 00 56 sethi %hi(0x40015800), %g1
<== NOT EXECUTED
400067f0: 82 10 61 2c or %g1, 0x12c, %g1 ! 4001592c <rtems_filesystem_global_location_null>
<== NOT EXECUTED
400067f4: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
400067f8: c4 26 20 08 st %g2, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
400067fc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40006800: c4 26 20 0c st %g2, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40006804: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40006808: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
4000680c: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40006810: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006814: 91 d0 20 09 ta 9
<== NOT EXECUTED
40006818: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
4000681c: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006820: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006824: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
40006828: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
4000682c: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006830: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006834: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006838: 01 00 00 00 nop
rtems_filesystem_location_initialize_to_null(detach);
}
4000683c: 81 c7 e0 08 ret
40006840: 81 e8 00 00 restore
40006ae0 <rtems_filesystem_location_remove_from_mt_entry>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006ae0: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous = the_node->previous;
40006ae4: c6 02 20 04 ld [ %o0 + 4 ], %g3
next = the_node->next;
40006ae8: c8 02 00 00 ld [ %o0 ], %g4
next->previous = previous;
40006aec: c6 21 20 04 st %g3, [ %g4 + 4 ]
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
40006af0: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
previous->next = next;
40006af4: c8 20 c0 00 st %g4, [ %g3 ]
40006af8: c6 08 a0 28 ldub [ %g2 + 0x28 ], %g3
40006afc: 80 a0 e0 00 cmp %g3, 0
40006b00: 12 80 00 07 bne 40006b1c <rtems_filesystem_location_remove_from_mt_entry+0x3c>
40006b04: 01 00 00 00 nop
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
40006b08: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
40006b0c: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
40006b10: 80 a1 00 03 cmp %g4, %g3
40006b14: 22 80 00 06 be,a 40006b2c <rtems_filesystem_location_remove_from_mt_entry+0x4c>
40006b18: c6 00 a0 24 ld [ %g2 + 0x24 ], %g3
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006b1c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006b20: 01 00 00 00 nop
}
40006b24: 81 c3 e0 08 retl
40006b28: 01 00 00 00 nop
&& mt_entry->mt_fs_root->reference_count == 1;
40006b2c: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3
40006b30: 80 a0 e0 01 cmp %g3, 1
40006b34: 12 bf ff fa bne 40006b1c <rtems_filesystem_location_remove_from_mt_entry+0x3c>
<== ALWAYS TAKEN
40006b38: 86 00 a0 14 add %g2, 0x14, %g3
return &the_chain->Tail.Node;
40006b3c: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
head->previous = NULL;
40006b40: c0 20 a0 18 clr [ %g2 + 0x18 ]
<== NOT EXECUTED
head->next = tail;
40006b44: c8 20 a0 14 st %g4, [ %g2 + 0x14 ]
<== NOT EXECUTED
tail->previous = head;
40006b48: c6 20 a0 1c st %g3, [ %g2 + 0x1c ]
<== NOT EXECUTED
40006b4c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006b50: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
40006b54: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
40006b58: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40006b5c: 7f ff ff 3a call 40006844 <rtems_filesystem_do_unmount>
<== NOT EXECUTED
40006b60: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40006c10 <rtems_filesystem_location_transform_to_global>:
{
40006c10: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
40006c14: 7f ff fa 48 call 40005534 <malloc>
40006c18: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
40006c1c: ba 92 20 00 orcc %o0, 0, %i5
40006c20: 02 80 00 1c be 40006c90 <rtems_filesystem_location_transform_to_global+0x80>
<== NEVER TAKEN
40006c24: b8 10 20 01 mov 1, %i4
<== NOT EXECUTED
dst->node_access = src->node_access;
40006c28: c8 06 20 08 ld [ %i0 + 8 ], %g4
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40006c2c: c6 06 20 0c ld [ %i0 + 0xc ], %g3
<== NOT EXECUTED
dst->handlers = src->handlers;
40006c30: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40006c34: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
global_loc->deferred_released_next = NULL;
40006c38: c0 27 60 1c clr [ %i5 + 0x1c ]
<== NOT EXECUTED
global_loc->reference_count = 1;
40006c3c: f8 27 60 18 st %i4, [ %i5 + 0x18 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 0;
40006c40: c0 27 60 20 clr [ %i5 + 0x20 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40006c44: c8 27 60 08 st %g4, [ %i5 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40006c48: c6 27 60 0c st %g3, [ %i5 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40006c4c: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40006c50: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006c54: 91 d0 20 09 ta 9
<== NOT EXECUTED
40006c58: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
old_last = tail->previous;
40006c5c: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
return &the_chain->Tail.Node;
40006c60: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006c64: c8 27 40 00 st %g4, [ %i5 ]
<== NOT EXECUTED
tail->previous = the_node;
40006c68: fa 20 a0 1c st %i5, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40006c6c: fa 20 c0 00 st %i5, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006c70: c6 27 60 04 st %g3, [ %i5 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006c74: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006c78: 01 00 00 00 nop
rtems_filesystem_location_remove_from_mt_entry(loc);
40006c7c: 90 10 00 18 mov %i0, %o0
40006c80: 7f ff ff 98 call 40006ae0 <rtems_filesystem_location_remove_from_mt_entry>
40006c84: b0 10 00 1d mov %i5, %i0
}
40006c88: 81 c7 e0 08 ret
40006c8c: 81 e8 00 00 restore
rtems_filesystem_location_free(loc);
40006c90: 40 00 26 f9 call 40010874 <rtems_filesystem_location_free>
<== NOT EXECUTED
40006c94: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
40006c98: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
40006c9c: 7f ff ff 33 call 40006968 <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40006ca0: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
errno = ENOMEM;
40006ca4: 40 00 2d f4 call 40012474 <__errno>
<== NOT EXECUTED
40006ca8: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
40006cac: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40006cb0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40006cb4: 81 c7 e0 08 ret
<== NOT EXECUTED
40006cb8: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
400055a0 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
400055a0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
400055a4: 40 00 01 e3 call 40005d30 <rtems_current_user_env_get>
400055a8: 01 00 00 00 nop
400055ac: d6 02 20 08 ld [ %o0 + 8 ], %o3
400055b0: 96 2e c0 0b andn %i3, %o3, %o3
switch (mode & S_IFMT) {
400055b4: 03 00 00 3c sethi %hi(0xf000), %g1
400055b8: 05 00 00 10 sethi %hi(0x4000), %g2
400055bc: 82 0a c0 01 and %o3, %g1, %g1
400055c0: 80 a0 40 02 cmp %g1, %g2
400055c4: 22 80 00 0c be,a 400055f4 <rtems_filesystem_mknod+0x54>
400055c8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400055cc: 08 80 00 14 bleu 4000561c <rtems_filesystem_mknod+0x7c>
400055d0: 05 00 00 04 sethi %hi(0x1000), %g2
400055d4: 05 00 00 18 sethi %hi(0x6000), %g2
400055d8: 80 a0 40 02 cmp %g1, %g2
400055dc: 02 80 00 05 be 400055f0 <rtems_filesystem_mknod+0x50>
400055e0: 05 00 00 20 sethi %hi(0x8000), %g2
400055e4: 80 a0 40 02 cmp %g1, %g2
400055e8: 12 80 00 13 bne 40005634 <rtems_filesystem_mknod+0x94>
<== NEVER TAKEN
400055ec: 01 00 00 00 nop
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
400055f0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
400055f4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400055f8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
400055fc: 98 10 00 1c mov %i4, %o4
40005600: 9a 10 00 1d mov %i5, %o5
40005604: 94 10 00 1a mov %i2, %o2
40005608: 92 10 00 19 mov %i1, %o1
4000560c: 9f c0 40 00 call %g1
40005610: 90 10 00 18 mov %i0, %o0
40005614: 81 c7 e0 08 ret
40005618: 91 e8 00 08 restore %g0, %o0, %o0
switch (mode & S_IFMT) {
4000561c: 80 a0 40 02 cmp %g1, %g2
40005620: 02 bf ff f4 be 400055f0 <rtems_filesystem_mknod+0x50>
40005624: 05 00 00 08 sethi %hi(0x2000), %g2
40005628: 80 a0 40 02 cmp %g1, %g2
4000562c: 22 bf ff f2 be,a 400055f4 <rtems_filesystem_mknod+0x54>
<== ALWAYS TAKEN
40005630: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
errno = EINVAL;
40005634: 40 00 33 90 call 40012474 <__errno>
<== NOT EXECUTED
40005638: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000563c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40005640: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
return rv;
}
40005644: 81 c7 e0 08 ret
<== NOT EXECUTED
40005648: 81 e8 00 00 restore
<== NOT EXECUTED
400142a8 <rtems_filesystem_null_handlers>:
400142a8: 40 00 6e a0 40 01 00 44 40 01 02 98 40 01 03 30 @.n.@..D@...@..0
400142b8: 40 01 00 cc 40 01 02 50 40 00 6e a8 40 01 00 b0 @...@..P@.n.@...
400142c8: 40 01 00 70 40 01 00 70 40 01 00 60 40 01 02 90 @..p@..p@..`@...
400142d8: 40 01 00 e8 40 01 02 b4 40 01 03 4c 40 01 02 6c @...@...@..L@..l
40004a90 <rtems_gxx_key_create>:
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
40004a90: 9d e3 bf a0 save %sp, -96, %sp
int eno;
pthread_key_t *pkey;
pkey = malloc( sizeof( *pkey ) );
40004a94: 40 00 01 3d call 40004f88 <malloc>
40004a98: 90 10 20 04 mov 4, %o0
*key = pkey;
40004a9c: d0 26 00 00 st %o0, [ %i0 ]
pkey = malloc( sizeof( *pkey ) );
40004aa0: b8 10 00 08 mov %o0, %i4
if ( pkey == NULL )
40004aa4: 80 a2 20 00 cmp %o0, 0
40004aa8: 02 80 00 07 be 40004ac4 <rtems_gxx_key_create+0x34>
<== NEVER TAKEN
40004aac: ba 10 20 0c mov 0xc, %i5
printk(
"gxx_wrappers: create key=%x, dtor=%x, pkey=%x\n", key, dtor, pkey
);
#endif
eno = pthread_key_create(pkey, dtor);
40004ab0: 40 00 07 16 call 40006708 <pthread_key_create>
40004ab4: 92 10 00 19 mov %i1, %o1
if ( eno != 0 ) {
40004ab8: ba 92 20 00 orcc %o0, 0, %i5
40004abc: 12 80 00 04 bne 40004acc <rtems_gxx_key_create+0x3c>
<== NEVER TAKEN
40004ac0: 01 00 00 00 nop
free( pkey );
*key = NULL;
}
return eno;
}
40004ac4: 81 c7 e0 08 ret
40004ac8: 91 e8 00 1d restore %g0, %i5, %o0
free( pkey );
40004acc: 7f ff ff a4 call 4000495c <free>
<== NOT EXECUTED
40004ad0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
*key = NULL;
40004ad4: c0 26 00 00 clr [ %i0 ]
<== NOT EXECUTED
}
40004ad8: 81 c7 e0 08 ret
<== NOT EXECUTED
40004adc: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40004b84 <rtems_gxx_mutex_init>:
/*
* MUTEX support
*/
void rtems_gxx_mutex_init (__gthread_mutex_t *mutex)
{
40004b84: 9d e3 bf a0 save %sp, -96, %sp
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init =%X\n", *mutex );
#endif
status = rtems_semaphore_create(
40004b88: 96 10 20 00 clr %o3
40004b8c: 98 10 00 18 mov %i0, %o4
40004b90: 94 10 20 54 mov 0x54, %o2
40004b94: 92 10 20 01 mov 1, %o1
40004b98: 11 11 d0 d0 sethi %hi(0x47434000), %o0
40004b9c: 40 00 08 39 call 40006c80 <rtems_semaphore_create>
40004ba0: 90 12 23 32 or %o0, 0x332, %o0 ! 47434332 <RAM_END+0x7034332>
RTEMS_PRIORITY|RTEMS_BINARY_SEMAPHORE|
RTEMS_INHERIT_PRIORITY|RTEMS_NO_PRIORITY_CEILING|RTEMS_LOCAL,
0,
(rtems_id *)mutex
);
if ( status != RTEMS_SUCCESSFUL ) {
40004ba4: 80 a2 20 00 cmp %o0, 0
40004ba8: 12 80 00 04 bne 40004bb8 <rtems_gxx_mutex_init+0x34>
<== NEVER TAKEN
40004bac: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_GXX_MUTEX_INIT_FAILED );
}
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );
#endif
}
40004bb0: 81 c7 e0 08 ret
40004bb4: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_GXX_MUTEX_INIT_FAILED );
40004bb8: 40 00 0d c5 call 400082cc <_Internal_error>
<== NOT EXECUTED
40004bbc: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40004bc0: 01 00 00 00 nop
<== NOT EXECUTED
40004b40 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
40004b40: 9d e3 bf a0 save %sp, -96, %sp
pthread_key_t *pkey = key;
int eno;
if ( pkey == NULL ) {
40004b44: 80 a6 20 00 cmp %i0, 0
40004b48: 02 80 00 0a be 40004b70 <rtems_gxx_setspecific+0x30>
40004b4c: 01 00 00 00 nop
return EINVAL;
}
eno = pthread_setspecific( *pkey, ptr );
40004b50: d0 06 00 00 ld [ %i0 ], %o0
40004b54: 40 00 07 b4 call 40006a24 <pthread_setspecific>
40004b58: 92 10 00 19 mov %i1, %o1
ptr,
rtems_task_self()
);
#endif
if ( eno != 0 ) {
40004b5c: b0 92 20 00 orcc %o0, 0, %i0
40004b60: 12 80 00 06 bne 40004b78 <rtems_gxx_setspecific+0x38>
<== NEVER TAKEN
40004b64: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_GXX_KEY_ADD_FAILED );
}
return 0;
}
40004b68: 81 c7 e0 08 ret
40004b6c: 81 e8 00 00 restore
40004b70: 81 c7 e0 08 ret
40004b74: 91 e8 20 16 restore %g0, 0x16, %o0
_Internal_error( INTERNAL_ERROR_GXX_KEY_ADD_FAILED );
40004b78: 40 00 0d d5 call 400082cc <_Internal_error>
<== NOT EXECUTED
40004b7c: 90 10 20 15 mov 0x15, %o0
<== NOT EXECUTED
40004b80: 01 00 00 00 nop
<== NOT EXECUTED
40005390 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
40005390: 9d e3 bf a0 save %sp, -96, %sp
40005394: 03 10 00 5c sethi %hi(0x40017000), %g1
40005398: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 40017100 <_System_state_Current>
Heap_Control *heap = RTEMS_Malloc_Heap;
4000539c: 05 10 00 56 sethi %hi(0x40015800), %g2
if ( _System_state_Is_up( state ) ) {
400053a0: 80 a0 60 02 cmp %g1, 2
400053a4: 02 80 00 21 be 40005428 <rtems_heap_allocate_aligned_with_boundary+0x98>
400053a8: f8 00 a0 8c ld [ %g2 + 0x8c ], %i4
} else if ( _System_state_Is_before_multitasking( state ) ) {
400053ac: 80 a0 60 01 cmp %g1, 1
400053b0: 02 80 00 22 be 40005438 <rtems_heap_allocate_aligned_with_boundary+0xa8>
400053b4: 96 10 00 1a mov %i2, %o3
boundary
);
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
p = _Heap_Allocate_aligned_with_boundary(
400053b8: 94 10 00 19 mov %i1, %o2
400053bc: 92 10 00 18 mov %i0, %o1
400053c0: 40 00 08 fc call 400077b0 <_Heap_Allocate_aligned_with_boundary>
400053c4: 90 10 00 1c mov %i4, %o0
400053c8: 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 ) {
400053cc: 80 a7 60 00 cmp %i5, 0
400053d0: 12 80 00 0b bne 400053fc <rtems_heap_allocate_aligned_with_boundary+0x6c>
400053d4: 80 a6 60 00 cmp %i1, 0
400053d8: 12 80 00 09 bne 400053fc <rtems_heap_allocate_aligned_with_boundary+0x6c>
400053dc: 80 a6 a0 00 cmp %i2, 0
400053e0: 12 80 00 23 bne 4000546c <rtems_heap_allocate_aligned_with_boundary+0xdc>
<== NEVER TAKEN
400053e4: 03 10 00 4f sethi %hi(0x40013c00), %g1
p = (*rtems_malloc_extend_handler)( heap, size );
400053e8: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 ! 40013d70 <rtems_malloc_extend_handler>
400053ec: 92 10 00 18 mov %i0, %o1
400053f0: 9f c0 40 00 call %g1
400053f4: 90 10 00 1c mov %i4, %o0
400053f8: ba 10 00 08 mov %o0, %i5
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( p != NULL && rtems_malloc_dirty_helper != NULL )
400053fc: 80 a7 60 00 cmp %i5, 0
40005400: 02 80 00 1b be 4000546c <rtems_heap_allocate_aligned_with_boundary+0xdc>
40005404: 03 10 00 57 sethi %hi(0x40015c00), %g1
40005408: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 40015d30 <rtems_malloc_dirty_helper>
4000540c: 80 a0 60 00 cmp %g1, 0
40005410: 02 80 00 04 be 40005420 <rtems_heap_allocate_aligned_with_boundary+0x90>
40005414: 92 10 00 18 mov %i0, %o1
(*rtems_malloc_dirty_helper)( p, size );
40005418: 9f c0 40 00 call %g1
4000541c: 90 10 00 1d mov %i5, %o0
return p;
}
40005420: 81 c7 e0 08 ret
40005424: 91 e8 00 1d restore %g0, %i5, %o0
40005428: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
if ( _Thread_Dispatch_is_enabled() ) {
4000542c: 80 a0 60 00 cmp %g1, 0
40005430: 32 80 00 10 bne,a 40005470 <rtems_heap_allocate_aligned_with_boundary+0xe0>
40005434: ba 10 20 00 clr %i5
_RTEMS_Lock_allocator();
40005438: 40 00 08 73 call 40007604 <_RTEMS_Lock_allocator>
4000543c: 01 00 00 00 nop
_Malloc_Process_deferred_frees();
40005440: 7f ff ff bb call 4000532c <_Malloc_Process_deferred_frees>
40005444: 01 00 00 00 nop
p = _Heap_Allocate_aligned_with_boundary(
40005448: 96 10 00 1a mov %i2, %o3
4000544c: 94 10 00 19 mov %i1, %o2
40005450: 92 10 00 18 mov %i0, %o1
40005454: 40 00 08 d7 call 400077b0 <_Heap_Allocate_aligned_with_boundary>
40005458: 90 10 00 1c mov %i4, %o0
_RTEMS_Unlock_allocator();
4000545c: 40 00 08 6f call 40007618 <_RTEMS_Unlock_allocator>
40005460: ba 10 00 08 mov %o0, %i5
break;
40005464: 10 bf ff db b 400053d0 <rtems_heap_allocate_aligned_with_boundary+0x40>
40005468: 80 a7 60 00 cmp %i5, 0
return NULL;
4000546c: ba 10 20 00 clr %i5
}
40005470: 81 c7 e0 08 ret
40005474: 91 e8 00 1d restore %g0, %i5, %o0
4000543c <rtems_heap_extend_via_sbrk>:
void *rtems_heap_extend_via_sbrk(
Heap_Control *heap,
size_t alloc_size
)
{
4000543c: 9d e3 bf a0 save %sp, -96, %sp
ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;
40005440: 03 10 00 4c sethi %hi(0x40013000), %g1
40005444: c4 00 63 bc ld [ %g1 + 0x3bc ], %g2 ! 400133bc <RTEMS_Malloc_Sbrk_amount>
ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;
ptrdiff_t misaligned = sbrk_amount != 0 ? sbrk_size % sbrk_amount : 0;
40005448: 80 a0 a0 00 cmp %g2, 0
4000544c: 12 80 00 04 bne 4000545c <rtems_heap_extend_via_sbrk+0x20>
40005450: 01 00 00 00 nop
}
}
}
return return_this;
}
40005454: 81 c7 e0 08 ret
40005458: 91 e8 20 00 restore %g0, 0, %o0
ptrdiff_t misaligned = sbrk_amount != 0 ? sbrk_size % sbrk_amount : 0;
4000545c: 87 3e 60 1f sra %i1, 0x1f, %g3
40005460: 81 80 e0 00 wr %g3, %y
40005464: 01 00 00 00 nop
40005468: 01 00 00 00 nop
4000546c: 01 00 00 00 nop
40005470: 82 7e 40 02 sdiv %i1, %g2, %g1
40005474: 82 58 40 02 smul %g1, %g2, %g1
if ( misaligned != 0 ) {
40005478: 82 a6 40 01 subcc %i1, %g1, %g1
4000547c: 12 80 00 14 bne 400054cc <rtems_heap_extend_via_sbrk+0x90>
40005480: ba 10 00 19 mov %i1, %i5
if ( sbrk_size > 0 && sbrk_amount > 0 ) {
40005484: 80 a7 60 00 cmp %i5, 0
40005488: 04 bf ff f3 ble 40005454 <rtems_heap_extend_via_sbrk+0x18>
<== NEVER TAKEN
4000548c: 80 a0 a0 00 cmp %g2, 0
40005490: 04 bf ff f1 ble 40005454 <rtems_heap_extend_via_sbrk+0x18>
<== NEVER TAKEN
40005494: 01 00 00 00 nop
void *area_begin = sbrk( sbrk_size );
40005498: 7f ff f0 56 call 400015f0 <sbrk>
4000549c: 90 10 00 1d mov %i5, %o0
if ( area_begin != (void *) -1 ) {
400054a0: 80 a2 3f ff cmp %o0, -1
400054a4: 02 bf ff ec be 40005454 <rtems_heap_extend_via_sbrk+0x18>
400054a8: 92 10 00 08 mov %o0, %o1
bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
400054ac: 94 10 00 1d mov %i5, %o2
400054b0: 40 00 0d e8 call 40008c50 <_Protected_heap_Extend>
400054b4: 90 10 00 18 mov %i0, %o0
if ( ok ) {
400054b8: 80 a2 20 00 cmp %o0, 0
400054bc: 02 80 00 07 be 400054d8 <rtems_heap_extend_via_sbrk+0x9c>
400054c0: b6 10 20 00 clr %i3
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
400054c4: 40 00 0d d7 call 40008c20 <_Protected_heap_Allocate_aligned_with_boundary>
<== NOT EXECUTED
400054c8: 95 e8 20 00 restore %g0, 0, %o2
sbrk_size += sbrk_amount - misaligned;
400054cc: 82 20 80 01 sub %g2, %g1, %g1
400054d0: 10 bf ff ed b 40005484 <rtems_heap_extend_via_sbrk+0x48>
400054d4: ba 06 40 01 add %i1, %g1, %i5
sbrk( -sbrk_size );
400054d8: 7f ff f0 46 call 400015f0 <sbrk>
400054dc: 90 20 00 1d neg %i5, %o0
return return_this;
400054e0: 30 bf ff dd b,a 40005454 <rtems_heap_extend_via_sbrk+0x18>
40005e9c <rtems_heap_null_extend>:
Heap_Control *heap RTEMS_UNUSED,
size_t alloc_size RTEMS_UNUSED
)
{
return NULL;
}
40005e9c: 81 c3 e0 08 retl
40005ea0: 90 10 20 00 clr %o0
4000525c <rtems_libio_allocate>:
return fcntl_flags;
}
rtems_libio_t *rtems_libio_allocate( void )
{
4000525c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_lock();
40005260: 7f ff ff e8 call 40005200 <rtems_libio_lock>
40005264: 01 00 00 00 nop
iop = rtems_libio_iop_free_head;
40005268: 03 10 00 5c sethi %hi(0x40017000), %g1
4000526c: f0 00 60 a4 ld [ %g1 + 0xa4 ], %i0 ! 400170a4 <rtems_libio_iop_free_head>
if ( iop != NULL ) {
40005270: 80 a6 20 00 cmp %i0, 0
40005274: 02 80 00 06 be 4000528c <rtems_libio_allocate+0x30>
<== NEVER TAKEN
40005278: 86 10 60 a4 or %g1, 0xa4, %g3
void *next;
next = iop->data1;
4000527c: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
rtems_libio_iop_free_head = next;
if ( next == NULL ) {
40005280: 80 a0 a0 00 cmp %g2, 0
40005284: 02 80 00 06 be 4000529c <rtems_libio_allocate+0x40>
40005288: c4 20 60 a4 st %g2, [ %g1 + 0xa4 ]
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
}
}
rtems_libio_unlock();
4000528c: 7f ff ff e2 call 40005214 <rtems_libio_unlock>
40005290: 01 00 00 00 nop
return iop;
}
40005294: 81 c7 e0 08 ret
40005298: 81 e8 00 00 restore
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
4000529c: 03 10 00 56 sethi %hi(0x40015800), %g1
rtems_libio_unlock();
400052a0: 7f ff ff dd call 40005214 <rtems_libio_unlock>
400052a4: c6 20 60 ac st %g3, [ %g1 + 0xac ] ! 400158ac <rtems_libio_iop_free_tail>
}
400052a8: 81 c7 e0 08 ret
400052ac: 81 e8 00 00 restore
40005d5c <rtems_libio_free_user_env>:
if (!uses_global_env) {
40005d5c: 03 10 00 56 sethi %hi(0x40015800), %g1
<== NOT EXECUTED
40005d60: 82 10 60 e4 or %g1, 0xe4, %g1 ! 400158e4 <rtems_global_user_env>
<== NOT EXECUTED
40005d64: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
40005d68: 02 80 00 05 be 40005d7c <rtems_libio_free_user_env+0x20>
<== NOT EXECUTED
40005d6c: 01 00 00 00 nop
<== NOT EXECUTED
40005d70: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40005d74: 7f ff ff e6 call 40005d0c <rtems_libio_free_user_env.part.1>
<== NOT EXECUTED
40005d78: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
}
}
40005d7c: 81 c3 e0 08 retl
<== NOT EXECUTED
40005d80: 01 00 00 00 nop
<== NOT EXECUTED
40005a4c <rtems_libio_post_driver>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void rtems_libio_post_driver(void)
{
40005a4c: 9d e3 bf a0 save %sp, -96, %sp
/*
* Attempt to open /dev/console.
*/
if ( open( CONSOLE_DEVICE_NAME, O_RDONLY, 0 ) != STDIN_FILENO ) {
40005a50: 94 10 20 00 clr %o2
40005a54: 92 10 20 00 clr %o1
40005a58: 3b 10 00 50 sethi %hi(0x40014000), %i5
40005a5c: 40 00 00 1a call 40005ac4 <open>
40005a60: 90 17 61 30 or %i5, 0x130, %o0 ! 40014130 <IMFS_node_control_sym_link+0x1c>
40005a64: 80 a2 20 00 cmp %o0, 0
40005a68: 02 80 00 04 be 40005a78 <rtems_libio_post_driver+0x2c>
40005a6c: 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);
}
40005a70: 81 c7 e0 08 ret
40005a74: 81 e8 00 00 restore
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDOUT_FILENO ) {
40005a78: 92 10 20 01 mov 1, %o1
40005a7c: 40 00 00 12 call 40005ac4 <open>
40005a80: 90 17 61 30 or %i5, 0x130, %o0
40005a84: 80 a2 20 01 cmp %o0, 1
40005a88: 12 80 00 0a bne 40005ab0 <rtems_libio_post_driver+0x64>
<== NEVER TAKEN
40005a8c: 94 10 20 00 clr %o2
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
40005a90: 92 10 20 01 mov 1, %o1
40005a94: 40 00 00 0c call 40005ac4 <open>
40005a98: 90 17 61 30 or %i5, 0x130, %o0
40005a9c: 80 a2 20 02 cmp %o0, 2
40005aa0: 12 80 00 06 bne 40005ab8 <rtems_libio_post_driver+0x6c>
<== NEVER TAKEN
40005aa4: 31 10 00 42 sethi %hi(0x40010800), %i0
<== NOT EXECUTED
atexit(rtems_libio_exit);
40005aa8: 40 00 32 6c call 40012458 <atexit>
<== NOT EXECUTED
40005aac: 91 ee 21 c0 restore %i0, 0x1c0, %o0
_Internal_error( INTERNAL_ERROR_LIBIO_STDOUT_FD_OPEN_FAILED );
40005ab0: 40 00 09 31 call 40007f74 <_Internal_error>
<== NOT EXECUTED
40005ab4: 90 10 20 24 mov 0x24, %o0
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
40005ab8: 40 00 09 2f call 40007f74 <_Internal_error>
<== NOT EXECUTED
40005abc: 90 10 20 25 mov 0x25, %o0
<== NOT EXECUTED
40005ac0: 01 00 00 00 nop
<== NOT EXECUTED
4000d824 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
4000d824: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = pthread_getspecific(rtems_current_user_env_key);
4000d828: 39 10 01 86 sethi %hi(0x40061800), %i4
4000d82c: 40 00 2f 06 call 40019444 <pthread_getspecific>
4000d830: d0 07 22 54 ld [ %i4 + 0x254 ], %o0 ! 40061a54 <rtems_current_user_env_key>
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_user_env_t *old_env = rtems_current_user_env;
bool uses_global_env = old_env == &rtems_global_user_env;
if (uses_global_env) {
4000d834: 3b 10 01 6d sethi %hi(0x4005b400), %i5
4000d838: ba 17 60 6c or %i5, 0x6c, %i5 ! 4005b46c <rtems_global_user_env>
4000d83c: 80 a2 00 1d cmp %o0, %i5
4000d840: 02 80 00 04 be 4000d850 <rtems_libio_set_private_env+0x2c>
<== NEVER TAKEN
4000d844: 80 a2 20 00 cmp %o0, 0
4000d848: 12 80 00 30 bne 4000d908 <rtems_libio_set_private_env+0xe4>
4000d84c: b0 10 20 00 clr %i0
Thread_Life_state life_state =
4000d850: 40 00 48 bb call 4001fb3c <_Thread_Set_life_protection>
4000d854: 90 10 20 01 mov 1, %o0
_Thread_Set_life_protection(THREAD_LIFE_PROTECTED);
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
4000d858: 92 10 20 48 mov 0x48, %o1
Thread_Life_state life_state =
4000d85c: b4 10 00 08 mov %o0, %i2
if (sc != RTEMS_SUCCESSFUL) {
rtems_libio_free_user_env(new_env);
}
} else {
sc = RTEMS_NO_MEMORY;
4000d860: b0 10 20 1a mov 0x1a, %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
4000d864: 7f ff ef d5 call 400097b8 <calloc>
4000d868: 90 10 20 01 mov 1, %o0
if (new_env != NULL) {
4000d86c: 80 a2 20 00 cmp %o0, 0
4000d870: 02 80 00 24 be 4000d900 <rtems_libio_set_private_env+0xdc>
<== NEVER TAKEN
4000d874: b6 10 00 08 mov %o0, %i3
*new_env = *old_env;
4000d878: 94 10 20 48 mov 0x48, %o2
4000d87c: 40 00 be 41 call 4003d180 <memcpy>
4000d880: 92 10 00 1d mov %i5, %o1
rtems_filesystem_global_location_obtain(&old_env->root_directory);
4000d884: 40 00 03 dd call 4000e7f8 <rtems_filesystem_global_location_obtain>
4000d888: 90 07 60 04 add %i5, 4, %o0
new_env->root_directory =
4000d88c: d0 26 e0 04 st %o0, [ %i3 + 4 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
4000d890: 40 00 03 da call 4000e7f8 <rtems_filesystem_global_location_obtain>
4000d894: 90 10 00 1d mov %i5, %o0
if (
4000d898: c2 06 e0 04 ld [ %i3 + 4 ], %g1
new_env->current_directory =
4000d89c: d0 26 c0 00 st %o0, [ %i3 ]
if (
4000d8a0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
4000d8a4: 03 10 01 59 sethi %hi(0x40056400), %g1
4000d8a8: 82 10 62 fc or %g1, 0x2fc, %g1 ! 400566fc <rtems_filesystem_null_handlers>
4000d8ac: 80 a0 80 01 cmp %g2, %g1
4000d8b0: 22 80 00 0f be,a 4000d8ec <rtems_libio_set_private_env+0xc8>
<== NEVER TAKEN
4000d8b4: b0 10 20 0d mov 0xd, %i0
<== NOT EXECUTED
&& !rtems_filesystem_global_location_is_null(new_env->current_directory)
4000d8b8: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
4000d8bc: 80 a0 80 01 cmp %g2, %g1
4000d8c0: 02 80 00 0a be 4000d8e8 <rtems_libio_set_private_env+0xc4>
<== NEVER TAKEN
4000d8c4: d0 07 22 54 ld [ %i4 + 0x254 ], %o0
int eno = pthread_setspecific(
4000d8c8: 92 10 00 1b mov %i3, %o1
4000d8cc: 40 00 2f 59 call 40019630 <pthread_setspecific>
4000d8d0: b0 10 20 00 clr %i0
if (eno == 0) {
4000d8d4: 80 a2 20 00 cmp %o0, 0
4000d8d8: 02 80 00 0a be 4000d900 <rtems_libio_set_private_env+0xdc>
<== ALWAYS TAKEN
4000d8dc: 01 00 00 00 nop
4000d8e0: 10 80 00 03 b 4000d8ec <rtems_libio_set_private_env+0xc8>
<== NOT EXECUTED
4000d8e4: b0 10 20 05 mov 5, %i0 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
sc = RTEMS_UNSATISFIED;
4000d8e8: b0 10 20 0d mov 0xd, %i0
<== NOT EXECUTED
if (!uses_global_env) {
4000d8ec: 80 a6 c0 1d cmp %i3, %i5
<== NOT EXECUTED
4000d8f0: 02 80 00 04 be 4000d900 <rtems_libio_set_private_env+0xdc>
<== NOT EXECUTED
4000d8f4: 01 00 00 00 nop
<== NOT EXECUTED
4000d8f8: 7f ff ff ad call 4000d7ac <rtems_libio_free_user_env.part.1>
<== NOT EXECUTED
4000d8fc: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
}
_Thread_Set_life_protection(life_state);
4000d900: 40 00 48 8f call 4001fb3c <_Thread_Set_life_protection>
4000d904: 90 10 00 1a mov %i2, %o0
}
return sc;
}
4000d908: 81 c7 e0 08 ret
4000d90c: 81 e8 00 00 restore
4000980c <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( unsigned int flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
4000980c: 84 0a 20 06 and %o0, 6, %g2
40009810: 80 a0 a0 06 cmp %g2, 6
40009814: 02 80 00 05 be 40009828 <rtems_libio_to_fcntl_flags+0x1c>
<== ALWAYS TAKEN
40009818: 82 10 20 02 mov 2, %g1
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
4000981c: 80 8a 20 02 btst 2, %o0
<== NOT EXECUTED
40009820: 02 80 00 0b be 4000984c <rtems_libio_to_fcntl_flags+0x40>
<== NOT EXECUTED
40009824: 82 10 20 00 clr %g1
<== NOT EXECUTED
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
40009828: 80 8a 20 01 btst 1, %o0
4000982c: 02 80 00 04 be 4000983c <rtems_libio_to_fcntl_flags+0x30>
40009830: 80 8a 22 00 btst 0x200, %o0
fcntl_flags |= O_NONBLOCK;
40009834: 05 00 00 10 sethi %hi(0x4000), %g2
40009838: 82 10 40 02 or %g1, %g2, %g1
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
4000983c: 32 80 00 02 bne,a 40009844 <rtems_libio_to_fcntl_flags+0x38>
<== NEVER TAKEN
40009840: 82 10 60 08 or %g1, 8, %g1
<== NOT EXECUTED
fcntl_flags |= O_APPEND;
}
return fcntl_flags;
}
40009844: 81 c3 e0 08 retl
40009848: 90 10 00 01 mov %g1, %o0
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
4000984c: 83 32 20 02 srl %o0, 2, %g1
<== NOT EXECUTED
40009850: 10 bf ff f6 b 40009828 <rtems_libio_to_fcntl_flags+0x1c>
<== NOT EXECUTED
40009854: 82 08 60 01 and %g1, 1, %g1
<== NOT EXECUTED
400052b8 <rtems_libio_use_global_env>:
void rtems_libio_use_global_env(void)
{
400052b8: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = pthread_getspecific(rtems_current_user_env_key);
400052bc: 39 10 00 5e sethi %hi(0x40017800), %i4
400052c0: 40 00 04 0a call 400062e8 <pthread_getspecific>
400052c4: d0 07 21 10 ld [ %i4 + 0x110 ], %o0 ! 40017910 <rtems_current_user_env_key>
rtems_user_env_t *env = rtems_current_user_env;
bool uses_private_env = env != &rtems_global_user_env;
if (uses_private_env) {
400052c8: 03 10 00 58 sethi %hi(0x40016000), %g1
400052cc: 82 10 60 90 or %g1, 0x90, %g1 ! 40016090 <rtems_global_user_env>
400052d0: 80 a2 00 01 cmp %o0, %g1
400052d4: 02 80 00 0f be 40005310 <rtems_libio_use_global_env+0x58>
<== NEVER TAKEN
400052d8: ba 10 00 08 mov %o0, %i5
400052dc: 80 a2 20 00 cmp %o0, 0
400052e0: 02 80 00 0c be 40005310 <rtems_libio_use_global_env+0x58>
<== NEVER TAKEN
400052e4: 01 00 00 00 nop
Thread_Life_state life_state =
400052e8: 40 00 16 b2 call 4000adb0 <_Thread_Set_life_protection>
400052ec: 90 10 20 01 mov 1, %o0 ! 1 <_TLS_Alignment>
400052f0: b0 10 00 08 mov %o0, %i0
400052f4: 7f ff ff 98 call 40005154 <rtems_libio_free_user_env.part.1>
400052f8: 90 10 00 1d mov %i5, %o0
_Thread_Set_life_protection(THREAD_LIFE_PROTECTED);
rtems_libio_free_user_env(env);
pthread_setspecific(rtems_current_user_env_key, NULL);
400052fc: d0 07 21 10 ld [ %i4 + 0x110 ], %o0
40005300: 40 00 04 75 call 400064d4 <pthread_setspecific>
40005304: 92 10 20 00 clr %o1
_Thread_Set_life_protection(life_state);
40005308: 40 00 16 aa call 4000adb0 <_Thread_Set_life_protection>
<== NOT EXECUTED
4000530c: 81 e8 00 00 restore
}
}
40005310: 81 c7 e0 08 ret
<== NOT EXECUTED
40005314: 81 e8 00 00 restore
<== NOT EXECUTED
4000a79c <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
4000a79c: 9d e3 bf 40 save %sp, -192, %sp
int success = 0;
char *dup_path = strdup(path);
4000a7a0: 40 00 5f d2 call 400226e8 <strdup>
4000a7a4: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
4000a7a8: b8 92 20 00 orcc %o0, 0, %i4
4000a7ac: 02 80 00 6e be 4000a964 <rtems_mkdir+0x1c8>
<== NEVER TAKEN
4000a7b0: 01 00 00 00 nop
if (p[0] == '/') /* Skip leading '/'. */
4000a7b4: c2 0f 00 00 ldub [ %i4 ], %g1
4000a7b8: 83 28 60 18 sll %g1, 0x18, %g1
4000a7bc: 85 38 60 18 sra %g1, 0x18, %g2
4000a7c0: 80 a0 a0 2f cmp %g2, 0x2f
4000a7c4: 12 80 00 05 bne 4000a7d8 <rtems_mkdir+0x3c>
<== NEVER TAKEN
4000a7c8: ba 10 00 1c mov %i4, %i5
4000a7cc: c2 0f 20 01 ldub [ %i4 + 1 ], %g1
++p;
4000a7d0: ba 07 20 01 add %i4, 1, %i5
4000a7d4: 83 28 60 18 sll %g1, 0x18, %g1
if (p[0] == '\0')
4000a7d8: 83 38 60 18 sra %g1, 0x18, %g1
4000a7dc: ba 07 60 01 inc %i5
*p = '/';
4000a7e0: b6 10 20 00 clr %i3
4000a7e4: 84 10 20 01 mov 1, %g2
4000a7e8: b0 10 20 2f mov 0x2f, %i0
} else if (!S_ISDIR(sb.st_mode)) {
4000a7ec: 23 00 00 3c sethi %hi(0xf000), %l1
if (p[0] == '\0')
4000a7f0: 80 a0 60 00 cmp %g1, 0
4000a7f4: 02 80 00 18 be 4000a854 <rtems_mkdir+0xb8>
<== NEVER TAKEN
4000a7f8: 21 00 00 10 sethi %hi(0x4000), %l0
else if (p[0] != '/')
4000a7fc: 80 a0 60 2f cmp %g1, 0x2f
4000a800: 12 80 00 0f bne 4000a83c <rtems_mkdir+0xa0>
<== ALWAYS TAKEN
4000a804: 80 a0 a0 00 cmp %g2, 0
*p = '\0';
4000a808: c0 2f 7f ff clrb [ %i5 + -1 ]
<== NOT EXECUTED
if (first) {
4000a80c: 12 80 00 5c bne 4000a97c <rtems_mkdir+0x1e0>
<== NOT EXECUTED
4000a810: f4 0f 40 00 ldub [ %i5 ], %i2
<== NOT EXECUTED
if (last)
4000a814: 80 8e a0 ff btst 0xff, %i2
<== NOT EXECUTED
4000a818: 02 80 00 17 be 4000a874 <rtems_mkdir+0xd8>
<== NOT EXECUTED
4000a81c: 92 10 21 ff mov 0x1ff, %o1
<== NOT EXECUTED
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4000a820: 7f ff fd 10 call 40009c60 <mkdir>
<== NOT EXECUTED
4000a824: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000a828: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000a82c: 06 80 00 1f bl 4000a8a8 <rtems_mkdir+0x10c>
<== NOT EXECUTED
4000a830: b4 10 20 00 clr %i2
<== NOT EXECUTED
*p = '/';
4000a834: f0 2f 7f ff stb %i0, [ %i5 + -1 ]
<== NOT EXECUTED
4000a838: 84 10 20 00 clr %g2
<== NOT EXECUTED
4000a83c: c2 0f 40 00 ldub [ %i5 ], %g1
4000a840: 83 28 60 18 sll %g1, 0x18, %g1
if (p[0] == '\0')
4000a844: 83 38 60 18 sra %g1, 0x18, %g1
4000a848: 80 a0 60 00 cmp %g1, 0
4000a84c: 12 bf ff ec bne 4000a7fc <rtems_mkdir+0x60>
4000a850: ba 07 60 01 inc %i5
if (first) {
4000a854: 80 a0 a0 00 cmp %g2, 0
4000a858: 02 80 00 07 be 4000a874 <rtems_mkdir+0xd8>
<== NEVER TAKEN
4000a85c: 01 00 00 00 nop
oumask = umask(0);
4000a860: 40 00 04 40 call 4000b960 <umask>
4000a864: 90 10 20 00 clr %o0 ! 0 <PROM_START>
4000a868: b6 10 00 08 mov %o0, %i3
(void)umask(numask);
4000a86c: 40 00 04 3d call 4000b960 <umask>
4000a870: 90 0a 3f 3f and %o0, -193, %o0
(void)umask(oumask);
4000a874: 40 00 04 3b call 4000b960 <umask>
4000a878: 90 10 00 1b mov %i3, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4000a87c: 92 10 00 19 mov %i1, %o1
4000a880: 7f ff fc f8 call 40009c60 <mkdir>
4000a884: 90 10 00 1c mov %i4, %o0
4000a888: 80 a2 20 00 cmp %o0, 0
4000a88c: 06 80 00 07 bl 4000a8a8 <rtems_mkdir+0x10c>
4000a890: b4 10 20 01 mov 1, %i2
(void)umask(oumask);
4000a894: b0 10 20 00 clr %i0
success = build(dup_path, mode);
free(dup_path);
4000a898: 7f ff fa df call 40009414 <free>
4000a89c: 90 10 00 1c mov %i4, %o0
4000a8a0: 81 c7 e0 08 ret
4000a8a4: 81 e8 00 00 restore
if (errno == EEXIST || errno == EISDIR) {
4000a8a8: 40 00 58 f0 call 40020c68 <__errno>
4000a8ac: 01 00 00 00 nop
4000a8b0: c2 02 00 00 ld [ %o0 ], %g1
4000a8b4: 80 a0 60 11 cmp %g1, 0x11
4000a8b8: 02 80 00 08 be 4000a8d8 <rtems_mkdir+0x13c>
<== ALWAYS TAKEN
4000a8bc: 92 07 bf a0 add %fp, -96, %o1
4000a8c0: 40 00 58 ea call 40020c68 <__errno>
<== NOT EXECUTED
4000a8c4: 01 00 00 00 nop
<== NOT EXECUTED
4000a8c8: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
4000a8cc: 80 a0 60 15 cmp %g1, 0x15
<== NOT EXECUTED
4000a8d0: 12 80 00 0f bne 4000a90c <rtems_mkdir+0x170>
<== NOT EXECUTED
4000a8d4: 92 07 bf a0 add %fp, -96, %o1
<== NOT EXECUTED
if (stat(path, &sb) < 0) {
4000a8d8: 40 00 00 3c call 4000a9c8 <stat>
4000a8dc: 90 10 00 1c mov %i4, %o0
4000a8e0: 80 a2 20 00 cmp %o0, 0
4000a8e4: 06 80 00 0a bl 4000a90c <rtems_mkdir+0x170>
<== NEVER TAKEN
4000a8e8: c2 07 bf ac ld [ %fp + -84 ], %g1
} else if (!S_ISDIR(sb.st_mode)) {
4000a8ec: 82 08 40 11 and %g1, %l1, %g1
4000a8f0: 80 a0 40 10 cmp %g1, %l0
4000a8f4: 12 80 00 10 bne 4000a934 <rtems_mkdir+0x198>
<== NEVER TAKEN
4000a8f8: 80 a6 a0 00 cmp %i2, 0
if (last)
4000a8fc: 32 bf ff e7 bne,a 4000a898 <rtems_mkdir+0xfc>
<== ALWAYS TAKEN
4000a900: b0 10 20 00 clr %i0
*p = '/';
4000a904: 10 bf ff cd b 4000a838 <rtems_mkdir+0x9c>
<== NOT EXECUTED
4000a908: f0 2f 7f ff stb %i0, [ %i5 + -1 ]
<== NOT EXECUTED
if (!first && !last)
4000a90c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000a910: 32 80 00 17 bne,a 4000a96c <rtems_mkdir+0x1d0>
<== NOT EXECUTED
4000a914: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
(void)umask(oumask);
4000a918: 40 00 04 12 call 4000b960 <umask>
<== NOT EXECUTED
4000a91c: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4000a920: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
free(dup_path);
4000a924: 7f ff fa bc call 40009414 <free>
<== NOT EXECUTED
4000a928: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000a92c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a930: 81 e8 00 00 restore
<== NOT EXECUTED
if (last)
4000a934: 02 80 00 07 be 4000a950 <rtems_mkdir+0x1b4>
<== NOT EXECUTED
4000a938: 01 00 00 00 nop
<== NOT EXECUTED
errno = EEXIST;
4000a93c: 40 00 58 cb call 40020c68 <__errno>
<== NOT EXECUTED
4000a940: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
4000a944: 82 10 20 11 mov 0x11, %g1
<== NOT EXECUTED
4000a948: 10 bf ff d4 b 4000a898 <rtems_mkdir+0xfc>
<== NOT EXECUTED
4000a94c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
errno = ENOTDIR;
4000a950: 40 00 58 c6 call 40020c68 <__errno>
<== NOT EXECUTED
4000a954: 01 00 00 00 nop
<== NOT EXECUTED
4000a958: 82 10 20 14 mov 0x14, %g1 ! 14 <_TLS_Alignment+0x13>
<== NOT EXECUTED
4000a95c: 10 bf ff ef b 4000a918 <rtems_mkdir+0x17c>
<== NOT EXECUTED
4000a960: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
return success != 0 ? 0 : -1;
4000a964: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a968: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
free(dup_path);
4000a96c: 7f ff fa aa call 40009414 <free>
<== NOT EXECUTED
4000a970: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
}
4000a974: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a978: 81 e8 00 00 restore
<== NOT EXECUTED
oumask = umask(0);
4000a97c: 40 00 03 f9 call 4000b960 <umask>
<== NOT EXECUTED
4000a980: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000a984: b6 10 00 08 mov %o0, %i3
<== NOT EXECUTED
(void)umask(numask);
4000a988: 40 00 03 f6 call 4000b960 <umask>
<== NOT EXECUTED
4000a98c: 90 0a 3f 3f and %o0, -193, %o0
<== NOT EXECUTED
if (last)
4000a990: 10 bf ff a2 b 4000a818 <rtems_mkdir+0x7c>
<== NOT EXECUTED
4000a994: 80 8e a0 ff btst 0xff, %i2
<== NOT EXECUTED
40010b54 <rtems_printf>:
int rtems_printf(
const rtems_printer *printer,
const char *format,
...
)
{
40010b54: 9d e3 bf 98 save %sp, -104, %sp
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
va_list ap;
va_start( ap, format );
40010b58: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
{
40010b5c: 82 10 00 18 mov %i0, %g1
va_start( ap, format );
40010b60: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int len = 0;
40010b64: b0 10 20 00 clr %i0
va_start( ap, format );
40010b68: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40010b6c: 80 a0 60 00 cmp %g1, 0
40010b70: 02 80 00 0b be 40010b9c <rtems_printf+0x48>
40010b74: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
40010b78: c4 00 60 04 ld [ %g1 + 4 ], %g2
40010b7c: 80 a0 a0 00 cmp %g2, 0
40010b80: 02 80 00 07 be 40010b9c <rtems_printf+0x48>
<== NEVER TAKEN
40010b84: 94 07 a0 4c add %fp, 0x4c, %o2
len = printer->printer( printer->context, format, ap );
40010b88: d0 00 40 00 ld [ %g1 ], %o0
40010b8c: 92 10 00 19 mov %i1, %o1
40010b90: 9f c0 80 00 call %g2
40010b94: d4 27 bf fc st %o2, [ %fp + -4 ]
40010b98: b0 10 00 08 mov %o0, %i0
va_end( ap );
}
return len;
}
40010b9c: 81 c7 e0 08 ret
40010ba0: 81 e8 00 00 restore
40014050 <rtems_termios_baud_table>:
40014050: 40 01 3f 88 00 00 00 00 00 00 00 00 40 01 3f 90 @.?.........@.?.
40014060: 00 00 00 32 00 00 00 32 40 01 3f 98 00 00 00 4b ...2...2@.?....K
40014070: 00 00 00 4b 40 01 3f a0 00 00 00 6e 00 00 00 6e ...K@.?....n...n
40014080: 40 01 3f a8 00 00 00 86 00 00 00 86 40 01 3f b0 @.?.........@.?.
40014090: 00 00 00 96 00 00 00 96 40 01 3f b8 00 00 00 c8 ........@.?.....
400140a0: 00 00 00 c8 40 01 3f c0 00 00 01 2c 00 00 01 2c ....@.?....,...,
400140b0: 40 01 3f c8 00 00 02 58 00 00 02 58 40 01 3f d0 @.?....X...X@.?.
400140c0: 00 00 04 b0 00 00 04 b0 40 01 3f d8 00 00 07 08 ........@.?.....
400140d0: 00 00 07 08 40 01 3f e0 00 00 09 60 00 00 09 60 ....@.?....`...`
400140e0: 40 01 3f e8 00 00 12 c0 00 00 12 c0 40 01 3f f0 @.?.........@.?.
400140f0: 00 00 25 80 00 00 25 80 40 01 3f f8 00 00 4b 00 ..%...%.@.?...K.
40014100: 00 00 4b 00 40 01 40 00 00 00 96 00 00 00 96 00 ..K.@.@.........
40014110: 40 01 40 08 00 00 1c 20 00 00 1c 20 40 01 40 10 @.@.... ... @.@.
40014120: 00 00 38 40 00 00 38 40 40 01 40 18 00 00 70 80 ..8@..8@@.@...p.
40014130: 00 00 70 80 40 01 40 20 00 00 e1 00 00 00 e1 00 ..p.@.@ ........
40014140: 40 01 40 28 00 01 2c 00 00 01 2c 00 40 01 40 30 @.@(..,...,.@.@0
40014150: 00 01 c2 00 00 01 c2 00 40 01 40 38 00 03 84 00 ........@.@8....
40014160: 00 03 84 00 40 01 40 40 00 07 08 00 00 07 08 00 ....@.@@........
40014170: 40 01 40 48 00 0e 10 00 00 0e 10 00 00 00 00 00 @.@H............
...
40014188: 74 65 72 6d 69 6f 73 20 69 6e 70 75 74 00 00 00 termios input...
40014198: 74 65 72 6d 69 6f 73 20 6f 75 74 70 75 74 00 00 termios output..
400141a8: 74 65 72 6d 69 6f 73 20 72 61 77 20 6f 75 74 70 termios raw outp
400141b8: 75 74 00 00 00 00 00 00 74 65 72 6d 69 6f 73 20 ut......termios
400141c8: 64 65 76 69 63 65 00 00 74 65 72 6d 69 6f 73 20 device..termios
400141d8: 72 61 77 20 69 6e 70 75 74 00 00 00 00 00 00 00 raw input.......
400141e8: 08 00 00 00 00 00 00 00 08 20 08 00 ......... ..
40007fbc <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
40007fbc: 05 00 00 04 sethi %hi(0x1000), %g2
40007fc0: 84 10 a2 c0 or %g2, 0x2c0, %g2 ! 12c0 <_Configuration_Interrupt_stack_size+0x2c0>
40007fc4: 80 a2 00 02 cmp %o0, %g2
40007fc8: 02 80 00 7d be 400081bc <rtems_termios_baud_to_index+0x200>
40007fcc: 82 10 00 08 mov %o0, %g1
40007fd0: 18 80 00 14 bgu 40008020 <rtems_termios_baud_to_index+0x64>
40007fd4: 80 a2 20 96 cmp %o0, 0x96
40007fd8: 02 80 00 7b be 400081c4 <rtems_termios_baud_to_index+0x208>
40007fdc: 01 00 00 00 nop
40007fe0: 08 80 00 2a bleu 40008088 <rtems_termios_baud_to_index+0xcc>
40007fe4: 80 a2 22 58 cmp %o0, 0x258
40007fe8: 02 80 00 73 be 400081b4 <rtems_termios_baud_to_index+0x1f8>
40007fec: 01 00 00 00 nop
40007ff0: 08 80 00 46 bleu 40008108 <rtems_termios_baud_to_index+0x14c>
40007ff4: 80 a0 67 08 cmp %g1, 0x708
40007ff8: 02 80 00 22 be 40008080 <rtems_termios_baud_to_index+0xc4>
40007ffc: 90 10 20 0a mov 0xa, %o0
40008000: 80 a0 69 60 cmp %g1, 0x960
40008004: 02 80 00 1f be 40008080 <rtems_termios_baud_to_index+0xc4>
40008008: 90 10 20 0b mov 0xb, %o0
4000800c: 80 a0 64 b0 cmp %g1, 0x4b0
40008010: 02 80 00 1c be 40008080 <rtems_termios_baud_to_index+0xc4>
<== ALWAYS TAKEN
40008014: 90 10 20 09 mov 9, %o0
case B921600: baud_index = 24; break;
default: baud_index = -1; break;
}
return baud_index;
}
40008018: 81 c3 e0 08 retl
4000801c: 90 10 3f ff mov -1, %o0
switch (termios_baud) {
40008020: 05 00 00 25 sethi %hi(0x9400), %g2
40008024: 84 10 a2 00 or %g2, 0x200, %g2 ! 9600 <_Configuration_Interrupt_stack_size+0x8600>
40008028: 80 a2 00 02 cmp %o0, %g2
4000802c: 02 80 00 60 be 400081ac <rtems_termios_baud_to_index+0x1f0>
40008030: 01 00 00 00 nop
40008034: 08 80 00 22 bleu 400080bc <rtems_termios_baud_to_index+0x100>
40008038: 05 00 00 70 sethi %hi(0x1c000), %g2
4000803c: 84 10 a2 00 or %g2, 0x200, %g2 ! 1c200 <_Configuration_Interrupt_stack_size+0x1b200>
40008040: 80 a2 00 02 cmp %o0, %g2
40008044: 02 80 00 62 be 400081cc <rtems_termios_baud_to_index+0x210>
40008048: 01 00 00 00 nop
4000804c: 08 80 00 37 bleu 40008128 <rtems_termios_baud_to_index+0x16c>
40008050: 05 00 01 c2 sethi %hi(0x70800), %g2
40008054: 80 a0 40 02 cmp %g1, %g2
40008058: 02 80 00 0a be 40008080 <rtems_termios_baud_to_index+0xc4>
4000805c: 90 10 20 17 mov 0x17, %o0
40008060: 05 00 03 84 sethi %hi(0xe1000), %g2
40008064: 80 a0 40 02 cmp %g1, %g2
40008068: 02 80 00 06 be 40008080 <rtems_termios_baud_to_index+0xc4>
4000806c: 90 10 20 18 mov 0x18, %o0
40008070: 05 00 00 e1 sethi %hi(0x38400), %g2
40008074: 80 a0 40 02 cmp %g1, %g2
40008078: 12 bf ff e8 bne 40008018 <rtems_termios_baud_to_index+0x5c>
4000807c: 90 10 20 16 mov 0x16, %o0
40008080: 81 c3 e0 08 retl
40008084: 01 00 00 00 nop
40008088: 80 a2 20 4b cmp %o0, 0x4b
4000808c: 02 80 00 46 be 400081a4 <rtems_termios_baud_to_index+0x1e8>
40008090: 01 00 00 00 nop
40008094: 18 80 00 3b bgu 40008180 <rtems_termios_baud_to_index+0x1c4>
40008098: 80 a0 60 6e cmp %g1, 0x6e
4000809c: 80 a0 60 00 cmp %g1, 0
400080a0: 02 bf ff f8 be 40008080 <rtems_termios_baud_to_index+0xc4>
400080a4: 90 10 20 00 clr %o0
400080a8: 80 a0 60 32 cmp %g1, 0x32
400080ac: 12 bf ff db bne 40008018 <rtems_termios_baud_to_index+0x5c>
<== NEVER TAKEN
400080b0: 90 10 20 01 mov 1, %o0
}
400080b4: 81 c3 e0 08 retl
400080b8: 01 00 00 00 nop
switch (termios_baud) {
400080bc: 05 00 00 0e sethi %hi(0x3800), %g2
400080c0: 84 10 a0 40 or %g2, 0x40, %g2 ! 3840 <_Configuration_Interrupt_stack_size+0x2840>
400080c4: 80 a2 00 02 cmp %o0, %g2
400080c8: 02 80 00 35 be 4000819c <rtems_termios_baud_to_index+0x1e0>
400080cc: 01 00 00 00 nop
400080d0: 18 80 00 21 bgu 40008154 <rtems_termios_baud_to_index+0x198>
400080d4: 05 00 00 12 sethi %hi(0x4800), %g2
400080d8: 05 00 00 07 sethi %hi(0x1c00), %g2
400080dc: 84 10 a0 20 or %g2, 0x20, %g2 ! 1c20 <_Configuration_Interrupt_stack_size+0xc20>
400080e0: 80 a0 40 02 cmp %g1, %g2
400080e4: 02 bf ff e7 be 40008080 <rtems_termios_baud_to_index+0xc4>
400080e8: 90 10 20 10 mov 0x10, %o0
400080ec: 05 00 00 09 sethi %hi(0x2400), %g2
400080f0: 84 10 a1 80 or %g2, 0x180, %g2 ! 2580 <_Configuration_Interrupt_stack_size+0x1580>
400080f4: 80 a0 40 02 cmp %g1, %g2
400080f8: 12 bf ff c8 bne 40008018 <rtems_termios_baud_to_index+0x5c>
<== NEVER TAKEN
400080fc: 90 10 20 0d mov 0xd, %o0
}
40008100: 81 c3 e0 08 retl
40008104: 01 00 00 00 nop
switch (termios_baud) {
40008108: 80 a0 60 c8 cmp %g1, 0xc8
4000810c: 02 bf ff dd be 40008080 <rtems_termios_baud_to_index+0xc4>
40008110: 90 10 20 06 mov 6, %o0
40008114: 80 a0 61 2c cmp %g1, 0x12c
40008118: 12 bf ff c0 bne 40008018 <rtems_termios_baud_to_index+0x5c>
<== NEVER TAKEN
4000811c: 90 10 20 07 mov 7, %o0
}
40008120: 81 c3 e0 08 retl
40008124: 01 00 00 00 nop
switch (termios_baud) {
40008128: 05 00 00 38 sethi %hi(0xe000), %g2
4000812c: 84 10 a1 00 or %g2, 0x100, %g2 ! e100 <_Configuration_Interrupt_stack_size+0xd100>
40008130: 80 a0 40 02 cmp %g1, %g2
40008134: 02 bf ff d3 be 40008080 <rtems_termios_baud_to_index+0xc4>
40008138: 90 10 20 13 mov 0x13, %o0
4000813c: 05 00 00 4b sethi %hi(0x12c00), %g2
40008140: 80 a0 40 02 cmp %g1, %g2
40008144: 12 bf ff b5 bne 40008018 <rtems_termios_baud_to_index+0x5c>
<== NEVER TAKEN
40008148: 90 10 20 14 mov 0x14, %o0
}
4000814c: 81 c3 e0 08 retl
40008150: 01 00 00 00 nop
switch (termios_baud) {
40008154: 84 10 a3 00 or %g2, 0x300, %g2
40008158: 80 a0 40 02 cmp %g1, %g2
4000815c: 02 bf ff c9 be 40008080 <rtems_termios_baud_to_index+0xc4>
40008160: 90 10 20 0e mov 0xe, %o0
40008164: 05 00 00 1c sethi %hi(0x7000), %g2
40008168: 84 10 a0 80 or %g2, 0x80, %g2 ! 7080 <_Configuration_Interrupt_stack_size+0x6080>
4000816c: 80 a0 40 02 cmp %g1, %g2
40008170: 12 bf ff aa bne 40008018 <rtems_termios_baud_to_index+0x5c>
<== NEVER TAKEN
40008174: 90 10 20 12 mov 0x12, %o0
}
40008178: 81 c3 e0 08 retl
4000817c: 01 00 00 00 nop
switch (termios_baud) {
40008180: 02 bf ff c0 be 40008080 <rtems_termios_baud_to_index+0xc4>
40008184: 90 10 20 03 mov 3, %o0 ! 3 <_TLS_Alignment+0x2>
40008188: 80 a0 60 86 cmp %g1, 0x86
4000818c: 12 bf ff a3 bne 40008018 <rtems_termios_baud_to_index+0x5c>
<== NEVER TAKEN
40008190: 90 10 20 04 mov 4, %o0
}
40008194: 81 c3 e0 08 retl
40008198: 01 00 00 00 nop
case B14400: baud_index = 17; break;
4000819c: 81 c3 e0 08 retl
400081a0: 90 10 20 11 mov 0x11, %o0 ! 11 <_TLS_Alignment+0x10>
case B75: baud_index = 2; break;
400081a4: 81 c3 e0 08 retl
400081a8: 90 10 20 02 mov 2, %o0
case B38400: baud_index = 15; break;
400081ac: 81 c3 e0 08 retl
400081b0: 90 10 20 0f mov 0xf, %o0
case B600: baud_index = 8; break;
400081b4: 81 c3 e0 08 retl
400081b8: 90 10 20 08 mov 8, %o0
case B4800: baud_index = 12; break;
400081bc: 81 c3 e0 08 retl
400081c0: 90 10 20 0c mov 0xc, %o0
case B150: baud_index = 5; break;
400081c4: 81 c3 e0 08 retl
400081c8: 90 10 20 05 mov 5, %o0
case B115200: baud_index = 21; break;
400081cc: 81 c3 e0 08 retl
400081d0: 90 10 20 15 mov 0x15, %o0
40008194 <rtems_termios_close>:
{
40008194: 9d e3 bf a0 save %sp, -96, %sp
struct rtems_termios_tty *tty = args->iop->data1;
40008198: c2 06 00 00 ld [ %i0 ], %g1
4000819c: fa 00 60 28 ld [ %g1 + 0x28 ], %i5
_Mutex_Acquire( mutex );
400081a0: 39 10 00 78 sethi %hi(0x4001e000), %i4
400081a4: 40 00 0e 7e call 4000bb9c <_Mutex_Acquire>
400081a8: 90 17 21 30 or %i4, 0x130, %o0 ! 4001e130 <rtems_termios_ttyMutex>
if (tty->refcount == 1) {
400081ac: c2 07 60 08 ld [ %i5 + 8 ], %g1
400081b0: 80 a0 60 01 cmp %g1, 1
400081b4: 22 80 00 1c be,a 40008224 <rtems_termios_close+0x90>
<== ALWAYS TAKEN
400081b8: c4 07 40 00 ld [ %i5 ], %g2
if (--tty->refcount == 0) {
400081bc: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
400081c0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400081c4: 02 80 00 0f be 40008200 <rtems_termios_close+0x6c>
<== NOT EXECUTED
400081c8: c2 27 60 08 st %g1, [ %i5 + 8 ]
<== NOT EXECUTED
_Mutex_Release( mutex );
400081cc: 90 17 21 30 or %i4, 0x130, %o0
<== NOT EXECUTED
400081d0: 40 00 0e 8f call 4000bc0c <_Mutex_Release>
<== NOT EXECUTED
400081d4: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
400081d8: 81 c7 e0 08 ret
<== NOT EXECUTED
400081dc: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_termios_ttyTail = tty->back;
400081e0: 05 10 00 7c sethi %hi(0x4001f000), %g2
if ( rtems_termios_ttyTail != NULL ) {
400081e4: 80 a0 60 00 cmp %g1, 0
400081e8: 02 80 00 1c be 40008258 <rtems_termios_close+0xc4>
<== ALWAYS TAKEN
400081ec: c2 20 a1 7c st %g1, [ %g2 + 0x17c ]
rtems_termios_ttyTail->forw = NULL;
400081f0: c0 20 40 00 clr [ %g1 ]
<== NOT EXECUTED
400081f4: c4 07 40 00 ld [ %i5 ], %g2
<== NOT EXECUTED
tty->back->forw = tty->forw;
400081f8: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
if (--tty->refcount == 0) {
400081fc: c0 27 60 08 clr [ %i5 + 8 ]
<== NOT EXECUTED
rtems_termios_destroy_tty (tty, arg, true);
40008200: 92 10 00 18 mov %i0, %o1
40008204: 94 10 20 01 mov 1, %o2
40008208: 7f ff f9 90 call 40006848 <rtems_termios_destroy_tty>
4000820c: 90 10 00 1d mov %i5, %o0
40008210: 90 17 21 30 or %i4, 0x130, %o0
40008214: 40 00 0e 7e call 4000bc0c <_Mutex_Release>
40008218: b0 10 20 00 clr %i0
}
4000821c: 81 c7 e0 08 ret
40008220: 81 e8 00 00 restore
if (tty->forw == NULL) {
40008224: 80 a0 a0 00 cmp %g2, 0
40008228: 02 bf ff ee be 400081e0 <rtems_termios_close+0x4c>
<== ALWAYS TAKEN
4000822c: c2 07 60 04 ld [ %i5 + 4 ], %g1
tty->forw->back = tty->back;
40008230: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
if (tty->back == NULL) {
40008234: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40008238: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000823c: 32 bf ff f0 bne,a 400081fc <rtems_termios_close+0x68>
<== NOT EXECUTED
40008240: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
rtems_termios_ttyHead->back = NULL;
40008244: c0 20 a0 04 clr [ %g2 + 4 ]
<== NOT EXECUTED
rtems_termios_ttyHead = tty->forw;
40008248: 03 10 00 7c sethi %hi(0x4001f000), %g1
<== NOT EXECUTED
if (--tty->refcount == 0) {
4000824c: c0 27 60 08 clr [ %i5 + 8 ]
<== NOT EXECUTED
rtems_termios_ttyHead = tty->forw;
40008250: 10 bf ff ec b 40008200 <rtems_termios_close+0x6c>
<== NOT EXECUTED
40008254: c4 20 61 80 st %g2, [ %g1 + 0x180 ]
<== NOT EXECUTED
40008258: 03 10 00 7c sethi %hi(0x4001f000), %g1
if (--tty->refcount == 0) {
4000825c: c0 27 60 08 clr [ %i5 + 8 ]
rtems_termios_ttyHead = tty->forw;
40008260: 10 bf ff e8 b 40008200 <rtems_termios_close+0x6c>
40008264: c0 20 61 80 clr [ %g1 + 0x180 ]
40008e30 <rtems_termios_dequeue_characters>:
{
40008e30: 9d e3 bf a0 save %sp, -96, %sp
tty->t_dqlen += len;
40008e34: c2 06 20 e0 ld [ %i0 + 0xe0 ], %g1
40008e38: b2 00 40 19 add %g1, %i1, %i1
40008e3c: f2 26 20 e0 st %i1, [ %i0 + 0xe0 ]
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
40008e40: c2 06 21 3c ld [ %i0 + 0x13c ], %g1
40008e44: 80 a0 60 02 cmp %g1, 2
40008e48: 02 80 00 10 be 40008e88 <rtems_termios_dequeue_characters+0x58>
40008e4c: 90 10 00 18 mov %i0, %o0
if (tty->t_line == PPPDISC ) {
40008e50: c2 06 21 5c ld [ %i0 + 0x15c ], %g1
40008e54: 80 a0 60 05 cmp %g1, 5
40008e58: 12 80 00 0a bne 40008e80 <rtems_termios_dequeue_characters+0x50>
40008e5c: 03 10 00 7c sethi %hi(0x4001f000), %g1
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40008e60: c2 00 62 38 ld [ %g1 + 0x238 ], %g1 ! 4001f238 <rtems_termios_linesw+0xb4>
40008e64: 80 a0 60 00 cmp %g1, 0
40008e68: 02 80 00 04 be 40008e78 <rtems_termios_dequeue_characters+0x48>
<== NEVER TAKEN
40008e6c: 01 00 00 00 nop
rtems_termios_linesw[tty->t_line].l_start(tty);
40008e70: 9f c0 40 00 call %g1
40008e74: 01 00 00 00 nop
}
40008e78: 81 c7 e0 08 ret
40008e7c: 91 e8 20 00 restore %g0, 0, %o0
return rtems_termios_refill_transmitter(tty);
40008e80: 7f ff f8 bb call 4000716c <rtems_termios_refill_transmitter>
40008e84: 81 e8 00 00 restore
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
40008e88: d0 06 21 58 ld [ %i0 + 0x158 ], %o0
40008e8c: 40 00 01 3e call 40009384 <rtems_event_send>
40008e90: 92 10 20 02 mov 2, %o1
if (sc != RTEMS_SUCCESSFUL)
40008e94: 80 a2 20 00 cmp %o0, 0
40008e98: 02 bf ff f8 be 40008e78 <rtems_termios_dequeue_characters+0x48>
<== ALWAYS TAKEN
40008e9c: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
40008ea0: 40 00 03 ab call 40009d4c <rtems_fatal_error_occurred>
<== NOT EXECUTED
40008ea4: 01 00 00 00 nop
<== NOT EXECUTED
40008ea8: 01 00 00 00 nop
<== NOT EXECUTED
40010184 <rtems_termios_device_lock_acquire_default>:
40010184: 91 d0 20 09 ta 9
<== NOT EXECUTED
rtems_termios_device_lock_acquire_default(
rtems_termios_device_context *ctx,
rtems_interrupt_lock_context *lock_context
)
{
rtems_interrupt_lock_acquire (&ctx->lock.interrupt, lock_context);
40010188: c2 22 40 00 st %g1, [ %o1 ]
}
4001018c: 81 c3 e0 08 retl
40010190: 01 00 00 00 nop
40010194 <rtems_termios_device_lock_release_default>:
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40010194: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010198: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001019c: 01 00 00 00 nop
rtems_termios_device_context *ctx,
rtems_interrupt_lock_context *lock_context
)
{
rtems_interrupt_lock_release (&ctx->lock.interrupt, lock_context);
}
400101a0: 81 c3 e0 08 retl
400101a4: 01 00 00 00 nop
400123d4 <rtems_termios_enqueue_raw_characters>:
{
400123d4: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
400123d8: c2 06 21 5c ld [ %i0 + 0x15c ], %g1
400123dc: 83 28 60 05 sll %g1, 5, %g1
400123e0: 39 10 00 5b sethi %hi(0x40016c00), %i4
400123e4: b8 17 21 c4 or %i4, 0x1c4, %i4 ! 40016dc4 <rtems_termios_linesw>
400123e8: 82 07 00 01 add %i4, %g1, %g1
400123ec: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
400123f0: 80 a0 60 00 cmp %g1, 0
400123f4: 02 80 00 25 be 40012488 <rtems_termios_enqueue_raw_characters+0xb4>
400123f8: ba 10 00 18 mov %i0, %i5
while (len--) {
400123fc: 80 a6 a0 00 cmp %i2, 0
40012400: 22 80 00 0f be,a 4001243c <rtems_termios_enqueue_raw_characters+0x68>
<== NEVER TAKEN
40012404: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
<== NOT EXECUTED
40012408: 10 80 00 05 b 4001241c <rtems_termios_enqueue_raw_characters+0x48>
4001240c: b4 06 40 1a add %i1, %i2, %i2
40012410: 83 28 60 05 sll %g1, 5, %g1
40012414: 82 07 00 01 add %i4, %g1, %g1
40012418: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
c = *buf++;
4001241c: b2 06 60 01 inc %i1
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
40012420: d0 4e 7f ff ldsb [ %i1 + -1 ], %o0
40012424: 9f c0 40 00 call %g1
40012428: 92 10 00 1d mov %i5, %o1
while (len--) {
4001242c: 80 a6 40 1a cmp %i1, %i2
40012430: 32 bf ff f8 bne,a 40012410 <rtems_termios_enqueue_raw_characters+0x3c>
40012434: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
40012438: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
4001243c: 80 a0 60 00 cmp %g1, 0
40012440: 02 80 00 0a be 40012468 <rtems_termios_enqueue_raw_characters+0x94>
40012444: b0 10 20 00 clr %i0
40012448: c4 0f 61 74 ldub [ %i5 + 0x174 ], %g2
4001244c: 80 a0 a0 00 cmp %g2, 0
40012450: 12 80 00 06 bne 40012468 <rtems_termios_enqueue_raw_characters+0x94>
<== NEVER TAKEN
40012454: 84 10 20 01 mov 1, %g2
tty->tty_rcvwakeup = true;
40012458: c4 2f 61 74 stb %g2, [ %i5 + 0x174 ]
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
4001245c: 90 07 60 50 add %i5, 0x50, %o0
40012460: 9f c0 40 00 call %g1
40012464: d2 07 61 70 ld [ %i5 + 0x170 ], %o1
40012468: 81 c7 e0 08 ret
4001246c: 81 e8 00 00 restore
tty->rawInBufDropped += dropped;
40012470: 82 00 40 18 add %g1, %i0, %g1
40012474: c2 27 60 b4 st %g1, [ %i5 + 0xb4 ]
_Semaphore_Post_binary( &binary_semaphore->Semaphore );
40012478: 40 00 02 98 call 40012ed8 <_Semaphore_Post_binary>
4001247c: 90 07 60 90 add %i5, 0x90, %o0
}
40012480: 81 c7 e0 08 ret
40012484: 81 e8 00 00 restore
rtems_termios_device_context *ctx = tty->device_context;
40012488: f8 06 21 7c ld [ %i0 + 0x17c ], %i4
4001248c: b4 06 40 1a add %i1, %i2, %i2
bool flow_rcv = false; /* true, if flow control char received */
40012490: a6 10 20 00 clr %l3
int dropped = 0;
40012494: b0 10 20 00 clr %i0
40012498: a2 10 20 01 mov 1, %l1
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
4001249c: a0 07 60 50 add %i5, 0x50, %l0
(void *)&(tty->termios.c_cc[VSTOP]), 1);
400124a0: a4 07 60 6d add %i5, 0x6d, %l2
while (len--) {
400124a4: 80 a6 40 1a cmp %i1, %i2
400124a8: 22 bf ff f2 be,a 40012470 <rtems_termios_enqueue_raw_characters+0x9c>
400124ac: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
if (tty->flow_ctrl & FL_MDXON) {
400124b0: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
c = *buf++;
400124b4: b2 06 60 01 inc %i1
if (tty->flow_ctrl & FL_MDXON) {
400124b8: 80 88 62 00 btst 0x200, %g1
400124bc: 02 80 00 0b be 400124e8 <rtems_termios_enqueue_raw_characters+0x114>
400124c0: d0 0e 7f ff ldub [ %i1 + -1 ], %o0
if (c == tty->termios.c_cc[VSTOP]) {
400124c4: c4 0f 60 6d ldub [ %i5 + 0x6d ], %g2
400124c8: 83 2a 20 18 sll %o0, 0x18, %g1
400124cc: 83 38 60 18 sra %g1, 0x18, %g1
400124d0: 80 a0 40 02 cmp %g1, %g2
400124d4: 02 80 00 60 be 40012654 <rtems_termios_enqueue_raw_characters+0x280>
400124d8: c6 0f 60 6c ldub [ %i5 + 0x6c ], %g3
else if (c == tty->termios.c_cc[VSTART]) {
400124dc: 80 a0 40 03 cmp %g1, %g3
400124e0: 02 80 00 a6 be 40012778 <rtems_termios_enqueue_raw_characters+0x3a4>
<== NEVER TAKEN
400124e4: 01 00 00 00 nop
if (flow_rcv) {
400124e8: 80 8c e0 ff btst 0xff, %l3
400124ec: 32 80 00 61 bne,a 40012670 <rtems_termios_enqueue_raw_characters+0x29c>
<== NEVER TAKEN
400124f0: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
if (c == '\r' && (tty->termios.c_iflag & IGNCR) != 0) {
400124f4: 82 0a 20 ff and %o0, 0xff, %g1
400124f8: 80 a0 60 0d cmp %g1, 0xd
400124fc: 12 80 00 06 bne 40012514 <rtems_termios_enqueue_raw_characters+0x140>
40012500: 01 00 00 00 nop
40012504: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
40012508: 80 88 60 80 btst 0x80, %g1
4001250c: 12 bf ff e7 bne 400124a8 <rtems_termios_enqueue_raw_characters+0xd4>
40012510: 80 a6 40 1a cmp %i1, %i2
c = iprocEarly (c, tty);
40012514: 7f ff fb 4d call 40011248 <iprocEarly>
40012518: 92 10 00 1d mov %i5, %o1
( *context->lock_acquire )( context, lock_context );
4001251c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40012520: a8 10 00 08 mov %o0, %l4
40012524: 92 07 bf fc add %fp, -4, %o1
40012528: 9f c0 40 00 call %g1
4001252c: 90 10 00 1c mov %i4, %o0
head = tty->rawInBuf.Head;
40012530: ea 07 60 84 ld [ %i5 + 0x84 ], %l5
oldTail = tty->rawInBuf.Tail;
40012534: f6 07 60 88 ld [ %i5 + 0x88 ], %i3
newTail = (oldTail + 1) % tty->rawInBuf.Size;
40012538: c4 07 60 8c ld [ %i5 + 0x8c ], %g2
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
4001253c: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
newTail = (oldTail + 1) % tty->rawInBuf.Size;
40012540: b6 06 e0 01 inc %i3
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
40012544: 80 88 60 01 btst 1, %g1
newTail = (oldTail + 1) % tty->rawInBuf.Size;
40012548: 81 80 20 00 wr %g0, %y
4001254c: 01 00 00 00 nop
40012550: 01 00 00 00 nop
40012554: 01 00 00 00 nop
40012558: 82 76 c0 02 udiv %i3, %g2, %g1
4001255c: 82 58 40 02 smul %g1, %g2, %g1
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
40012560: 02 80 00 0f be 4001259c <rtems_termios_enqueue_raw_characters+0x1c8>
<== ALWAYS TAKEN
40012564: b6 26 c0 01 sub %i3, %g1, %i3
tty->rawInBuf.Size) > tty->highwater)) {
40012568: c6 07 60 8c ld [ %i5 + 0x8c ], %g3
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
4001256c: c8 07 61 50 ld [ %i5 + 0x150 ], %g4
<== NOT EXECUTED
40012570: 82 26 c0 15 sub %i3, %l5, %g1
<== NOT EXECUTED
40012574: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40012578: 01 00 00 00 nop
<== NOT EXECUTED
4001257c: 01 00 00 00 nop
<== NOT EXECUTED
40012580: 01 00 00 00 nop
<== NOT EXECUTED
40012584: 84 70 40 03 udiv %g1, %g3, %g2
<== NOT EXECUTED
40012588: 84 58 80 03 smul %g2, %g3, %g2
<== NOT EXECUTED
4001258c: 82 20 40 02 sub %g1, %g2, %g1
<== NOT EXECUTED
40012590: 80 a0 40 04 cmp %g1, %g4
<== NOT EXECUTED
40012594: 18 80 00 57 bgu 400126f0 <rtems_termios_enqueue_raw_characters+0x31c>
<== NOT EXECUTED
40012598: 01 00 00 00 nop
<== NOT EXECUTED
if (newTail != head) {
4001259c: 80 a5 40 1b cmp %l5, %i3
400125a0: 22 80 00 20 be,a 40012620 <rtems_termios_enqueue_raw_characters+0x24c>
400125a4: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
tty->rawInBuf.theBuf[newTail] = c;
400125a8: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
400125ac: e8 28 40 1b stb %l4, [ %g1 + %i3 ]
tty->rawInBuf.Tail = newTail;
400125b0: f6 27 60 88 st %i3, [ %i5 + 0x88 ]
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
400125b4: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
400125b8: 80 a0 60 00 cmp %g1, 0
400125bc: 22 80 00 74 be,a 4001278c <rtems_termios_enqueue_raw_characters+0x3b8>
400125c0: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
400125c4: c2 0f 61 74 ldub [ %i5 + 0x174 ], %g1
400125c8: 80 a0 60 00 cmp %g1, 0
400125cc: 12 80 00 1d bne 40012640 <rtems_termios_enqueue_raw_characters+0x26c>
400125d0: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
if ((tty->termios.c_lflag & ICANON) != 0) {
400125d4: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
400125d8: 80 88 61 00 btst 0x100, %g1
400125dc: 02 80 00 71 be 400127a0 <rtems_termios_enqueue_raw_characters+0x3cc>
400125e0: 80 a5 20 0a cmp %l4, 0xa
c == tty->termios.c_cc[VEOL] || c == tty->termios.c_cc[VEOL2];
400125e4: 22 80 00 5c be,a 40012754 <rtems_termios_enqueue_raw_characters+0x380>
400125e8: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
return c == '\n' || c == tty->termios.c_cc[VEOF] ||
400125ec: c2 0f 60 60 ldub [ %i5 + 0x60 ], %g1
400125f0: 80 a5 00 01 cmp %l4, %g1
400125f4: 22 80 00 58 be,a 40012754 <rtems_termios_enqueue_raw_characters+0x380>
400125f8: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
400125fc: c2 0f 60 61 ldub [ %i5 + 0x61 ], %g1
40012600: 80 a5 00 01 cmp %l4, %g1
40012604: 22 80 00 54 be,a 40012754 <rtems_termios_enqueue_raw_characters+0x380>
40012608: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
c == tty->termios.c_cc[VEOL] || c == tty->termios.c_cc[VEOL2];
4001260c: c2 0f 60 62 ldub [ %i5 + 0x62 ], %g1
40012610: a8 18 40 14 xor %g1, %l4, %l4
40012614: 80 a0 00 14 cmp %g0, %l4
40012618: 10 80 00 6e b 400127d0 <rtems_termios_enqueue_raw_characters+0x3fc>
4001261c: 82 60 3f ff subx %g0, -1, %g1
++dropped;
40012620: b0 06 20 01 inc %i0
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
40012624: 80 a0 60 00 cmp %g1, 0
40012628: 02 80 00 06 be 40012640 <rtems_termios_enqueue_raw_characters+0x26c>
<== NEVER TAKEN
4001262c: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
40012630: c2 0f 61 74 ldub [ %i5 + 0x174 ], %g1
40012634: 80 a0 60 00 cmp %g1, 0
40012638: 22 80 00 47 be,a 40012754 <rtems_termios_enqueue_raw_characters+0x380>
<== ALWAYS TAKEN
4001263c: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
( *context->lock_release )( context, lock_context );
40012640: 92 07 bf fc add %fp, -4, %o1
40012644: 9f c0 80 00 call %g2
40012648: 90 10 00 1c mov %i4, %o0
while (len--) {
4001264c: 10 bf ff 97 b 400124a8 <rtems_termios_enqueue_raw_characters+0xd4>
40012650: 80 a6 40 1a cmp %i1, %i2
if (c == tty->termios.c_cc[VSTART]) {
40012654: 80 a0 40 03 cmp %g1, %g3
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
40012658: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
if (c == tty->termios.c_cc[VSTART]) {
4001265c: 32 80 00 22 bne,a 400126e4 <rtems_termios_enqueue_raw_characters+0x310>
<== ALWAYS TAKEN
40012660: 82 10 60 10 or %g1, 0x10, %g1
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
40012664: 82 18 60 10 xor %g1, 0x10, %g1
<== NOT EXECUTED
40012668: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
4001266c: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
40012670: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
40012674: 82 08 60 30 and %g1, 0x30, %g1
40012678: 80 a0 60 20 cmp %g1, 0x20
4001267c: 12 bf ff 8a bne 400124a4 <rtems_termios_enqueue_raw_characters+0xd0>
<== ALWAYS TAKEN
40012680: 92 07 bf fc add %fp, -4, %o1
( *context->lock_acquire )( context, lock_context );
40012684: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
<== NOT EXECUTED
40012688: 9f c0 40 00 call %g1
<== NOT EXECUTED
4001268c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
40012690: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40012694: 82 08 7f df and %g1, -33, %g1
<== NOT EXECUTED
40012698: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->rawOutBufState != rob_idle) {
4001269c: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
<== NOT EXECUTED
400126a0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400126a4: 22 80 00 0a be,a 400126cc <rtems_termios_enqueue_raw_characters+0x2f8>
<== NOT EXECUTED
400126a8: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
400126ac: c4 07 60 c0 ld [ %i5 + 0xc0 ], %g2
<== NOT EXECUTED
400126b0: d2 07 60 b8 ld [ %i5 + 0xb8 ], %o1
<== NOT EXECUTED
(*tty->handler.write)(
400126b4: c2 07 61 30 ld [ %i5 + 0x130 ], %g1
<== NOT EXECUTED
400126b8: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
400126bc: 92 02 40 02 add %o1, %g2, %o1
<== NOT EXECUTED
400126c0: 9f c0 40 00 call %g1
<== NOT EXECUTED
400126c4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
( *context->lock_release )( context, lock_context );
400126c8: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
400126cc: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
400126d0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
400126d4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400126d8: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
while (len--) {
400126dc: 10 bf ff 73 b 400124a8 <rtems_termios_enqueue_raw_characters+0xd4>
<== NOT EXECUTED
400126e0: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
tty->flow_ctrl |= FL_ORCVXOF;
400126e4: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
400126e8: 10 bf ff e2 b 40012670 <rtems_termios_enqueue_raw_characters+0x29c>
400126ec: a6 10 20 01 mov 1, %l3
tty->flow_ctrl |= FL_IREQXOF;
400126f0: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
400126f4: 82 10 60 01 or %g1, 1, %g1
<== NOT EXECUTED
400126f8: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
400126fc: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40012700: 82 08 64 02 and %g1, 0x402, %g1
<== NOT EXECUTED
40012704: 80 a0 64 00 cmp %g1, 0x400
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
40012708: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
4001270c: 02 80 00 39 be 400127f0 <rtems_termios_enqueue_raw_characters+0x41c>
<== NOT EXECUTED
40012710: 80 88 60 20 btst 0x20, %g1
<== NOT EXECUTED
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
40012714: 82 08 61 04 and %g1, 0x104, %g1
<== NOT EXECUTED
40012718: 80 a0 61 00 cmp %g1, 0x100
<== NOT EXECUTED
4001271c: 12 bf ff a1 bne 400125a0 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
40012720: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
40012724: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40012728: 82 10 60 04 or %g1, 4, %g1
<== NOT EXECUTED
4001272c: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->flow.stop_remote_tx != NULL) {
40012730: c2 07 61 40 ld [ %i5 + 0x140 ], %g1
<== NOT EXECUTED
40012734: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40012738: 22 bf ff 9a be,a 400125a0 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
4001273c: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
tty->flow.stop_remote_tx(ctx);
40012740: 9f c0 40 00 call %g1
<== NOT EXECUTED
40012744: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if (newTail != head) {
40012748: 10 bf ff 96 b 400125a0 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
4001274c: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
tty->tty_rcvwakeup = true;
40012750: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
40012754: 92 07 bf fc add %fp, -4, %o1
40012758: 9f c0 80 00 call %g2
4001275c: 90 10 00 1c mov %i4, %o0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
40012760: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
40012764: d2 07 61 70 ld [ %i5 + 0x170 ], %o1
40012768: 9f c0 40 00 call %g1
4001276c: 90 10 00 10 mov %l0, %o0
while (len--) {
40012770: 10 bf ff 4e b 400124a8 <rtems_termios_enqueue_raw_characters+0xd4>
40012774: 80 a6 40 1a cmp %i1, %i2
tty->flow_ctrl &= ~FL_ORCVXOF;
40012778: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
4001277c: 82 08 7f ef and %g1, -17, %g1
<== NOT EXECUTED
40012780: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
40012784: 10 bf ff bb b 40012670 <rtems_termios_enqueue_raw_characters+0x29c>
<== NOT EXECUTED
40012788: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
4001278c: 92 07 bf fc add %fp, -4, %o1
40012790: 9f c0 40 00 call %g1
40012794: 90 10 00 1c mov %i4, %o0
while (len--) {
40012798: 10 bf ff 44 b 400124a8 <rtems_termios_enqueue_raw_characters+0xd4>
4001279c: 80 a6 40 1a cmp %i1, %i2
unsigned int rawContentSize = (newTail - head) % tty->rawInBuf.Size;
400127a0: c6 07 60 8c ld [ %i5 + 0x8c ], %g3
400127a4: b6 26 c0 15 sub %i3, %l5, %i3
return rawContentSize >= tty->termios.c_cc[VMIN];
400127a8: c8 0f 60 70 ldub [ %i5 + 0x70 ], %g4
unsigned int rawContentSize = (newTail - head) % tty->rawInBuf.Size;
400127ac: 81 80 20 00 wr %g0, %y
400127b0: 01 00 00 00 nop
400127b4: 01 00 00 00 nop
400127b8: 01 00 00 00 nop
400127bc: 82 76 c0 03 udiv %i3, %g3, %g1
400127c0: 82 58 40 03 smul %g1, %g3, %g1
400127c4: b6 26 c0 01 sub %i3, %g1, %i3
return rawContentSize >= tty->termios.c_cc[VMIN];
400127c8: 80 a6 c0 04 cmp %i3, %g4
400127cc: 82 60 3f ff subx %g0, -1, %g1
if (mustCallReceiveCallback (tty, c, newTail, head)) {
400127d0: 80 88 60 ff btst 0xff, %g1
400127d4: 12 bf ff df bne 40012750 <rtems_termios_enqueue_raw_characters+0x37c>
400127d8: 92 07 bf fc add %fp, -4, %o1
400127dc: 90 10 00 1c mov %i4, %o0
400127e0: 9f c0 80 00 call %g2
400127e4: a6 10 00 01 mov %g1, %l3
while (len--) {
400127e8: 10 bf ff 30 b 400124a8 <rtems_termios_enqueue_raw_characters+0xd4>
400127ec: 80 a6 40 1a cmp %i1, %i2
if ((tty->flow_ctrl & FL_OSTOP) ||
400127f0: 22 80 00 0c be,a 40012820 <rtems_termios_enqueue_raw_characters+0x44c>
<== NOT EXECUTED
400127f4: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
<== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
400127f8: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
400127fc: 82 10 60 02 or %g1, 2, %g1
<== NOT EXECUTED
40012800: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
(*tty->handler.write)(ctx,
40012804: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
40012808: c2 07 61 30 ld [ %i5 + 0x130 ], %g1
<== NOT EXECUTED
4001280c: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
40012810: 9f c0 40 00 call %g1
<== NOT EXECUTED
40012814: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if (newTail != head) {
40012818: 10 bf ff 62 b 400125a0 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
4001281c: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
40012820: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40012824: 32 bf ff 5f bne,a 400125a0 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
40012828: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
4001282c: 30 bf ff f3 b,a 400127f8 <rtems_termios_enqueue_raw_characters+0x424>
<== NOT EXECUTED
40011db0 <rtems_termios_ioctl>:
{
40011db0: 9d e3 bf 98 save %sp, -104, %sp
struct rtems_termios_tty *tty = args->iop->data1;
40011db4: c2 06 00 00 ld [ %i0 ], %g1
40011db8: fa 00 60 28 ld [ %g1 + 0x28 ], %i5
args->ioctl_return = 0;
40011dbc: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_mutex_lock (&tty->osem);
40011dc0: b4 07 60 28 add %i5, 0x28, %i2
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
40011dc4: f2 06 20 08 ld [ %i0 + 8 ], %i1
_Mutex_Acquire( mutex );
40011dc8: 7f ff d8 36 call 40007ea0 <_Mutex_Acquire>
40011dcc: 90 10 00 1a mov %i2, %o0
switch (args->command) {
40011dd0: f6 06 20 04 ld [ %i0 + 4 ], %i3
40011dd4: 03 20 01 1d sethi %hi(0x80047400), %g1
40011dd8: 84 10 60 10 or %g1, 0x10, %g2 ! 80047410 <RAM_END+0x3fc47410>
40011ddc: 80 a6 c0 02 cmp %i3, %g2
40011de0: 02 80 00 f0 be 400121a0 <rtems_termios_ioctl+0x3f0>
40011de4: b8 10 00 18 mov %i0, %i4
40011de8: 28 80 00 17 bleu,a 40011e44 <rtems_termios_ioctl+0x94>
40011dec: 03 10 01 19 sethi %hi(0x40046400), %g1
40011df0: 05 20 02 1d sethi %hi(0x80087400), %g2
40011df4: 86 10 a0 0c or %g2, 0xc, %g3 ! 8008740c <RAM_END+0x3fc8740c>
40011df8: 80 a6 c0 03 cmp %i3, %g3
40011dfc: 22 80 00 d4 be,a 4001214c <rtems_termios_ioctl+0x39c>
40011e00: c2 06 40 00 ld [ %i1 ], %g1
40011e04: 18 80 00 53 bgu 40011f50 <rtems_termios_ioctl+0x1a0>
40011e08: 82 10 60 1b or %g1, 0x1b, %g1
40011e0c: 80 a6 c0 01 cmp %i3, %g1
40011e10: 02 80 00 2b be 40011ebc <rtems_termios_ioctl+0x10c>
40011e14: 84 10 a0 0b or %g2, 0xb, %g2
40011e18: 80 a6 c0 02 cmp %i3, %g2
40011e1c: 12 80 00 d4 bne 4001216c <rtems_termios_ioctl+0x3bc>
<== NEVER TAKEN
40011e20: b0 10 20 00 clr %i0
tty->tty_snd = *wakeup;
40011e24: c2 06 40 00 ld [ %i1 ], %g1
40011e28: c2 27 61 64 st %g1, [ %i5 + 0x164 ]
40011e2c: c2 06 60 04 ld [ %i1 + 4 ], %g1
40011e30: c2 27 61 68 st %g1, [ %i5 + 0x168 ]
_Mutex_Release( mutex );
40011e34: 7f ff d8 37 call 40007f10 <_Mutex_Release>
40011e38: 90 10 00 1a mov %i2, %o0
}
40011e3c: 81 c7 e0 08 ret
40011e40: 81 e8 00 00 restore
switch (args->command) {
40011e44: 82 10 62 7f or %g1, 0x27f, %g1
40011e48: 80 a6 c0 01 cmp %i3, %g1
40011e4c: 02 80 00 ae be 40012104 <rtems_termios_ioctl+0x354>
<== NEVER TAKEN
40011e50: 01 00 00 00 nop
40011e54: 08 80 00 33 bleu 40011f20 <rtems_termios_ioctl+0x170>
40011e58: 03 10 01 1d sethi %hi(0x40047400), %g1
40011e5c: 82 10 60 1a or %g1, 0x1a, %g1 ! 4004741a <__end+0x2f53a>
40011e60: 80 a6 c0 01 cmp %i3, %g1
40011e64: 02 80 00 0e be 40011e9c <rtems_termios_ioctl+0xec>
40011e68: 03 10 0b 1d sethi %hi(0x402c7400), %g1
40011e6c: 82 10 60 13 or %g1, 0x13, %g1 ! 402c7413 <__end+0x2af533>
40011e70: 80 a6 c0 01 cmp %i3, %g1
40011e74: 12 80 00 be bne 4001216c <rtems_termios_ioctl+0x3bc>
<== NEVER TAKEN
40011e78: 94 10 20 2c mov 0x2c, %o2
*(struct termios *)args->buffer = tty->termios;
40011e7c: d0 06 20 08 ld [ %i0 + 8 ], %o0
40011e80: 7f ff f1 cd call 4000e5b4 <memcpy>
40011e84: 92 07 60 50 add %i5, 0x50, %o1
sc = RTEMS_SUCCESSFUL;
40011e88: b0 10 20 00 clr %i0
40011e8c: 7f ff d8 21 call 40007f10 <_Mutex_Release>
40011e90: 90 10 00 1a mov %i2, %o0
}
40011e94: 81 c7 e0 08 ret
40011e98: 81 e8 00 00 restore
*(int*)(args->buffer)=tty->t_line;
40011e9c: c2 06 20 08 ld [ %i0 + 8 ], %g1
40011ea0: c4 07 61 5c ld [ %i5 + 0x15c ], %g2
40011ea4: c4 20 40 00 st %g2, [ %g1 ]
sc = RTEMS_SUCCESSFUL;
40011ea8: b0 10 20 00 clr %i0
40011eac: 7f ff d8 19 call 40007f10 <_Mutex_Release>
40011eb0: 90 10 00 1a mov %i2, %o0
}
40011eb4: 81 c7 e0 08 ret
40011eb8: 81 e8 00 00 restore
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
40011ebc: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
40011ec0: 83 28 60 05 sll %g1, 5, %g1
40011ec4: 37 10 00 5b sethi %hi(0x40016c00), %i3
40011ec8: b6 16 e1 c4 or %i3, 0x1c4, %i3 ! 40016dc4 <rtems_termios_linesw>
40011ecc: 82 06 c0 01 add %i3, %g1, %g1
40011ed0: c2 00 60 04 ld [ %g1 + 4 ], %g1
40011ed4: 80 a0 60 00 cmp %g1, 0
40011ed8: 02 80 00 05 be 40011eec <rtems_termios_ioctl+0x13c>
40011edc: b0 10 20 00 clr %i0
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
40011ee0: 9f c0 40 00 call %g1
40011ee4: 90 10 00 1d mov %i5, %o0
40011ee8: b0 10 00 08 mov %o0, %i0
tty->t_line=*(int*)(args->buffer);
40011eec: c2 07 20 08 ld [ %i4 + 8 ], %g1
40011ef0: c2 00 40 00 ld [ %g1 ], %g1
40011ef4: c2 27 61 5c st %g1, [ %i5 + 0x15c ]
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
40011ef8: 83 28 60 05 sll %g1, 5, %g1
tty->t_sc = NULL; /* ensure that no more valid data */
40011efc: c0 27 61 60 clr [ %i5 + 0x160 ]
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
40011f00: c2 06 c0 01 ld [ %i3 + %g1 ], %g1
40011f04: 80 a0 60 00 cmp %g1, 0
40011f08: 02 bf ff cb be 40011e34 <rtems_termios_ioctl+0x84>
40011f0c: 01 00 00 00 nop
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
40011f10: 9f c0 40 00 call %g1
40011f14: 90 10 00 1d mov %i5, %o0
40011f18: 10 bf ff c7 b 40011e34 <rtems_termios_ioctl+0x84>
40011f1c: b0 10 00 08 mov %o0, %i0
switch (args->command) {
40011f20: 03 08 00 1d sethi %hi(0x20007400), %g1
40011f24: 82 10 60 5e or %g1, 0x5e, %g1 ! 2000745e <RAM_SIZE+0x1fc0745e>
40011f28: 80 a6 c0 01 cmp %i3, %g1
40011f2c: 32 80 00 91 bne,a 40012170 <rtems_termios_ioctl+0x3c0>
40011f30: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
drainOutput (tty);
40011f34: 7f ff f8 b0 call 400101f4 <drainOutput>
40011f38: 90 10 00 1d mov %i5, %o0
sc = RTEMS_SUCCESSFUL;
40011f3c: b0 10 20 00 clr %i0
40011f40: 7f ff d7 f4 call 40007f10 <_Mutex_Release>
40011f44: 90 10 00 1a mov %i2, %o0
}
40011f48: 81 c7 e0 08 ret
40011f4c: 81 e8 00 00 restore
switch (args->command) {
40011f50: 33 1f f4 e2 sethi %hi(0x7fd38800), %i1
40011f54: 82 16 63 ec or %i1, 0x3ec, %g1 ! 7fd38bec <RAM_END+0x3f938bec>
40011f58: 82 06 c0 01 add %i3, %g1, %g1
40011f5c: 80 a0 60 02 cmp %g1, 2
40011f60: 18 80 00 83 bgu 4001216c <rtems_termios_ioctl+0x3bc>
<== NEVER TAKEN
40011f64: 94 10 20 2c mov 0x2c, %o2
tty->termios = *(struct termios *)args->buffer;
40011f68: d2 06 20 08 ld [ %i0 + 8 ], %o1
40011f6c: b0 07 60 50 add %i5, 0x50, %i0
40011f70: 7f ff f1 91 call 4000e5b4 <memcpy>
40011f74: 90 10 00 18 mov %i0, %o0
if (args->command == TIOCSETAW || args->command == TIOCSETAF) {
40011f78: b2 16 63 eb or %i1, 0x3eb, %i1
40011f7c: b6 06 c0 19 add %i3, %i1, %i3
40011f80: 80 a6 e0 01 cmp %i3, 1
40011f84: 08 80 00 df bleu 40012300 <rtems_termios_ioctl+0x550>
40011f88: 01 00 00 00 nop
if (( tty->flow_ctrl & FL_MDXON) &&
40011f8c: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
40011f90: 80 88 62 00 btst 0x200, %g1
40011f94: 02 80 00 23 be 40012020 <rtems_termios_ioctl+0x270>
40011f98: f8 07 61 7c ld [ %i5 + 0x17c ], %i4
!(tty->termios.c_iflag & IXON)) {
40011f9c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (( tty->flow_ctrl & FL_MDXON) &&
40011fa0: 80 88 62 00 btst 0x200, %g1
40011fa4: 12 80 00 1f bne 40012020 <rtems_termios_ioctl+0x270>
40011fa8: 01 00 00 00 nop
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
40011fac: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
40011fb0: 82 08 7d ef and %g1, -529, %g1
40011fb4: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
if (tty->flow_ctrl & FL_OSTOP) {
40011fb8: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
40011fbc: 80 88 60 20 btst 0x20, %g1
40011fc0: 02 80 00 18 be 40012020 <rtems_termios_ioctl+0x270>
<== ALWAYS TAKEN
40011fc4: 01 00 00 00 nop
( *context->lock_acquire )( context, lock_context );
40011fc8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
<== NOT EXECUTED
40011fcc: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40011fd0: 9f c0 40 00 call %g1
<== NOT EXECUTED
40011fd4: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
40011fd8: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40011fdc: 82 08 7f df and %g1, -33, %g1
<== NOT EXECUTED
40011fe0: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->rawOutBufState != rob_idle) {
40011fe4: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
<== NOT EXECUTED
40011fe8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40011fec: 22 80 00 0a be,a 40012014 <rtems_termios_ioctl+0x264>
<== NOT EXECUTED
40011ff0: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
40011ff4: c4 07 60 c0 ld [ %i5 + 0xc0 ], %g2
<== NOT EXECUTED
40011ff8: d2 07 60 b8 ld [ %i5 + 0xb8 ], %o1
<== NOT EXECUTED
(*tty->handler.write)(
40011ffc: c2 07 61 30 ld [ %i5 + 0x130 ], %g1
<== NOT EXECUTED
40012000: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
40012004: 92 02 40 02 add %o1, %g2, %o1
<== NOT EXECUTED
40012008: 9f c0 40 00 call %g1
<== NOT EXECUTED
4001200c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
( *context->lock_release )( context, lock_context );
40012010: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
40012014: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40012018: 9f c0 40 00 call %g1
<== NOT EXECUTED
4001201c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
40012020: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
40012024: 80 88 64 00 btst 0x400, %g1
40012028: 02 80 00 06 be 40012040 <rtems_termios_ioctl+0x290>
4001202c: 01 00 00 00 nop
40012030: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
40012034: 80 88 64 00 btst 0x400, %g1
40012038: 02 80 00 ab be 400122e4 <rtems_termios_ioctl+0x534>
<== ALWAYS TAKEN
4001203c: 01 00 00 00 nop
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
40012040: c4 07 61 48 ld [ %i5 + 0x148 ], %g2
40012044: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
40012048: 37 00 00 c0 sethi %hi(0x30000), %i3
4001204c: 80 88 a1 00 btst 0x100, %g2
40012050: 02 80 00 9c be 400122c0 <rtems_termios_ioctl+0x510>
<== ALWAYS TAKEN
40012054: 82 08 40 1b and %g1, %i3, %g1
40012058: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001205c: 02 80 00 87 be 40012278 <rtems_termios_ioctl+0x4c8>
<== NOT EXECUTED
40012060: 01 00 00 00 nop
<== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
40012064: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40012068: 82 10 61 00 or %g1, 0x100, %g1
<== NOT EXECUTED
4001206c: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->termios.c_iflag & IXOFF) {
40012070: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
40012074: 80 88 64 00 btst 0x400, %g1
40012078: 02 80 00 06 be 40012090 <rtems_termios_ioctl+0x2e0>
4001207c: 80 88 62 00 btst 0x200, %g1
tty->flow_ctrl |= FL_MDXOF;
40012080: c4 07 61 48 ld [ %i5 + 0x148 ], %g2
40012084: 84 10 a4 00 or %g2, 0x400, %g2
40012088: c4 27 61 48 st %g2, [ %i5 + 0x148 ]
if (tty->termios.c_iflag & IXON) {
4001208c: 80 88 62 00 btst 0x200, %g1
40012090: 22 80 00 06 be,a 400120a8 <rtems_termios_ioctl+0x2f8>
40012094: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
tty->flow_ctrl |= FL_MDXON;
40012098: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
4001209c: 82 10 62 00 or %g1, 0x200, %g1
400120a0: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
if (tty->termios.c_lflag & ICANON) {
400120a4: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
400120a8: 80 88 61 00 btst 0x100, %g1
400120ac: 12 80 00 64 bne 4001223c <rtems_termios_ioctl+0x48c>
400120b0: 82 10 20 01 mov 1, %g1
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
400120b4: c6 0f 60 71 ldub [ %i5 + 0x71 ], %g3
400120b8: 03 10 00 4d sethi %hi(0x40013400), %g1
400120bc: c2 00 61 84 ld [ %g1 + 0x184 ], %g1 ! 40013584 <_Watchdog_Ticks_per_second>
400120c0: 82 58 c0 01 smul %g3, %g1, %g1
rtems_clock_get_ticks_per_second() / 10;
400120c4: 05 33 33 33 sethi %hi(0xcccccc00), %g2
400120c8: 84 10 a0 cd or %g2, 0xcd, %g2 ! cccccccd <RAM_END+0x8c8ccccd>
400120cc: 80 50 40 02 umul %g1, %g2, %g0
400120d0: 83 40 00 00 rd %y, %g1
400120d4: 83 30 60 03 srl %g1, 3, %g1
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
400120d8: c2 27 60 7c st %g1, [ %i5 + 0x7c ]
if (tty->termios.c_cc[VTIME]) {
400120dc: 80 a0 e0 00 cmp %g3, 0
400120e0: 02 80 00 7c be 400122d0 <rtems_termios_ioctl+0x520>
400120e4: c4 0f 60 70 ldub [ %i5 + 0x70 ], %g2
if (tty->termios.c_cc[VMIN])
400120e8: 80 88 a0 ff btst 0xff, %g2
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
400120ec: c2 27 60 ac st %g1, [ %i5 + 0xac ]
tty->rawInBufSemaphoreWait = true;
400120f0: 84 10 20 01 mov 1, %g2
if (tty->termios.c_cc[VMIN])
400120f4: 12 80 00 54 bne 40012244 <rtems_termios_ioctl+0x494>
400120f8: c4 2f 60 a8 stb %g2, [ %i5 + 0xa8 ]
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
400120fc: 10 80 00 53 b 40012248 <rtems_termios_ioctl+0x498>
40012100: c2 27 60 b0 st %g1, [ %i5 + 0xb0 ]
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
40012104: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
<== NOT EXECUTED
40012108: c4 07 60 84 ld [ %i5 + 0x84 ], %g2
<== NOT EXECUTED
if ( rawnc < 0 )
4001210c: 84 a0 40 02 subcc %g1, %g2, %g2
<== NOT EXECUTED
40012110: 3c 80 00 05 bpos,a 40012124 <rtems_termios_ioctl+0x374>
<== NOT EXECUTED
40012114: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
<== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
40012118: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
<== NOT EXECUTED
4001211c: 84 00 80 01 add %g2, %g1, %g2
<== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
40012120: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
<== NOT EXECUTED
40012124: c8 07 60 44 ld [ %i5 + 0x44 ], %g4
<== NOT EXECUTED
40012128: c6 07 20 08 ld [ %i4 + 8 ], %g3
<== NOT EXECUTED
4001212c: 82 20 40 04 sub %g1, %g4, %g1
<== NOT EXECUTED
40012130: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
40012134: c2 20 c0 00 st %g1, [ %g3 ]
<== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40012138: b0 10 20 00 clr %i0
<== NOT EXECUTED
4001213c: 7f ff d7 75 call 40007f10 <_Mutex_Release>
<== NOT EXECUTED
40012140: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
}
40012144: 81 c7 e0 08 ret
<== NOT EXECUTED
40012148: 81 e8 00 00 restore
<== NOT EXECUTED
tty->tty_rcv = *wakeup;
4001214c: c2 27 61 6c st %g1, [ %i5 + 0x16c ]
sc = RTEMS_SUCCESSFUL;
40012150: b0 10 20 00 clr %i0
tty->tty_rcv = *wakeup;
40012154: c2 06 60 04 ld [ %i1 + 4 ], %g1
40012158: c2 27 61 70 st %g1, [ %i5 + 0x170 ]
4001215c: 7f ff d7 6d call 40007f10 <_Mutex_Release>
40012160: 90 10 00 1a mov %i2, %o0
}
40012164: 81 c7 e0 08 ret
40012168: 81 e8 00 00 restore
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
4001216c: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
<== NOT EXECUTED
40012170: 85 28 60 05 sll %g1, 5, %g2
40012174: 03 10 00 5b sethi %hi(0x40016c00), %g1
40012178: 82 10 61 c4 or %g1, 0x1c4, %g1 ! 40016dc4 <rtems_termios_linesw>
4001217c: 82 00 40 02 add %g1, %g2, %g1
40012180: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40012184: 80 a0 60 00 cmp %g1, 0
40012188: 02 80 00 77 be 40012364 <rtems_termios_ioctl+0x5b4>
<== NEVER TAKEN
4001218c: 92 10 00 1c mov %i4, %o1
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
40012190: 9f c0 40 00 call %g1
40012194: 90 10 00 1d mov %i5, %o0
40012198: 10 bf ff 27 b 40011e34 <rtems_termios_ioctl+0x84>
4001219c: b0 10 00 08 mov %o0, %i0
flags = *((int *)args->buffer);
400121a0: c2 06 20 08 ld [ %i0 + 8 ], %g1
400121a4: c2 00 40 00 ld [ %g1 ], %g1
if (flags == 0) {
400121a8: 80 a0 60 00 cmp %g1, 0
400121ac: 22 80 00 05 be,a 400121c0 <rtems_termios_ioctl+0x410>
<== NEVER TAKEN
400121b0: b6 10 20 01 mov 1, %i3
<== NOT EXECUTED
if (flags & FWRITE) {
400121b4: 80 88 60 02 btst 2, %g1
400121b8: 02 80 00 0e be 400121f0 <rtems_termios_ioctl+0x440>
400121bc: b6 08 60 01 and %g1, 1, %i3
rtems_termios_device_context *ctx = tty->device_context;
400121c0: f8 07 61 7c ld [ %i5 + 0x17c ], %i4
( *context->lock_acquire )( context, lock_context );
400121c4: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
400121c8: 90 10 00 1c mov %i4, %o0
400121cc: 9f c0 40 00 call %g1
400121d0: 92 07 bf fc add %fp, -4, %o1
tty->rawOutBuf.Tail = 0;
400121d4: c0 27 60 c0 clr [ %i5 + 0xc0 ]
( *context->lock_release )( context, lock_context );
400121d8: 92 07 bf fc add %fp, -4, %o1
tty->rawOutBuf.Head = 0;
400121dc: c0 27 60 bc clr [ %i5 + 0xbc ]
tty->rawOutBufState = rob_idle;
400121e0: c0 27 60 e4 clr [ %i5 + 0xe4 ]
400121e4: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
400121e8: 9f c0 40 00 call %g1
400121ec: 90 10 00 1c mov %i4, %o0
if (flags & FREAD) {
400121f0: 80 a6 e0 00 cmp %i3, 0
400121f4: 22 80 00 0e be,a 4001222c <rtems_termios_ioctl+0x47c>
400121f8: b0 10 20 00 clr %i0
rtems_termios_device_context *ctx = tty->device_context;
400121fc: f8 07 61 7c ld [ %i5 + 0x17c ], %i4
( *context->lock_acquire )( context, lock_context );
40012200: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40012204: 90 10 00 1c mov %i4, %o0
40012208: 9f c0 40 00 call %g1
4001220c: 92 07 bf fc add %fp, -4, %o1
tty->rawInBuf.Tail = 0;
40012210: c0 27 60 88 clr [ %i5 + 0x88 ]
( *context->lock_release )( context, lock_context );
40012214: 92 07 bf fc add %fp, -4, %o1
tty->rawInBuf.Head = 0;
40012218: c0 27 60 84 clr [ %i5 + 0x84 ]
4001221c: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
40012220: 9f c0 40 00 call %g1
40012224: 90 10 00 1c mov %i4, %o0
sc = RTEMS_SUCCESSFUL;
40012228: b0 10 20 00 clr %i0
4001222c: 7f ff d7 39 call 40007f10 <_Mutex_Release>
40012230: 90 10 00 1a mov %i2, %o0
}
40012234: 81 c7 e0 08 ret
40012238: 81 e8 00 00 restore
tty->rawInBufSemaphoreTimeout = 0;
4001223c: c0 27 60 ac clr [ %i5 + 0xac ]
tty->rawInBufSemaphoreWait = true;
40012240: c2 2f 60 a8 stb %g1, [ %i5 + 0xa8 ]
tty->rawInBufSemaphoreFirstTimeout = 0;
40012244: c0 27 60 b0 clr [ %i5 + 0xb0 ]
if (tty->handler.set_attributes) {
40012248: c2 07 61 34 ld [ %i5 + 0x134 ], %g1
4001224c: 80 a0 60 00 cmp %g1, 0
40012250: 02 bf ff f6 be 40012228 <rtems_termios_ioctl+0x478>
40012254: 92 10 00 18 mov %i0, %o1
sc = (*tty->handler.set_attributes)(tty->device_context, &tty->termios) ?
40012258: d0 07 61 7c ld [ %i5 + 0x17c ], %o0
4001225c: 9f c0 40 00 call %g1
40012260: b0 10 20 1b mov 0x1b, %i0
RTEMS_SUCCESSFUL : RTEMS_IO_ERROR;
40012264: 80 a2 20 00 cmp %o0, 0
40012268: 02 bf fe f3 be 40011e34 <rtems_termios_ioctl+0x84>
4001226c: 01 00 00 00 nop
sc = RTEMS_SUCCESSFUL;
40012270: 10 bf ff ef b 4001222c <rtems_termios_ioctl+0x47c>
40012274: b0 10 20 00 clr %i0 ! 0 <PROM_START>
tty->flow_ctrl &= ~(FL_MDRTS);
40012278: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
4001227c: 82 08 7e ff and %g1, -257, %g1
<== NOT EXECUTED
40012280: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_IRTSOFF) &&
40012284: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40012288: 80 88 60 04 btst 4, %g1
<== NOT EXECUTED
4001228c: 02 80 00 31 be 40012350 <rtems_termios_ioctl+0x5a0>
<== NOT EXECUTED
40012290: 01 00 00 00 nop
<== NOT EXECUTED
(tty->flow.start_remote_tx != NULL)) {
40012294: c2 07 61 44 ld [ %i5 + 0x144 ], %g1
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_IRTSOFF) &&
40012298: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001229c: 02 80 00 2d be 40012350 <rtems_termios_ioctl+0x5a0>
<== NOT EXECUTED
400122a0: 01 00 00 00 nop
<== NOT EXECUTED
tty->flow.start_remote_tx(ctx);
400122a4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400122a8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
tty->flow_ctrl &= ~(FL_IRTSOFF);
400122ac: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
400122b0: 82 08 7f fb and %g1, -5, %g1
<== NOT EXECUTED
400122b4: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
400122b8: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
<== NOT EXECUTED
400122bc: 82 08 40 1b and %g1, %i3, %g1
<== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
400122c0: 80 a0 60 00 cmp %g1, 0
400122c4: 22 bf ff 6c be,a 40012074 <rtems_termios_ioctl+0x2c4>
<== ALWAYS TAKEN
400122c8: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
400122cc: 30 bf ff 66 b,a 40012064 <rtems_termios_ioctl+0x2b4>
<== NOT EXECUTED
if (tty->termios.c_cc[VMIN]) {
400122d0: 80 88 a0 ff btst 0xff, %g2
400122d4: 12 bf ff da bne 4001223c <rtems_termios_ioctl+0x48c>
400122d8: 82 10 20 01 mov 1, %g1
tty->rawInBufSemaphoreWait = false;
400122dc: 10 bf ff db b 40012248 <rtems_termios_ioctl+0x498>
400122e0: c0 2f 60 a8 clrb [ %i5 + 0xa8 ]
tty->flow_ctrl &= ~(FL_MDXOF);
400122e4: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
400122e8: 82 08 7b ff and %g1, -1025, %g1
400122ec: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
tty->flow_ctrl &= ~(FL_ISNTXOF);
400122f0: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
400122f4: 82 08 7f fd and %g1, -3, %g1
400122f8: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
400122fc: 30 bf ff 51 b,a 40012040 <rtems_termios_ioctl+0x290>
drainOutput (tty);
40012300: 7f ff f7 bd call 400101f4 <drainOutput>
40012304: 90 10 00 1d mov %i5, %o0
if (args->command == TIOCSETAF) {
40012308: c4 07 20 04 ld [ %i4 + 4 ], %g2
4001230c: 03 20 0b 1d sethi %hi(0x802c7400), %g1
40012310: 82 10 60 16 or %g1, 0x16, %g1 ! 802c7416 <RAM_END+0x3fec7416>
40012314: 80 a0 80 01 cmp %g2, %g1
40012318: 12 bf ff 1d bne 40011f8c <rtems_termios_ioctl+0x1dc>
4001231c: 01 00 00 00 nop
rtems_termios_device_context *ctx = tty->device_context;
40012320: f8 07 61 7c ld [ %i5 + 0x17c ], %i4
( *context->lock_acquire )( context, lock_context );
40012324: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40012328: 90 10 00 1c mov %i4, %o0
4001232c: 9f c0 40 00 call %g1
40012330: 92 07 bf fc add %fp, -4, %o1
tty->rawInBuf.Tail = 0;
40012334: c0 27 60 88 clr [ %i5 + 0x88 ]
( *context->lock_release )( context, lock_context );
40012338: 92 07 bf fc add %fp, -4, %o1
tty->rawInBuf.Head = 0;
4001233c: c0 27 60 84 clr [ %i5 + 0x84 ]
40012340: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
40012344: 9f c0 40 00 call %g1
40012348: 90 10 00 1c mov %i4, %o0
4001234c: 30 bf ff 10 b,a 40011f8c <rtems_termios_ioctl+0x1dc>
tty->flow_ctrl &= ~(FL_IRTSOFF);
40012350: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40012354: 82 08 7f fb and %g1, -5, %g1
<== NOT EXECUTED
40012358: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->termios.c_iflag & IXOFF) {
4001235c: 10 bf ff 46 b 40012074 <rtems_termios_ioctl+0x2c4>
<== NOT EXECUTED
40012360: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
} else if (tty->handler.ioctl) {
40012364: c2 07 61 38 ld [ %i5 + 0x138 ], %g1
<== NOT EXECUTED
40012368: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4001236c: 02 80 00 08 be 4001238c <rtems_termios_ioctl+0x5dc>
<== NOT EXECUTED
40012370: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
args->ioctl_return = (*tty->handler.ioctl) (tty->device_context,
40012374: d4 07 20 08 ld [ %i4 + 8 ], %o2
<== NOT EXECUTED
40012378: d0 07 61 7c ld [ %i5 + 0x17c ], %o0
<== NOT EXECUTED
4001237c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40012380: b0 10 20 00 clr %i0
<== NOT EXECUTED
40012384: 10 bf fe ac b 40011e34 <rtems_termios_ioctl+0x84>
<== NOT EXECUTED
40012388: d0 27 20 0c st %o0, [ %i4 + 0xc ]
<== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
4001238c: 10 bf fe aa b 40011e34 <rtems_termios_ioctl+0x84>
<== NOT EXECUTED
40012390: b0 10 20 0a mov 0xa, %i0
<== NOT EXECUTED
400080b0 <rtems_termios_open>:
{
400080b0: 9d e3 bf a0 save %sp, -96, %sp
_Mutex_Acquire( mutex );
400080b4: 3b 10 00 78 sethi %hi(0x4001e000), %i5
400080b8: 40 00 0e b9 call 4000bb9c <_Mutex_Acquire>
400080bc: 90 17 61 30 or %i5, 0x130, %o0 ! 4001e130 <rtems_termios_ttyMutex>
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
400080c0: 39 10 00 7c sethi %hi(0x4001f000), %i4
400080c4: d6 07 21 80 ld [ %i4 + 0x180 ], %o3 ! 4001f180 <rtems_termios_ttyHead>
400080c8: 80 a2 e0 00 cmp %o3, 0
400080cc: 32 80 00 08 bne,a 400080ec <rtems_termios_open+0x3c>
<== NEVER TAKEN
400080d0: c2 02 e0 0c ld [ %o3 + 0xc ], %g1
<== NOT EXECUTED
tty = rtems_termios_open_tty(
400080d4: 10 80 00 0e b 4000810c <rtems_termios_open+0x5c>
400080d8: 9a 10 00 1b mov %i3, %o5
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
400080dc: 80 a2 e0 00 cmp %o3, 0
<== NOT EXECUTED
400080e0: 02 80 00 0b be 4000810c <rtems_termios_open+0x5c>
<== NOT EXECUTED
400080e4: 9a 10 00 1b mov %i3, %o5
<== NOT EXECUTED
if ((tty->major == major) && (tty->minor == minor))
400080e8: c2 02 e0 0c ld [ %o3 + 0xc ], %g1
<== NOT EXECUTED
400080ec: 80 a0 40 18 cmp %g1, %i0
<== NOT EXECUTED
400080f0: 32 bf ff fb bne,a 400080dc <rtems_termios_open+0x2c>
<== NOT EXECUTED
400080f4: d6 02 c0 00 ld [ %o3 ], %o3
<== NOT EXECUTED
400080f8: c2 02 e0 10 ld [ %o3 + 0x10 ], %g1
<== NOT EXECUTED
400080fc: 80 a0 40 19 cmp %g1, %i1
<== NOT EXECUTED
40008100: 32 bf ff f7 bne,a 400080dc <rtems_termios_open+0x2c>
<== NOT EXECUTED
40008104: d6 02 c0 00 ld [ %o3 ], %o3
<== NOT EXECUTED
tty = rtems_termios_open_tty(
40008108: 9a 10 00 1b mov %i3, %o5
<== NOT EXECUTED
4000810c: 98 10 20 00 clr %o4
40008110: 94 10 00 1a mov %i2, %o2
40008114: 92 10 00 19 mov %i1, %o1
40008118: 7f ff fa 12 call 40006960 <rtems_termios_open_tty>
4000811c: 90 10 00 18 mov %i0, %o0
if (tty == NULL) {
40008120: 80 a2 20 00 cmp %o0, 0
40008124: 22 80 00 18 be,a 40008184 <rtems_termios_open+0xd4>
40008128: 90 17 61 30 or %i5, 0x130, %o0
if (tty->refcount == 1) {
4000812c: c2 02 20 08 ld [ %o0 + 8 ], %g1
40008130: 80 a0 60 01 cmp %g1, 1
40008134: 02 80 00 07 be 40008150 <rtems_termios_open+0xa0>
<== ALWAYS TAKEN
40008138: c2 07 21 80 ld [ %i4 + 0x180 ], %g1
_Mutex_Release( mutex );
4000813c: 90 17 61 30 or %i5, 0x130, %o0
40008140: 40 00 0e b3 call 4000bc0c <_Mutex_Release>
40008144: b0 10 20 00 clr %i0
}
40008148: 81 c7 e0 08 ret
4000814c: 81 e8 00 00 restore
tty->forw = rtems_termios_ttyHead;
40008150: c2 22 00 00 st %g1, [ %o0 ]
if (rtems_termios_ttyHead != NULL)
40008154: 80 a0 60 00 cmp %g1, 0
40008158: 02 80 00 03 be 40008164 <rtems_termios_open+0xb4>
<== ALWAYS TAKEN
4000815c: c0 22 20 04 clr [ %o0 + 4 ]
rtems_termios_ttyHead->back = tty;
40008160: d0 20 60 04 st %o0, [ %g1 + 4 ]
<== NOT EXECUTED
if (rtems_termios_ttyTail == NULL)
40008164: 03 10 00 7c sethi %hi(0x4001f000), %g1
rtems_termios_ttyHead = tty;
40008168: d0 27 21 80 st %o0, [ %i4 + 0x180 ]
if (rtems_termios_ttyTail == NULL)
4000816c: c4 00 61 7c ld [ %g1 + 0x17c ], %g2
40008170: 80 a0 a0 00 cmp %g2, 0
40008174: 22 bf ff f2 be,a 4000813c <rtems_termios_open+0x8c>
<== ALWAYS TAKEN
40008178: d0 20 61 7c st %o0, [ %g1 + 0x17c ]
4000817c: 10 bf ff f1 b 40008140 <rtems_termios_open+0x90>
<== NOT EXECUTED
40008180: 90 17 61 30 or %i5, 0x130, %o0
<== NOT EXECUTED
40008184: 40 00 0e a2 call 4000bc0c <_Mutex_Release>
40008188: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
4000818c: 81 c7 e0 08 ret
40008190: 81 e8 00 00 restore
400128b4 <rtems_termios_set_best_baud>:
{
const rtems_assoc_t *current = &rtems_termios_baud_table[ 0 ];
const rtems_assoc_t *last = current;
speed_t spd;
while ( current->name != NULL && current->local_value < baud ) {
400128b4: 03 10 00 50 sethi %hi(0x40014000), %g1
400128b8: c6 00 60 50 ld [ %g1 + 0x50 ], %g3 ! 40014050 <rtems_termios_baud_table>
if ( current->name != NULL ) {
uint32_t mid = (last->local_value + current->local_value) / UINT32_C( 2 );
spd = baud <= mid ? last->remote_value : current->remote_value;
} else {
spd = B460800;
400128bc: 05 00 01 c2 sethi %hi(0x70800), %g2
while ( current->name != NULL && current->local_value < baud ) {
400128c0: 80 a0 e0 00 cmp %g3, 0
400128c4: 02 80 00 12 be 4001290c <rtems_termios_set_best_baud+0x58>
<== NEVER TAKEN
400128c8: 82 10 60 50 or %g1, 0x50, %g1
400128cc: c8 00 60 04 ld [ %g1 + 4 ], %g4
400128d0: 80 a2 40 04 cmp %o1, %g4
400128d4: 38 80 00 0a bgu,a 400128fc <rtems_termios_set_best_baud+0x48>
400128d8: c6 00 60 0c ld [ %g1 + 0xc ], %g3
400128dc: 10 80 00 1b b 40012948 <rtems_termios_set_best_baud+0x94>
400128e0: 86 10 00 04 mov %g4, %g3
400128e4: c6 00 a0 04 ld [ %g2 + 4 ], %g3
400128e8: 80 a0 c0 09 cmp %g3, %o1
400128ec: 3a 80 00 0b bcc,a 40012918 <rtems_termios_set_best_baud+0x64>
400128f0: c8 00 60 04 ld [ %g1 + 4 ], %g4
400128f4: 82 10 00 02 mov %g2, %g1
400128f8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
400128fc: 80 a0 e0 00 cmp %g3, 0
40012900: 12 bf ff f9 bne 400128e4 <rtems_termios_set_best_baud+0x30>
40012904: 84 00 60 0c add %g1, 0xc, %g2
spd = B460800;
40012908: 05 00 01 c2 sethi %hi(0x70800), %g2
}
term->c_ispeed = spd;
4001290c: c4 22 20 24 st %g2, [ %o0 + 0x24 ]
term->c_ospeed = spd;
}
40012910: 81 c3 e0 08 retl
40012914: c4 22 20 28 st %g2, [ %o0 + 0x28 ]
uint32_t mid = (last->local_value + current->local_value) / UINT32_C( 2 );
40012918: 86 00 c0 04 add %g3, %g4, %g3
4001291c: 87 30 e0 01 srl %g3, 1, %g3
spd = baud <= mid ? last->remote_value : current->remote_value;
40012920: 80 a2 40 03 cmp %o1, %g3
40012924: 28 80 00 06 bleu,a 4001293c <rtems_termios_set_best_baud+0x88>
40012928: c4 00 60 08 ld [ %g1 + 8 ], %g2
4001292c: c4 00 a0 08 ld [ %g2 + 8 ], %g2
term->c_ispeed = spd;
40012930: c4 22 20 24 st %g2, [ %o0 + 0x24 ]
}
40012934: 81 c3 e0 08 retl
40012938: c4 22 20 28 st %g2, [ %o0 + 0x28 ]
term->c_ispeed = spd;
4001293c: c4 22 20 24 st %g2, [ %o0 + 0x24 ]
}
40012940: 81 c3 e0 08 retl
40012944: c4 22 20 28 st %g2, [ %o0 + 0x28 ]
const rtems_assoc_t *current = &rtems_termios_baud_table[ 0 ];
40012948: 10 bf ff f4 b 40012918 <rtems_termios_set_best_baud+0x64>
4001294c: 84 10 00 01 mov %g1, %g2
40012e80 <rtems_verror>:
int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
40012e80: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
40012e84: 03 08 00 00 sethi %hi(0x20000000), %g1
<== NOT EXECUTED
40012e88: 80 8e 00 01 btst %i0, %g1
<== NOT EXECUTED
40012e8c: 02 80 00 0e be 40012ec4 <rtems_verror+0x44>
<== NOT EXECUTED
40012e90: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
if (rtems_panic_in_progress++)
40012e94: 05 10 00 b8 sethi %hi(0x4002e000), %g2
<== NOT EXECUTED
40012e98: c2 00 a1 a8 ld [ %g2 + 0x1a8 ], %g1 ! 4002e1a8 <rtems_panic_in_progress>
<== NOT EXECUTED
40012e9c: 86 00 60 01 add %g1, 1, %g3
<== NOT EXECUTED
40012ea0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40012ea4: 02 80 00 08 be 40012ec4 <rtems_verror+0x44>
<== NOT EXECUTED
40012ea8: c6 20 a1 a8 st %g3, [ %g2 + 0x1a8 ]
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
40012eac: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40012eb0: 82 00 60 01 inc %g1
<== NOT EXECUTED
40012eb4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
_Thread_Dispatch_disable(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
40012eb8: 80 a0 e0 02 cmp %g3, 2
<== NOT EXECUTED
40012ebc: 14 80 00 1d bg 40012f30 <rtems_verror+0xb0>
<== NOT EXECUTED
40012ec0: b0 10 20 00 clr %i0
<== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
40012ec4: 7f ff b9 db call 40001630 <__getreent>
<== NOT EXECUTED
40012ec8: 39 1c 00 00 sethi %hi(0x70000000), %i4
<== NOT EXECUTED
40012ecc: 40 00 0c e2 call 40016254 <fflush>
<== NOT EXECUTED
40012ed0: d0 02 20 08 ld [ %o0 + 8 ], %o0
<== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
40012ed4: 03 10 00 00 sethi %hi(0x40000000), %g1
<== NOT EXECUTED
40012ed8: 80 8f 40 01 btst %i5, %g1
<== NOT EXECUTED
40012edc: 12 80 00 17 bne 40012f38 <rtems_verror+0xb8>
<== NOT EXECUTED
40012ee0: b8 2f 40 1c andn %i5, %i4, %i4
<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
40012ee4: 7f ff b9 d3 call 40001630 <__getreent>
<== NOT EXECUTED
40012ee8: 01 00 00 00 nop
<== NOT EXECUTED
40012eec: d0 02 20 0c ld [ %o0 + 0xc ], %o0
<== NOT EXECUTED
40012ef0: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40012ef4: 40 00 32 43 call 4001f800 <vfprintf>
<== NOT EXECUTED
40012ef8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (status)
40012efc: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40012f00: 12 80 00 37 bne 40012fdc <rtems_verror+0x15c>
<== NOT EXECUTED
40012f04: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
40012f08: 7f ff b9 ca call 40001630 <__getreent>
<== NOT EXECUTED
40012f0c: 01 00 00 00 nop
<== NOT EXECUTED
40012f10: 13 10 00 a4 sethi %hi(0x40029000), %o1
<== NOT EXECUTED
40012f14: d0 02 20 0c ld [ %o0 + 0xc ], %o0
<== NOT EXECUTED
40012f18: 40 00 0e ba call 40016a00 <fprintf>
<== NOT EXECUTED
40012f1c: 92 12 61 a8 or %o1, 0x1a8, %o1
<== NOT EXECUTED
(void) fflush(stderr);
40012f20: 7f ff b9 c4 call 40001630 <__getreent>
<== NOT EXECUTED
40012f24: b0 02 00 18 add %o0, %i0, %i0
<== NOT EXECUTED
40012f28: 40 00 0c cb call 40016254 <fflush>
<== NOT EXECUTED
40012f2c: d0 02 20 0c ld [ %o0 + 0xc ], %o0
<== NOT EXECUTED
40012f30: 81 c7 e0 08 ret
<== NOT EXECUTED
40012f34: 81 e8 00 00 restore
<== NOT EXECUTED
local_errno = errno;
40012f38: 40 00 0b 8c call 40015d68 <__errno>
<== NOT EXECUTED
40012f3c: 01 00 00 00 nop
<== NOT EXECUTED
chars_written += vfprintf(stderr, printf_format, arglist);
40012f40: 7f ff b9 bc call 40001630 <__getreent>
<== NOT EXECUTED
40012f44: fa 02 00 00 ld [ %o0 ], %i5
<== NOT EXECUTED
40012f48: d0 02 20 0c ld [ %o0 + 0xc ], %o0
<== NOT EXECUTED
40012f4c: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
40012f50: 40 00 32 2c call 4001f800 <vfprintf>
<== NOT EXECUTED
40012f54: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
if (status)
40012f58: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40012f5c: 12 80 00 21 bne 40012fe0 <rtems_verror+0x160>
<== NOT EXECUTED
40012f60: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
if (local_errno) {
40012f64: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
40012f68: 02 bf ff e8 be 40012f08 <rtems_verror+0x88>
<== NOT EXECUTED
40012f6c: 01 00 00 00 nop
<== NOT EXECUTED
if ((local_errno > 0) && *strerror(local_errno))
40012f70: 04 80 00 08 ble 40012f90 <rtems_verror+0x110>
<== NOT EXECUTED
40012f74: 01 00 00 00 nop
<== NOT EXECUTED
40012f78: 40 00 1b 7c call 40019d68 <strerror>
<== NOT EXECUTED
40012f7c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40012f80: c2 4a 00 00 ldsb [ %o0 ], %g1
<== NOT EXECUTED
40012f84: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40012f88: 12 80 00 22 bne 40013010 <rtems_verror+0x190>
<== NOT EXECUTED
40012f8c: 01 00 00 00 nop
<== NOT EXECUTED
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
40012f90: 7f ff b9 a8 call 40001630 <__getreent>
<== NOT EXECUTED
40012f94: 01 00 00 00 nop
<== NOT EXECUTED
40012f98: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
40012f9c: d0 02 20 0c ld [ %o0 + 0xc ], %o0
<== NOT EXECUTED
40012fa0: 13 10 00 a5 sethi %hi(0x40029400), %o1
<== NOT EXECUTED
40012fa4: 40 00 0e 97 call 40016a00 <fprintf>
<== NOT EXECUTED
40012fa8: 92 12 60 38 or %o1, 0x38, %o1 ! 40029438 <state_pairs+0xd8>
<== NOT EXECUTED
chars_written += fprintf(stderr, "\n");
40012fac: 7f ff b9 a1 call 40001630 <__getreent>
<== NOT EXECUTED
40012fb0: b0 06 00 08 add %i0, %o0, %i0
<== NOT EXECUTED
40012fb4: 13 10 00 a4 sethi %hi(0x40029000), %o1
<== NOT EXECUTED
40012fb8: d0 02 20 0c ld [ %o0 + 0xc ], %o0
<== NOT EXECUTED
40012fbc: 40 00 0e 91 call 40016a00 <fprintf>
<== NOT EXECUTED
40012fc0: 92 12 61 a8 or %o1, 0x1a8, %o1
<== NOT EXECUTED
(void) fflush(stderr);
40012fc4: 7f ff b9 9b call 40001630 <__getreent>
<== NOT EXECUTED
40012fc8: b0 02 00 18 add %o0, %i0, %i0
<== NOT EXECUTED
40012fcc: 40 00 0c a2 call 40016254 <fflush>
<== NOT EXECUTED
40012fd0: d0 02 20 0c ld [ %o0 + 0xc ], %o0
<== NOT EXECUTED
40012fd4: 81 c7 e0 08 ret
<== NOT EXECUTED
40012fd8: 81 e8 00 00 restore
<== NOT EXECUTED
int local_errno = 0;
40012fdc: ba 10 20 00 clr %i5
<== NOT EXECUTED
fprintf(stderr, " (status: %s)", rtems_status_text(status));
40012fe0: 7f ff b9 94 call 40001630 <__getreent>
<== NOT EXECUTED
40012fe4: 01 00 00 00 nop
<== NOT EXECUTED
40012fe8: f6 02 20 0c ld [ %o0 + 0xc ], %i3
<== NOT EXECUTED
40012fec: 7f ff d9 5e call 40009564 <rtems_status_text>
<== NOT EXECUTED
40012ff0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40012ff4: 13 10 00 a5 sethi %hi(0x40029400), %o1
<== NOT EXECUTED
40012ff8: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
40012ffc: 92 12 60 18 or %o1, 0x18, %o1
<== NOT EXECUTED
40013000: 40 00 0e 80 call 40016a00 <fprintf>
<== NOT EXECUTED
40013004: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
chars_written +=
40013008: 10 bf ff d7 b 40012f64 <rtems_verror+0xe4>
<== NOT EXECUTED
4001300c: b0 06 00 08 add %i0, %o0, %i0
<== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
40013010: 7f ff b9 88 call 40001630 <__getreent>
<== NOT EXECUTED
40013014: 01 00 00 00 nop
<== NOT EXECUTED
40013018: f8 02 20 0c ld [ %o0 + 0xc ], %i4
<== NOT EXECUTED
4001301c: 40 00 1b 53 call 40019d68 <strerror>
<== NOT EXECUTED
40013020: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40013024: 13 10 00 a5 sethi %hi(0x40029400), %o1
<== NOT EXECUTED
40013028: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
4001302c: 92 12 60 28 or %o1, 0x28, %o1
<== NOT EXECUTED
40013030: 40 00 0e 74 call 40016a00 <fprintf>
<== NOT EXECUTED
40013034: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40013038: 10 bf ff b4 b 40012f08 <rtems_verror+0x88>
<== NOT EXECUTED
4001303c: b0 06 00 08 add %i0, %o0, %i0
<== NOT EXECUTED
40010b18 <rtems_vprintf>:
int rtems_vprintf(
const rtems_printer *printer,
const char *format,
va_list ap
)
{
40010b18: 9d e3 bf a0 save %sp, -96, %sp
40010b1c: 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;
40010b20: 80 a0 60 00 cmp %g1, 0
40010b24: 02 80 00 0a be 40010b4c <rtems_vprintf+0x34>
<== NEVER TAKEN
40010b28: b0 10 20 00 clr %i0
40010b2c: c4 00 60 04 ld [ %g1 + 4 ], %g2
40010b30: 80 a0 a0 00 cmp %g2, 0
40010b34: 02 80 00 06 be 40010b4c <rtems_vprintf+0x34>
<== NEVER TAKEN
40010b38: 94 10 00 1a mov %i2, %o2
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
len = printer->printer( printer->context, format, ap );
40010b3c: d0 00 40 00 ld [ %g1 ], %o0
40010b40: 9f c0 80 00 call %g2
40010b44: 92 10 00 19 mov %i1, %o1
40010b48: b0 10 00 08 mov %o0, %i0
}
return len;
}
40010b4c: 81 c7 e0 08 ret
40010b50: 81 e8 00 00 restore
4000cdd0 <setgrent>:
void setgrent(void)
{
4000cdd0: 9d e3 bf a0 save %sp, -96, %sp
grp_context *ctx = grp_get_context();
4000cdd4: 7f ff ff d8 call 4000cd34 <grp_get_context>
4000cdd8: 01 00 00 00 nop
if (ctx == NULL) {
4000cddc: ba 92 20 00 orcc %o0, 0, %i5
4000cde0: 02 80 00 12 be 4000ce28 <setgrent+0x58>
<== ALWAYS TAKEN
4000cde4: 92 10 21 14 mov 0x114, %o1
return;
}
}
_libcsupport_pwdgrp_init();
4000cde8: 7f ff e1 97 call 40005444 <_libcsupport_pwdgrp_init>
4000cdec: 01 00 00 00 nop
if (ctx->fp != NULL)
4000cdf0: d0 07 40 00 ld [ %i5 ], %o0
4000cdf4: 80 a2 20 00 cmp %o0, 0
4000cdf8: 02 80 00 05 be 4000ce0c <setgrent+0x3c>
<== ALWAYS TAKEN
4000cdfc: 13 10 00 4b sethi %hi(0x40012c00), %o1
fclose(ctx->fp);
4000ce00: 40 00 06 56 call 4000e758 <fclose>
<== NOT EXECUTED
4000ce04: 01 00 00 00 nop
<== NOT EXECUTED
ctx->fp = fopen("/etc/group", "r");
4000ce08: 13 10 00 4b sethi %hi(0x40012c00), %o1
<== NOT EXECUTED
4000ce0c: 11 10 00 49 sethi %hi(0x40012400), %o0
4000ce10: 92 12 61 80 or %o1, 0x180, %o1
4000ce14: 40 00 08 86 call 4000f02c <fopen>
4000ce18: 90 12 23 90 or %o0, 0x390, %o0
4000ce1c: d0 27 40 00 st %o0, [ %i5 ]
}
4000ce20: 81 c7 e0 08 ret
4000ce24: 81 e8 00 00 restore
ctx = calloc(1, sizeof(*ctx));
4000ce28: 7f ff dd 48 call 40004348 <calloc>
4000ce2c: 90 10 20 01 mov 1, %o0
if (ctx == NULL)
4000ce30: ba 92 20 00 orcc %o0, 0, %i5
4000ce34: 02 bf ff fb be 4000ce20 <setgrent+0x50>
<== NEVER TAKEN
4000ce38: b0 10 00 08 mov %o0, %i0
eno = pthread_setspecific(grp_key, ctx);
4000ce3c: 03 10 00 56 sethi %hi(0x40015800), %g1
4000ce40: d0 00 61 68 ld [ %g1 + 0x168 ], %o0 ! 40015968 <grp_key>
4000ce44: 7f ff e7 68 call 40006be4 <pthread_setspecific>
4000ce48: 92 10 00 18 mov %i0, %o1
if (eno != 0) {
4000ce4c: 80 a2 20 00 cmp %o0, 0
4000ce50: 02 bf ff e6 be 4000cde8 <setgrent+0x18>
<== ALWAYS TAKEN
4000ce54: 01 00 00 00 nop
free(ctx);
4000ce58: 7f ff dd 87 call 40004474 <free>
<== NOT EXECUTED
4000ce5c: 81 e8 00 00 restore
<== NOT EXECUTED
400065a4 <unmount>:
* in some form is supported on most UNIX and POSIX systems. This
* routine is necessary to mount instantiations of a file system
* into the file system name space.
*/
int unmount( const char *path )
{
400065a4: 9d e3 bf 60 save %sp, -160, %sp
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
400065a8: 94 10 20 18 mov 0x18, %o2
400065ac: 92 10 00 18 mov %i0, %o1
400065b0: 7f ff fd b6 call 40005c88 <rtems_filesystem_eval_path_start>
400065b4: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
400065b8: fa 02 20 14 ld [ %o0 + 0x14 ], %i5
return (*mt_entry->ops->are_nodes_equal_h)(
400065bc: c2 07 60 0c ld [ %i5 + 0xc ], %g1
400065c0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
400065c4: 9f c0 40 00 call %g1
400065c8: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
400065cc: 80 a2 20 00 cmp %o0, 0
400065d0: 02 80 00 34 be 400066a0 <unmount+0xfc>
<== NEVER TAKEN
400065d4: 01 00 00 00 nop
&rtems_filesystem_root->location;
400065d8: 7f ff fb 68 call 40005378 <rtems_current_user_env_get>
400065dc: 01 00 00 00 nop
&rtems_filesystem_current->location;
400065e0: 7f ff fb 66 call 40005378 <rtems_current_user_env_get>
400065e4: f8 02 20 04 ld [ %o0 + 4 ], %i4
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
400065e8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
400065ec: 80 a7 40 01 cmp %i5, %g1
400065f0: 02 80 00 14 be 40006640 <unmount+0x9c>
<== NEVER TAKEN
400065f4: 01 00 00 00 nop
400065f8: c2 02 00 00 ld [ %o0 ], %g1
400065fc: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40006600: 80 a7 40 01 cmp %i5, %g1
40006604: 02 80 00 0f be 40006640 <unmount+0x9c>
<== NEVER TAKEN
40006608: 01 00 00 00 nop
if ( !contains_root_or_current_directory( mt_entry ) ) {
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
4000660c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
const rtems_filesystem_operations_table *mt_point_ops =
40006610: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
40006614: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40006618: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
4000661c: 9f c0 40 00 call %g1
40006620: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40006624: b0 92 20 00 orcc %o0, 0, %i0
40006628: 02 80 00 0b be 40006654 <unmount+0xb0>
<== ALWAYS TAKEN
4000662c: 01 00 00 00 nop
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40006630: 7f ff fd e0 call 40005db0 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40006634: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
40006638: 81 c7 e0 08 ret
4000663c: 81 e8 00 00 restore
errno = EBUSY;
40006640: 40 00 21 43 call 4000eb4c <__errno>
<== NOT EXECUTED
40006644: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006648: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000664c: 10 bf ff f9 b 40006630 <unmount+0x8c>
<== NOT EXECUTED
40006650: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_id self_task_id = rtems_task_self();
40006654: 40 00 01 52 call 40006b9c <rtems_task_self>
40006658: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000665c: 91 d0 20 09 ta 9
<== NOT EXECUTED
mt_entry->unmount_task = self_task_id;
40006660: d0 27 60 3c st %o0, [ %i5 + 0x3c ]
<== NOT EXECUTED
mt_entry->mounted = false;
40006664: c0 2f 60 28 clrb [ %i5 + 0x28 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006668: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000666c: 01 00 00 00 nop
rtems_filesystem_eval_path_cleanup( &ctx );
40006670: 7f ff fd d0 call 40005db0 <rtems_filesystem_eval_path_cleanup>
40006674: 90 07 bf c8 add %fp, -56, %o0
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
40006678: 96 07 bf c4 add %fp, -60, %o3
4000667c: 94 10 20 00 clr %o2
40006680: 92 10 20 00 clr %o1
40006684: 40 00 00 e8 call 40006a24 <rtems_event_system_receive>
40006688: 11 20 00 00 sethi %hi(0x80000000), %o0
if ( sc != RTEMS_SUCCESSFUL ) {
4000668c: 80 a2 20 00 cmp %o0, 0
40006690: 02 bf ff ea be 40006638 <unmount+0x94>
<== ALWAYS TAKEN
40006694: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
40006698: 40 00 01 77 call 40006c74 <rtems_fatal_error_occurred>
<== NOT EXECUTED
4000669c: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0x9e6dbeef>
<== NOT EXECUTED
errno = EACCES;
400066a0: 40 00 21 2b call 4000eb4c <__errno>
<== NOT EXECUTED
400066a4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400066a8: 82 10 20 0d mov 0xd, %g1
<== NOT EXECUTED
400066ac: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
400066b0: 7f ff fd c0 call 40005db0 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
400066b4: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
400066b8: 81 c7 e0 08 ret
<== NOT EXECUTED
400066bc: 81 e8 00 00 restore
<== NOT EXECUTED
40007bc0 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
40007bc0: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
40007bc4: 80 a6 60 00 cmp %i1, 0
40007bc8: 02 80 00 32 be 40007c90 <write+0xd0>
<== NEVER TAKEN
40007bcc: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
40007bd0: 02 80 00 22 be 40007c58 <write+0x98>
40007bd4: 84 10 20 00 clr %g2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40007bd8: 03 10 00 52 sethi %hi(0x40014800), %g1
40007bdc: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1 ! 40014af8 <rtems_libio_number_iops>
40007be0: 80 a6 00 01 cmp %i0, %g1
40007be4: 1a 80 00 25 bcc 40007c78 <write+0xb8>
<== NEVER TAKEN
40007be8: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
40007bec: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40007bf0: 31 10 00 5f sethi %hi(0x40017c00), %i0
<== NOT EXECUTED
40007bf4: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40007bf8: b0 16 22 a8 or %i0, 0x2a8, %i0
<== NOT EXECUTED
40007bfc: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007c00: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40007c04: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40007c08: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40007c0c: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007c10: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007c14: 01 00 00 00 nop
40007c18: 84 08 a1 04 and %g2, 0x104, %g2
40007c1c: 80 a0 a1 04 cmp %g2, 0x104
40007c20: 12 80 00 10 bne 40007c60 <write+0xa0>
<== NEVER TAKEN
40007c24: 94 10 00 1a mov %i2, %o2
/*
* Now process the write() request.
*/
n = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
40007c28: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40007c2c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40007c30: 92 10 00 19 mov %i1, %o1
40007c34: 9f c0 40 00 call %g1
40007c38: 90 10 00 1d mov %i5, %o0
40007c3c: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007c40: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40007c44: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
40007c48: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
40007c4c: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007c50: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007c54: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return n;
}
40007c58: 81 c7 e0 08 ret
40007c5c: 91 e8 00 02 restore %g0, %g2, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007c60: 91 d0 20 09 ta 9
<== NOT EXECUTED
40007c64: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40007c68: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40007c6c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007c70: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007c74: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40007c78: 40 00 2c e1 call 40012ffc <__errno>
<== NOT EXECUTED
40007c7c: 01 00 00 00 nop
<== NOT EXECUTED
40007c80: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
40007c84: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40007c88: 10 bf ff f4 b 40007c58 <write+0x98>
<== NOT EXECUTED
40007c8c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_libio_check_buffer( buffer );
40007c90: 40 00 2c db call 40012ffc <__errno>
<== NOT EXECUTED
40007c94: 01 00 00 00 nop
<== NOT EXECUTED
40007c98: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40007c9c: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40007ca0: 10 bf ff ee b 40007c58 <write+0x98>
<== NOT EXECUTED
40007ca4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000ef00 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
4000ef00: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( iov == NULL )
4000ef04: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000ef08: 02 80 00 3f be 4000f004 <writev+0x104>
<== NOT EXECUTED
4000ef0c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
if ( iovcnt <= 0 )
4000ef10: 04 80 00 3d ble 4000f004 <writev+0x104>
<== NOT EXECUTED
4000ef14: 80 a6 a4 00 cmp %i2, 0x400
<== NOT EXECUTED
if ( iovcnt > IOV_MAX )
4000ef18: 14 80 00 3b bg 4000f004 <writev+0x104>
<== NOT EXECUTED
4000ef1c: bb 2e a0 03 sll %i2, 3, %i5
<== NOT EXECUTED
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
4000ef20: 09 1f ff ff sethi %hi(0x7ffffc00), %g4
<== NOT EXECUTED
4000ef24: 82 10 00 19 mov %i1, %g1
<== NOT EXECUTED
4000ef28: ba 07 40 19 add %i5, %i1, %i5
<== NOT EXECUTED
total = 0;
4000ef2c: 96 10 20 00 clr %o3
<== NOT EXECUTED
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
4000ef30: 88 11 23 ff or %g4, 0x3ff, %g4
<== NOT EXECUTED
size_t len = iov[ v ].iov_len;
4000ef34: c4 00 60 04 ld [ %g1 + 4 ], %g2
<== NOT EXECUTED
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
4000ef38: 86 21 00 0b sub %g4, %o3, %g3
<== NOT EXECUTED
4000ef3c: 80 a0 80 03 cmp %g2, %g3
<== NOT EXECUTED
4000ef40: 18 80 00 31 bgu 4000f004 <writev+0x104>
<== NOT EXECUTED
4000ef44: 01 00 00 00 nop
<== NOT EXECUTED
if ( iov[ v ].iov_base == NULL && len != 0 ) {
4000ef48: c6 00 40 00 ld [ %g1 ], %g3
<== NOT EXECUTED
4000ef4c: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4000ef50: 12 80 00 05 bne 4000ef64 <writev+0x64>
<== NOT EXECUTED
4000ef54: 96 02 c0 02 add %o3, %g2, %o3
<== NOT EXECUTED
4000ef58: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000ef5c: 12 80 00 2a bne 4000f004 <writev+0x104>
<== NOT EXECUTED
4000ef60: 01 00 00 00 nop
<== NOT EXECUTED
4000ef64: 82 00 60 08 add %g1, 8, %g1
<== NOT EXECUTED
for ( v = 0 ; v < iovcnt ; ++v ) {
4000ef68: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
4000ef6c: 32 bf ff f3 bne,a 4000ef38 <writev+0x38>
<== NOT EXECUTED
4000ef70: c4 00 60 04 ld [ %g1 + 4 ], %g2
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
4000ef74: 03 10 01 53 sethi %hi(0x40054c00), %g1
<== NOT EXECUTED
4000ef78: c2 00 61 48 ld [ %g1 + 0x148 ], %g1 ! 40054d48 <rtems_libio_number_iops>
<== NOT EXECUTED
4000ef7c: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
4000ef80: 1a 80 00 2e bcc 4000f038 <writev+0x138>
<== NOT EXECUTED
4000ef84: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
4000ef88: 03 10 01 84 sethi %hi(0x40061000), %g1
<== NOT EXECUTED
4000ef8c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
4000ef90: 82 10 62 c0 or %g1, 0x2c0, %g1
<== NOT EXECUTED
4000ef94: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
4000ef98: ba 07 40 01 add %i5, %g1, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ef9c: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000efa0: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4000efa4: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4000efa8: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000efac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000efb0: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
4000efb4: 84 08 a1 04 and %g2, 0x104, %g2
<== NOT EXECUTED
4000efb8: 80 a0 a1 04 cmp %g2, 0x104
<== NOT EXECUTED
4000efbc: 12 80 00 19 bne 4000f020 <writev+0x120>
<== NOT EXECUTED
4000efc0: 80 a2 e0 00 cmp %o3, 0
<== NOT EXECUTED
if ( total > 0 ) {
4000efc4: 04 80 00 08 ble 4000efe4 <writev+0xe4>
<== NOT EXECUTED
4000efc8: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
return ( *iop->pathinfo.handlers->writev_h )( iop, iov, iovcnt, total );
4000efcc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000efd0: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
<== NOT EXECUTED
4000efd4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000efd8: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000efdc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000efe0: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000efe4: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000efe8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000efec: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000eff0: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000eff4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000eff8: 01 00 00 00 nop
<== NOT EXECUTED
iov,
iovcnt,
LIBIO_FLAGS_WRITE,
writev_adapter
);
}
4000effc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f000: 91 e8 00 0b restore %g0, %o3, %o0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
4000f004: 40 00 ac db call 4003a370 <__errno>
<== NOT EXECUTED
4000f008: 01 00 00 00 nop
<== NOT EXECUTED
4000f00c: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
4000f010: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000f014: 96 10 3f ff mov -1, %o3
<== NOT EXECUTED
4000f018: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f01c: 91 e8 00 0b restore %g0, %o3, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f020: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000f024: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000f028: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000f02c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f030: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f034: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
4000f038: 40 00 ac ce call 4003a370 <__errno>
<== NOT EXECUTED
4000f03c: 01 00 00 00 nop
<== NOT EXECUTED
4000f040: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
4000f044: 96 10 3f ff mov -1, %o3
<== NOT EXECUTED
4000f048: 10 bf ff f4 b 4000f018 <writev+0x118>
<== NOT EXECUTED
4000f04c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED