RTEMS-5
Annotated Report
Fri Aug 10 13:14:56 2018
40004c40 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
40004c40: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
if ( !rtems_configuration_get_unified_work_area() ) {
40004c44: 03 10 00 5c sethi %hi(0x40017000), %g1
40004c48: c2 08 62 39 ldub [ %g1 + 0x239 ], %g1 ! 40017239 <Configuration+0x31>
40004c4c: 80 a0 60 00 cmp %g1, 0
40004c50: 12 80 00 19 bne 40004cb4 <RTEMS_Malloc_Initialize+0x74>
40004c54: 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) {
40004c58: 02 80 00 19 be 40004cbc <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
40004c5c: 03 10 00 65 sethi %hi(0x40019400), %g1
Heap_Control *heap = RTEMS_Malloc_Heap;
40004c60: f8 00 60 84 ld [ %g1 + 0x84 ], %i4 ! 40019484 <RTEMS_Malloc_Heap>
40004c64: b3 2e 60 03 sll %i1, 3, %i1
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
40004c68: 37 10 00 1d sethi %hi(0x40007400), %i3
40004c6c: b2 06 00 19 add %i0, %i1, %i1
40004c70: b6 16 e2 7c or %i3, 0x27c, %i3
40004c74: ba 10 00 1b mov %i3, %i5
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
40004c78: d4 06 20 04 ld [ %i0 + 4 ], %o2
40004c7c: d2 06 00 00 ld [ %i0 ], %o1
40004c80: 96 10 20 08 mov 8, %o3
40004c84: 9f c7 40 00 call %i5
40004c88: 90 10 00 1c mov %i4, %o0
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
40004c8c: 80 a2 20 00 cmp %o0, 0
40004c90: 32 80 00 02 bne,a 40004c98 <RTEMS_Malloc_Initialize+0x58>
<== ALWAYS TAKEN
40004c94: ba 10 00 1a mov %i2, %i5
40004c98: b0 06 20 08 add %i0, 8, %i0
for (i = 0; i < area_count; ++i) {
40004c9c: 80 a6 00 19 cmp %i0, %i1
40004ca0: 32 bf ff f7 bne,a 40004c7c <RTEMS_Malloc_Initialize+0x3c>
<== NEVER TAKEN
40004ca4: d4 06 20 04 ld [ %i0 + 4 ], %o2
<== NOT EXECUTED
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
40004ca8: 80 a7 40 1b cmp %i5, %i3
40004cac: 02 80 00 04 be 40004cbc <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
40004cb0: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
}
}
}
40004cb4: 81 c7 e0 08 ret
40004cb8: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
40004cbc: 40 00 0b 39 call 400079a0 <_Internal_error>
<== NOT EXECUTED
40004cc0: 90 10 20 17 mov 0x17, %o0
<== NOT EXECUTED
40004cc4: 01 00 00 00 nop
<== NOT EXECUTED
40004844 <_Console_simple_Read>:
ssize_t _Console_simple_Read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
40004844: 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 ) {
40004848: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000484c: 04 80 00 0c ble 4000487c <_Console_simple_Read+0x38>
<== NOT EXECUTED
40004850: ba 10 20 00 clr %i5
<== NOT EXECUTED
int c;
do {
c = getchark();
40004854: 40 00 00 22 call 400048dc <getchark>
<== NOT EXECUTED
40004858: 01 00 00 00 nop
<== NOT EXECUTED
} while (c == -1);
4000485c: 80 a2 3f ff cmp %o0, -1
<== NOT EXECUTED
40004860: 02 bf ff fd be 40004854 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004864: 01 00 00 00 nop
<== NOT EXECUTED
buf[ i ] = (char) c;
40004868: d0 2e 40 1d stb %o0, [ %i1 + %i5 ]
<== NOT EXECUTED
for ( i = 0; i < n; ++i ) {
4000486c: ba 07 60 01 inc %i5
<== NOT EXECUTED
40004870: 80 a6 80 1d cmp %i2, %i5
<== NOT EXECUTED
40004874: 12 bf ff f8 bne 40004854 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004878: 01 00 00 00 nop
<== NOT EXECUTED
}
return n;
}
4000487c: 81 c7 e0 08 ret
<== NOT EXECUTED
40004880: 91 e8 00 1a restore %g0, %i2, %o0
<== NOT EXECUTED
40004c0c <_Malloc_Deferred_free>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004c0c: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
40004c10: 05 10 00 65 sethi %hi(0x40019400), %g2
<== NOT EXECUTED
40004c14: 84 10 a0 b0 or %g2, 0xb0, %g2 ! 400194b0 <_Malloc_GC_list>
<== NOT EXECUTED
40004c18: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
40004c1c: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
40004c20: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40004c24: d0 20 a0 08 st %o0, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
40004c28: d0 20 c0 00 st %o0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40004c2c: c6 22 20 04 st %g3, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004c30: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004c34: 01 00 00 00 nop
<== NOT EXECUTED
rtems_interrupt_lock_acquire( &_Malloc_GC_lock, &lock_context );
rtems_chain_initialize_node( node );
rtems_chain_append_unprotected( &_Malloc_GC_list, node );
rtems_interrupt_lock_release( &_Malloc_GC_lock, &lock_context );
}
40004c38: 81 c3 e0 08 retl
<== NOT EXECUTED
40004c3c: 01 00 00 00 nop
<== NOT EXECUTED
40004ac0 <_Malloc_Process_deferred_frees>:
return p;
}
void _Malloc_Process_deferred_frees( void )
{
40004ac0: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004ac4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40004ac8: 3b 10 00 65 sethi %hi(0x40019400), %i5
40004acc: d0 07 60 b0 ld [ %i5 + 0xb0 ], %o0 ! 400194b0 <_Malloc_GC_list>
40004ad0: ba 17 60 b0 or %i5, 0xb0, %i5
if ( !_Chain_Is_empty(the_chain))
40004ad4: b8 07 60 04 add %i5, 4, %i4
40004ad8: 80 a2 00 1c cmp %o0, %i4
40004adc: 02 80 00 0e be 40004b14 <_Malloc_Process_deferred_frees+0x54>
<== ALWAYS TAKEN
40004ae0: 01 00 00 00 nop
new_first = old_first->next;
40004ae4: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
head->next = new_first;
40004ae8: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
new_first->previous = head;
40004aec: fa 20 a0 04 st %i5, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004af0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004af4: 01 00 00 00 nop
<== NOT EXECUTED
/*
* If some free's have been deferred, then do them now.
*/
while ( ( to_be_freed = _Malloc_Get_deferred_free() ) != NULL ) {
free( to_be_freed );
40004af8: 7f ff ff 63 call 40004884 <free>
<== NOT EXECUTED
40004afc: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004b00: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40004b04: d0 07 40 00 ld [ %i5 ], %o0
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
40004b08: 80 a2 00 1c cmp %o0, %i4
<== NOT EXECUTED
40004b0c: 32 bf ff f7 bne,a 40004ae8 <_Malloc_Process_deferred_frees+0x28>
<== NOT EXECUTED
40004b10: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004b14: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004b18: 01 00 00 00 nop
}
}
40004b1c: 81 c7 e0 08 ret
40004b20: 81 e8 00 00 restore
40004a84 <_Malloc_System_state>:
40004a84: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40004a88: c2 00 61 c4 ld [ %g1 + 0x1c4 ], %g1 ! 4001adc4 <_System_state_Current>
if ( _Thread_Dispatch_is_enabled() ) {
return MALLOC_SYSTEM_STATE_NORMAL;
} else {
return MALLOC_SYSTEM_STATE_NO_ALLOCATION;
}
} else if ( _System_state_Is_before_multitasking( state ) ) {
40004a8c: 84 18 60 01 xor %g1, 1, %g2
return MALLOC_SYSTEM_STATE_NORMAL;
} else {
return MALLOC_SYSTEM_STATE_NO_PROTECTION;
40004a90: 80 a0 00 02 cmp %g0, %g2
40004a94: 90 40 20 00 addx %g0, 0, %o0
if ( _System_state_Is_up( state ) ) {
40004a98: 80 a0 60 02 cmp %g1, 2
40004a9c: 02 80 00 04 be 40004aac <_Malloc_System_state+0x28>
<== ALWAYS TAKEN
40004aa0: 01 00 00 00 nop
}
}
40004aa4: 81 c3 e0 08 retl
<== NOT EXECUTED
40004aa8: 01 00 00 00 nop
<== NOT EXECUTED
ISR_Level level;
_ISR_Local_disable( level );
#endif
enabled = _Thread_Dispatch_disable_level == 0;
40004aac: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
return MALLOC_SYSTEM_STATE_NO_ALLOCATION;
40004ab0: 80 a0 00 01 cmp %g0, %g1
40004ab4: 90 40 20 00 addx %g0, 0, %o0
}
40004ab8: 81 c3 e0 08 retl
40004abc: 91 2a 20 01 sll %o0, 1, %o0
40003f00 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
40003f00: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
rtems_assert_context assert_context = {
40003f04: 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",
40003f08: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
rtems_assert_context assert_context = {
40003f0c: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
40003f10: 02 80 00 0e be 40003f48 <__assert_func+0x48>
<== NOT EXECUTED
40003f14: f4 3f bf f8 std %i2, [ %fp + -8 ]
<== NOT EXECUTED
40003f18: 19 10 00 3e sethi %hi(0x4000f800), %o4
<== NOT EXECUTED
40003f1c: 98 13 22 b8 or %o4, 0x2b8, %o4 ! 4000fab8 <IMFS_node_control_sym_link+0x14>
<== NOT EXECUTED
40003f20: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40003f24: 9a 10 00 1a mov %i2, %o5
<== NOT EXECUTED
40003f28: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
40003f2c: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40003f30: 11 10 00 3e sethi %hi(0x4000f800), %o0
<== NOT EXECUTED
40003f34: 40 00 03 41 call 40004c38 <printk>
<== NOT EXECUTED
40003f38: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 4000fac8 <IMFS_node_control_sym_link+0x24>
<== NOT EXECUTED
40003f3c: 92 07 bf f0 add %fp, -16, %o1
<== NOT EXECUTED
40003f40: 40 00 0c d4 call 40007290 <_Terminate>
<== NOT EXECUTED
40003f44: 90 10 20 07 mov 7, %o0
<== NOT EXECUTED
40003f48: 19 10 00 3e sethi %hi(0x4000f800), %o4
<== NOT EXECUTED
40003f4c: 98 13 20 f8 or %o4, 0xf8, %o4 ! 4000f8f8 <__func__.3761+0xf8>
<== NOT EXECUTED
40003f50: 10 bf ff f4 b 40003f20 <__assert_func+0x20>
<== NOT EXECUTED
40003f54: b4 10 00 0c mov %o4, %i2
<== NOT EXECUTED
40016a34 <_calloc_r>:
void *_calloc_r(
struct _reent *ignored,
size_t elements,
size_t size
)
{
40016a34: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
(void) ignored;
return calloc( elements, size );
40016a38: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
40016a3c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40016a40: 7f ff b7 46 call 40004758 <calloc>
<== NOT EXECUTED
40016a44: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40018994 <_exit>:
extern void FINI_SYMBOL( void );
#endif
void _exit(int status)
{
40018994: 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();
40018998: 40 00 06 66 call 4001a330 <_fini>
4001899c: 01 00 00 00 nop
#endif
rtems_shutdown_executive(status);
400189a0: 7f ff da f9 call 4000f584 <rtems_shutdown_executive>
400189a4: 90 10 00 18 mov %i0, %o0
400189a8: 01 00 00 00 nop
<== NOT EXECUTED
4000497c <_gettimeofday_r>:
int _gettimeofday_r(
struct _reent *ignored_reentrancy_stuff RTEMS_UNUSED,
struct timeval *tp,
void *__tz
)
{
4000497c: 9d e3 bf a0 save %sp, -96, %sp
if ( !tp )
40004980: 80 a6 60 00 cmp %i1, 0
40004984: 02 80 00 06 be 4000499c <_gettimeofday_r+0x20>
<== NEVER TAKEN
40004988: 90 10 00 19 mov %i1, %o0
4000498c: 40 00 10 53 call 40008ad8 <_Timecounter_Microtime>
40004990: b0 10 20 00 clr %i0
struct timezone *tzp = __tz;
return gettimeofday( tp, tzp );
}
40004994: 81 c7 e0 08 ret
40004998: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EFAULT );
4000499c: 40 00 29 73 call 4000ef68 <__errno>
<== NOT EXECUTED
400049a0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400049a4: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
400049a8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400049ac: 81 c7 e0 08 ret
<== NOT EXECUTED
400049b0: 81 e8 00 00 restore
<== NOT EXECUTED
40005cc0 <_libcsupport_scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
40005cc0: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
40005cc4: 98 10 20 00 clr %o4
{
40005cc8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
40005ccc: 96 07 a0 50 add %fp, 0x50, %o3
{
40005cd0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
40005cd4: 94 07 a0 4c add %fp, 0x4c, %o2
40005cd8: 92 10 00 19 mov %i1, %o1
40005cdc: 7f ff ff 34 call 400059ac <scanString>
40005ce0: 90 10 00 18 mov %i0, %o0
40005ce4: 80 a2 20 00 cmp %o0, 0
40005ce8: 12 80 00 04 bne 40005cf8 <_libcsupport_scangr+0x38>
40005cec: 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;
40005cf0: 81 c7 e0 08 ret
40005cf4: 91 e8 20 00 restore %g0, 0, %o0
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
40005cf8: 96 07 a0 50 add %fp, 0x50, %o3
40005cfc: 94 07 a0 4c add %fp, 0x4c, %o2
40005d00: 92 06 60 04 add %i1, 4, %o1
40005d04: 7f ff ff 2a call 400059ac <scanString>
40005d08: 90 10 00 18 mov %i0, %o0
40005d0c: 80 a2 20 00 cmp %o0, 0
40005d10: 02 bf ff f8 be 40005cf0 <_libcsupport_scangr+0x30>
<== NEVER TAKEN
40005d14: 92 07 bf f8 add %fp, -8, %o1
|| !scanInt(fp, &grgid)
40005d18: 7f ff fe ec call 400058c8 <scanInt>
40005d1c: 90 10 00 18 mov %i0, %o0
40005d20: 80 a2 20 00 cmp %o0, 0
40005d24: 02 bf ff f3 be 40005cf0 <_libcsupport_scangr+0x30>
<== NEVER TAKEN
40005d28: 98 10 20 01 mov 1, %o4
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
40005d2c: 96 07 a0 50 add %fp, 0x50, %o3
40005d30: 94 07 a0 4c add %fp, 0x4c, %o2
40005d34: 92 07 bf fc add %fp, -4, %o1
40005d38: 7f ff ff 1d call 400059ac <scanString>
40005d3c: 90 10 00 18 mov %i0, %o0
40005d40: 80 a2 20 00 cmp %o0, 0
40005d44: 02 bf ff eb be 40005cf0 <_libcsupport_scangr+0x30>
<== NEVER TAKEN
40005d48: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
40005d4c: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
if (grmem[0] == '\0') {
40005d50: fa 07 bf fc ld [ %fp + -4 ], %i5
40005d54: c2 0f 40 00 ldub [ %i5 ], %g1
40005d58: 83 28 60 18 sll %g1, 0x18, %g1
40005d5c: 80 a0 60 00 cmp %g1, 0
40005d60: 02 80 00 13 be 40005dac <_libcsupport_scangr+0xec>
40005d64: 84 10 20 13 mov 0x13, %g2
40005d68: 84 10 00 1d mov %i5, %g2
memcount = 0;
} else {
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40005d6c: 88 10 20 01 mov 1, %g4
if(*cp == ',')
40005d70: 83 38 60 18 sra %g1, 0x18, %g1
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40005d74: 84 00 a0 01 inc %g2
if(*cp == ',')
40005d78: 80 a0 60 2c cmp %g1, 0x2c
40005d7c: 12 80 00 05 bne 40005d90 <_libcsupport_scangr+0xd0>
40005d80: 86 01 20 01 add %g4, 1, %g3
40005d84: 82 01 20 02 add %g4, 2, %g1
memcount++;
40005d88: 88 10 00 03 mov %g3, %g4
if(*cp == ',')
40005d8c: 86 10 00 01 mov %g1, %g3
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40005d90: c2 08 80 00 ldub [ %g2 ], %g1
40005d94: 83 28 60 18 sll %g1, 0x18, %g1
40005d98: 80 a0 60 00 cmp %g1, 0
40005d9c: 12 bf ff f6 bne 40005d74 <_libcsupport_scangr+0xb4>
40005da0: 83 38 60 18 sra %g1, 0x18, %g1
40005da4: 85 28 e0 02 sll %g3, 2, %g2
40005da8: 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))
40005dac: c2 07 a0 50 ld [ %fp + 0x50 ], %g1
40005db0: 80 a0 40 02 cmp %g1, %g2
40005db4: 0a bf ff cf bcs 40005cf0 <_libcsupport_scangr+0x30>
<== NEVER TAKEN
40005db8: c6 07 a0 4c ld [ %fp + 0x4c ], %g3
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
40005dbc: 86 00 e0 0f add %g3, 0xf, %g3
40005dc0: 86 08 ff f0 and %g3, -16, %g3
40005dc4: c6 26 60 0c st %g3, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
if (grmem[0] == '\0') {
40005dc8: c2 4f 40 00 ldsb [ %i5 ], %g1
40005dcc: 80 a0 60 00 cmp %g1, 0
40005dd0: 02 80 00 1a be 40005e38 <_libcsupport_scangr+0x178>
40005dd4: 88 10 20 00 clr %g4
memcount = 0;
} else {
grp->gr_mem[0] = grmem;
40005dd8: fa 20 c0 00 st %i5, [ %g3 ]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40005ddc: c4 07 bf fc ld [ %fp + -4 ], %g2
40005de0: c2 08 80 00 ldub [ %g2 ], %g1
40005de4: 83 28 60 18 sll %g1, 0x18, %g1
40005de8: 80 a0 60 00 cmp %g1, 0
40005dec: 02 80 00 13 be 40005e38 <_libcsupport_scangr+0x178>
<== NEVER TAKEN
40005df0: 88 10 20 04 mov 4, %g4
40005df4: 86 10 20 01 mov 1, %g3
if(*cp == ',') {
40005df8: 83 38 60 18 sra %g1, 0x18, %g1
40005dfc: 89 28 e0 02 sll %g3, 2, %g4
40005e00: 80 a0 60 2c cmp %g1, 0x2c
40005e04: 12 80 00 07 bne 40005e20 <_libcsupport_scangr+0x160>
40005e08: 84 00 a0 01 inc %g2
*cp = '\0';
40005e0c: c0 28 bf ff clrb [ %g2 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
40005e10: 86 00 e0 01 inc %g3
40005e14: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40005e18: c4 20 40 04 st %g2, [ %g1 + %g4 ]
40005e1c: 88 01 20 04 add %g4, 4, %g4
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
40005e20: c2 08 80 00 ldub [ %g2 ], %g1
40005e24: 83 28 60 18 sll %g1, 0x18, %g1
40005e28: 80 a0 60 00 cmp %g1, 0
40005e2c: 32 bf ff f4 bne,a 40005dfc <_libcsupport_scangr+0x13c>
40005e30: 83 38 60 18 sra %g1, 0x18, %g1
40005e34: c6 06 60 0c ld [ %i1 + 0xc ], %g3
}
}
}
grp->gr_mem[memcount] = NULL;
40005e38: c0 20 c0 04 clr [ %g3 + %g4 ]
return 1;
}
40005e3c: 81 c7 e0 08 ret
40005e40: 91 e8 20 01 restore %g0, 1, %o0
40005a48 <_libcsupport_scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
40005a48: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40005a4c: 98 10 20 00 clr %o4
{
40005a50: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40005a54: 96 07 a0 50 add %fp, 0x50, %o3
{
40005a58: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
40005a5c: 94 07 a0 4c add %fp, 0x4c, %o2
40005a60: 92 10 00 19 mov %i1, %o1
40005a64: 7f ff ff cc call 40005994 <scanString>
40005a68: 90 10 00 18 mov %i0, %o0
40005a6c: 80 a2 20 00 cmp %o0, 0
40005a70: 12 80 00 04 bne 40005a80 <_libcsupport_scanpw+0x38>
40005a74: 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;
40005a78: 81 c7 e0 08 ret
40005a7c: 91 e8 20 00 restore %g0, 0, %o0
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
40005a80: 96 07 a0 50 add %fp, 0x50, %o3
40005a84: 94 07 a0 4c add %fp, 0x4c, %o2
40005a88: 92 06 60 04 add %i1, 4, %o1
40005a8c: 7f ff ff c2 call 40005994 <scanString>
40005a90: 90 10 00 18 mov %i0, %o0
40005a94: 80 a2 20 00 cmp %o0, 0
40005a98: 02 bf ff f8 be 40005a78 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40005a9c: 92 07 bf f8 add %fp, -8, %o1
|| !scanInt(fp, &pwuid)
40005aa0: 7f ff ff 84 call 400058b0 <scanInt>
40005aa4: 90 10 00 18 mov %i0, %o0
40005aa8: 80 a2 20 00 cmp %o0, 0
40005aac: 02 bf ff f3 be 40005a78 <_libcsupport_scanpw+0x30>
40005ab0: 92 07 bf fc add %fp, -4, %o1
|| !scanInt(fp, &pwgid)
40005ab4: 7f ff ff 7f call 400058b0 <scanInt>
40005ab8: 90 10 00 18 mov %i0, %o0
40005abc: 80 a2 20 00 cmp %o0, 0
40005ac0: 02 bf ff ee be 40005a78 <_libcsupport_scanpw+0x30>
40005ac4: 98 10 20 00 clr %o4
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
40005ac8: 96 07 a0 50 add %fp, 0x50, %o3
40005acc: 94 07 a0 4c add %fp, 0x4c, %o2
40005ad0: 92 06 60 0c add %i1, 0xc, %o1
40005ad4: 7f ff ff b0 call 40005994 <scanString>
40005ad8: 90 10 00 18 mov %i0, %o0
40005adc: 80 a2 20 00 cmp %o0, 0
40005ae0: 02 bf ff e6 be 40005a78 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40005ae4: 98 10 20 00 clr %o4
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
40005ae8: 96 07 a0 50 add %fp, 0x50, %o3
40005aec: 94 07 a0 4c add %fp, 0x4c, %o2
40005af0: 92 06 60 10 add %i1, 0x10, %o1
40005af4: 7f ff ff a8 call 40005994 <scanString>
40005af8: 90 10 00 18 mov %i0, %o0
40005afc: 80 a2 20 00 cmp %o0, 0
40005b00: 02 bf ff de be 40005a78 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40005b04: 98 10 20 00 clr %o4
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
40005b08: 96 07 a0 50 add %fp, 0x50, %o3
40005b0c: 94 07 a0 4c add %fp, 0x4c, %o2
40005b10: 92 06 60 14 add %i1, 0x14, %o1
40005b14: 7f ff ff a0 call 40005994 <scanString>
40005b18: 90 10 00 18 mov %i0, %o0
40005b1c: 80 a2 20 00 cmp %o0, 0
40005b20: 02 bf ff d6 be 40005a78 <_libcsupport_scanpw+0x30>
<== NEVER TAKEN
40005b24: 98 10 20 01 mov 1, %o4
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
40005b28: 96 07 a0 50 add %fp, 0x50, %o3
40005b2c: 94 07 a0 4c add %fp, 0x4c, %o2
40005b30: 92 06 60 18 add %i1, 0x18, %o1
40005b34: 7f ff ff 98 call 40005994 <scanString>
40005b38: 90 10 00 18 mov %i0, %o0
40005b3c: 80 a2 20 00 cmp %o0, 0
40005b40: 02 bf ff ce be 40005a78 <_libcsupport_scanpw+0x30>
40005b44: c2 07 bf f8 ld [ %fp + -8 ], %g1
pwd->pw_uid = pwuid;
40005b48: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
40005b4c: c2 07 bf fc ld [ %fp + -4 ], %g1
40005b50: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
40005b54: 81 c7 e0 08 ret
40005b58: 91 e8 20 01 restore %g0, 1, %o0
40016a68 <_realloc_r>:
void *_realloc_r(
struct _reent *ignored,
void *ptr,
size_t size
)
{
40016a68: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
(void) ignored;
return realloc( ptr, size );
40016a6c: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
40016a70: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40016a74: 40 00 00 14 call 40016ac4 <realloc>
<== NOT EXECUTED
40016a78: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000408c <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
4000408c: 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(
40004090: 40 00 28 1b call 4000e0fc <strlen>
40004094: 90 10 00 18 mov %i0, %o0
40004098: 96 10 20 19 mov 0x19, %o3
4000409c: 94 10 00 08 mov %o0, %o2
400040a0: 92 10 00 18 mov %i0, %o1
400040a4: 90 07 bf 68 add %fp, -152, %o0
400040a8: 1b 10 00 43 sethi %hi(0x40010c00), %o5
400040ac: 9a 13 61 50 or %o5, 0x150, %o5 ! 40010d50 <rtems_global_user_env>
400040b0: 40 00 05 bc call 400057a0 <rtems_filesystem_eval_path_start_with_root_and_current>
400040b4: 98 03 60 04 add %o5, 4, %o4
rtems_filesystem_location_copy_and_detach(
400040b8: 92 07 bf 80 add %fp, -128, %o1
400040bc: 40 00 07 65 call 40005e50 <rtems_filesystem_location_copy_and_detach>
400040c0: 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 );
400040c4: 40 00 07 8e call 40005efc <rtems_filesystem_location_transform_to_global>
400040c8: 90 07 bf 50 add %fp, -176, %o0
400040cc: d0 27 bf 4c st %o0, [ %fp + -180 ]
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
400040d0: 3b 10 00 3d sethi %hi(0x4000f400), %i5
400040d4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
400040d8: ba 17 63 88 or %i5, 0x388, %i5
400040dc: 80 a0 40 1d cmp %g1, %i5
400040e0: 02 80 00 3c be 400041d0 <chroot+0x144>
400040e4: 01 00 00 00 nop
rtems_filesystem_global_location_t *new_root_loc =
400040e8: 40 00 06 db call 40005c54 <rtems_filesystem_global_location_obtain>
400040ec: 90 07 bf 4c add %fp, -180, %o0
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
400040f0: c0 27 bf ac clr [ %fp + -84 ]
400040f4: b8 10 00 08 mov %o0, %i4
(void) ( *loc->handlers->fstat_h )( loc, &st );
400040f8: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
400040fc: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40004100: 9f c0 40 00 call %g1
40004104: 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 ) ) {
40004108: 05 00 00 3c sethi %hi(0xf000), %g2
4000410c: c2 07 bf ac ld [ %fp + -84 ], %g1
40004110: 82 08 40 02 and %g1, %g2, %g1
40004114: 05 00 00 10 sethi %hi(0x4000), %g2
40004118: 80 a0 40 02 cmp %g1, %g2
4000411c: 32 80 00 14 bne,a 4000416c <chroot+0xe0>
40004120: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
sc = rtems_libio_set_private_env();
40004124: 40 00 03 e0 call 400050a4 <rtems_libio_set_private_env>
40004128: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
4000412c: 80 a2 20 00 cmp %o0, 0
40004130: 12 80 00 21 bne 400041b4 <chroot+0x128>
40004134: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
&rtems_filesystem_root,
40004138: 40 00 03 c6 call 40005050 <rtems_current_user_env_get>
4000413c: b0 10 20 00 clr %i0
rtems_filesystem_global_location_assign(
40004140: 92 10 00 1c mov %i4, %o1
40004144: 40 00 07 18 call 40005da4 <rtems_filesystem_global_location_assign>
40004148: 90 02 20 04 add %o0, 4, %o0
new_root_loc
);
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
4000414c: 40 00 03 c1 call 40005050 <rtems_current_user_env_get>
40004150: 01 00 00 00 nop
rtems_filesystem_global_location_assign(
40004154: 40 00 07 14 call 40005da4 <rtems_filesystem_global_location_assign>
40004158: d2 07 bf 4c ld [ %fp + -180 ], %o1
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
4000415c: 40 00 05 f3 call 40005928 <rtems_filesystem_eval_path_cleanup>
40004160: 90 07 bf 68 add %fp, -152, %o0
40004164: 81 c7 e0 08 ret
40004168: 81 e8 00 00 restore
if ( !rtems_filesystem_location_is_null( loc ) ) {
4000416c: 80 a0 40 1d cmp %g1, %i5
40004170: 22 80 00 07 be,a 4000418c <chroot+0x100>
<== NEVER TAKEN
40004174: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
errno = eno;
40004178: 40 00 26 91 call 4000dbbc <__errno>
4000417c: 01 00 00 00 nop
40004180: 82 10 20 14 mov 0x14, %g1 ! 14 <_TLS_Alignment+0x13>
40004184: c2 22 00 00 st %g1, [ %o0 ]
rtems_filesystem_global_location_release( new_root_loc, true );
40004188: 90 10 00 1c mov %i4, %o0
4000418c: 40 00 06 ec call 40005d3c <rtems_filesystem_global_location_release>
40004190: 92 10 20 01 mov 1, %o1
rtems_filesystem_eval_path_cleanup( &ctx );
40004194: 40 00 05 e5 call 40005928 <rtems_filesystem_eval_path_cleanup>
40004198: 90 07 bf 68 add %fp, -152, %o0
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc, false );
4000419c: d0 07 bf 4c ld [ %fp + -180 ], %o0
400041a0: 92 10 20 00 clr %o1
400041a4: 40 00 06 e6 call 40005d3c <rtems_filesystem_global_location_release>
400041a8: b0 10 3f ff mov -1, %i0
}
return rv;
}
400041ac: 81 c7 e0 08 ret
400041b0: 81 e8 00 00 restore
if (sc != RTEMS_UNSATISFIED) {
400041b4: 22 bf ff f6 be,a 4000418c <chroot+0x100>
<== NEVER TAKEN
400041b8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
errno = ENOMEM;
400041bc: 40 00 26 80 call 4000dbbc <__errno>
400041c0: 01 00 00 00 nop
400041c4: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
400041c8: 10 bf ff f0 b 40004188 <chroot+0xfc>
400041cc: c2 22 00 00 st %g1, [ %o0 ]
rtems_filesystem_eval_path_cleanup( &ctx );
400041d0: 40 00 05 d6 call 40005928 <rtems_filesystem_eval_path_cleanup>
400041d4: 90 07 bf 68 add %fp, -152, %o0
rtems_filesystem_global_location_release( new_current_loc, false );
400041d8: 10 bf ff f2 b 400041a0 <chroot+0x114>
400041dc: d0 07 bf 4c ld [ %fp + -180 ], %o0
4000ee4c <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
4000ee4c: 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 ) {
4000ee50: 03 10 00 5c sethi %hi(0x40017000), %g1
4000ee54: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 400173d0 <rtems_libio_number_iops>
4000ee58: 80 a6 00 01 cmp %i0, %g1
4000ee5c: 1a 80 00 1b bcc 4000eec8 <close+0x7c>
4000ee60: 01 00 00 00 nop
4000ee64: b7 2e 20 01 sll %i0, 1, %i3
4000ee68: b0 06 c0 18 add %i3, %i0, %i0
4000ee6c: 37 10 00 6a sethi %hi(0x4001a800), %i3
4000ee70: b9 2e 20 04 sll %i0, 4, %i4
4000ee74: b6 16 e1 98 or %i3, 0x198, %i3
4000ee78: b8 06 c0 1c add %i3, %i4, %i4
4000ee7c: c4 07 20 08 ld [ %i4 + 8 ], %g2
unsigned int actual;
(void) succ;
(void) fail;
_ISR_Local_disable( level );
actual = *obj;
4000ee80: 10 80 00 0f b 4000eebc <close+0x70>
4000ee84: ba 10 00 1c mov %i4, %i5
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ee88: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000ee8c: c6 07 60 08 ld [ %i5 + 8 ], %g3
success = ( actual == *expected );
if ( success ) {
4000ee90: 80 a1 00 03 cmp %g4, %g3
4000ee94: 12 80 00 03 bne 4000eea0 <close+0x54>
<== NEVER TAKEN
4000ee98: 84 08 ae ff and %g2, 0xeff, %g2
<== NOT EXECUTED
*obj = desired;
4000ee9c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000eea0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000eea4: 01 00 00 00 nop
desired,
ATOMIC_ORDER_ACQ_REL,
ATOMIC_ORDER_RELAXED
);
if ( success ) {
4000eea8: 80 a1 00 03 cmp %g4, %g3
4000eeac: 02 80 00 0d be 4000eee0 <close+0x94>
<== ALWAYS TAKEN
4000eeb0: 80 88 f0 00 btst -4096, %g3
break;
}
if ( ( flags & ~( LIBIO_FLAGS_REFERENCE_INC - 1U ) ) != 0 ) {
4000eeb4: 12 80 00 16 bne 4000ef0c <close+0xc0>
<== NOT EXECUTED
4000eeb8: 84 10 00 03 mov %g3, %g2
<== NOT EXECUTED
if ( ( flags & LIBIO_FLAGS_OPEN ) == 0 ) {
4000eebc: 80 88 a1 00 btst 0x100, %g2
4000eec0: 12 bf ff f2 bne 4000ee88 <close+0x3c>
4000eec4: 88 08 af ff and %g2, 0xfff, %g4
rtems_set_errno_and_return_minus_one( EBADF );
4000eec8: 40 00 00 28 call 4000ef68 <__errno>
4000eecc: b0 10 3f ff mov -1, %i0
4000eed0: 82 10 20 09 mov 9, %g1
4000eed4: c2 22 00 00 st %g1, [ %o0 ]
4000eed8: 81 c7 e0 08 ret
4000eedc: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EBUSY );
}
}
rc = (*iop->pathinfo.handlers->close_h)( iop );
4000eee0: b1 2e 20 04 sll %i0, 4, %i0
4000eee4: b6 06 c0 18 add %i3, %i0, %i3
4000eee8: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
4000eeec: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000eef0: 9f c0 40 00 call %g1
4000eef4: 90 10 00 1c mov %i4, %o0
4000eef8: b0 10 00 08 mov %o0, %i0
rtems_libio_free( iop );
4000eefc: 7f ff fb ab call 4000dda8 <rtems_libio_free>
4000ef00: 90 10 00 1c mov %i4, %o0
return rc;
}
4000ef04: 81 c7 e0 08 ret
4000ef08: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EBUSY );
4000ef0c: 40 00 00 17 call 4000ef68 <__errno>
<== NOT EXECUTED
4000ef10: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000ef14: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000ef18: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000ef1c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ef20: 81 e8 00 00 restore
<== NOT EXECUTED
40004a40 <endgrent>:
void endgrent(void)
{
40004a40: 9d e3 bf a0 save %sp, -96, %sp
grp_context *ctx = grp_get_context();
40004a44: 7f ff ff b4 call 40004914 <grp_get_context>
40004a48: 01 00 00 00 nop
if (ctx == NULL)
40004a4c: ba 92 20 00 orcc %o0, 0, %i5
40004a50: 02 80 00 0e be 40004a88 <endgrent+0x48>
40004a54: 01 00 00 00 nop
return;
if (ctx->fp != NULL) {
40004a58: d0 07 40 00 ld [ %i5 ], %o0
40004a5c: 80 a2 20 00 cmp %o0, 0
40004a60: 02 80 00 04 be 40004a70 <endgrent+0x30>
<== NEVER TAKEN
40004a64: 01 00 00 00 nop
fclose(ctx->fp);
40004a68: 40 00 2a 4a call 4000f390 <fclose>
40004a6c: 01 00 00 00 nop
}
free(ctx);
40004a70: 7f ff ff 7b call 4000485c <free>
40004a74: 90 10 00 1d mov %i5, %o0
pthread_setspecific(grp_key, NULL);
40004a78: 03 10 00 56 sethi %hi(0x40015800), %g1
<== NOT EXECUTED
40004a7c: f0 00 63 20 ld [ %g1 + 0x320 ], %i0 ! 40015b20 <grp_key>
<== NOT EXECUTED
40004a80: 40 00 09 da call 400071e8 <pthread_setspecific>
<== NOT EXECUTED
40004a84: 93 e8 20 00 restore %g0, 0, %o1
}
40004a88: 81 c7 e0 08 ret
40004a8c: 81 e8 00 00 restore
40004c2c <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
40004c2c: 03 10 00 57 sethi %hi(0x40015c00), %g1
40004c30: d0 00 60 e8 ld [ %g1 + 0xe8 ], %o0 ! 40015ce8 <passwd_fp>
40004c34: 80 a2 20 00 cmp %o0, 0
40004c38: 02 80 00 05 be 40004c4c <endpwent+0x20>
<== NEVER TAKEN
40004c3c: 01 00 00 00 nop
fclose(passwd_fp);
40004c40: 82 13 c0 00 mov %o7, %g1
40004c44: 40 00 29 d3 call 4000f390 <fclose>
40004c48: 9e 10 40 00 mov %g1, %o7
}
40004c4c: 81 c3 e0 08 retl
<== NOT EXECUTED
40004c50: 01 00 00 00 nop
<== NOT EXECUTED
40004cac <fchdir>:
/**
* compatible with SVr4, 4.4BSD and X/OPEN - Change Directory
*/
int fchdir( int fd )
{
40004cac: 9d e3 bf 28 save %sp, -216, %sp
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
40004cb0: c0 27 bf ac clr [ %fp + -84 ]
st.st_uid = 0;
st.st_gid = 0;
LIBIO_GET_IOP( fd, iop );
40004cb4: 03 10 00 42 sethi %hi(0x40010800), %g1
st.st_uid = 0;
40004cb8: c0 37 bf b2 clrh [ %fp + -78 ]
LIBIO_GET_IOP( fd, iop );
40004cbc: c2 00 63 78 ld [ %g1 + 0x378 ], %g1
40004cc0: 80 a6 00 01 cmp %i0, %g1
40004cc4: 1a 80 00 44 bcc 40004dd4 <fchdir+0x128>
40004cc8: c0 37 bf b4 clrh [ %fp + -76 ]
40004ccc: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
40004cd0: b0 07 40 18 add %i5, %i0, %i0
<== NOT EXECUTED
40004cd4: 3b 10 00 4e sethi %hi(0x40013800), %i5
<== NOT EXECUTED
40004cd8: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
40004cdc: ba 17 60 c8 or %i5, 0xc8, %i5
<== NOT EXECUTED
40004ce0: b8 06 00 1d add %i0, %i5, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004ce4: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40004ce8: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40004cec: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40004cf0: c6 27 20 08 st %g3, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004cf4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004cf8: 01 00 00 00 nop
40004cfc: 80 88 a1 00 btst 0x100, %g2
40004d00: 02 80 00 3b be 40004dec <fchdir+0x140>
40004d04: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
40004d08: b0 06 20 0c add %i0, 0xc, %i0
40004d0c: ba 06 00 1d add %i0, %i5, %i5
40004d10: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40004d14: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40004d18: c2 00 40 00 ld [ %g1 ], %g1
40004d1c: 9f c0 40 00 call %g1
40004d20: 01 00 00 00 nop
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
40004d24: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40004d28: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40004d2c: 92 07 bf a0 add %fp, -96, %o1
40004d30: 9f c0 40 00 call %g1
40004d34: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40004d38: b0 92 20 00 orcc %o0, 0, %i0
40004d3c: 02 80 00 16 be 40004d94 <fchdir+0xe8>
<== ALWAYS TAKEN
40004d40: d6 17 bf b4 lduh [ %fp + -76 ], %o3
40004d44: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40004d48: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40004d4c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40004d50: 9f c0 40 00 call %g1
40004d54: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004d58: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40004d5c: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40004d60: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40004d64: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004d68: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004d6c: 01 00 00 00 nop
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
rtems_libio_iop_drop( iop );
if ( rv == 0 ) {
40004d70: 80 a6 20 00 cmp %i0, 0
40004d74: 02 80 00 04 be 40004d84 <fchdir+0xd8>
40004d78: 01 00 00 00 nop
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
40004d7c: 81 c7 e0 08 ret
40004d80: 81 e8 00 00 restore
rv = rtems_filesystem_chdir( &loc );
40004d84: 40 00 22 b9 call 4000d868 <rtems_filesystem_chdir>
40004d88: 90 07 bf 88 add %fp, -120, %o0
}
40004d8c: 81 c7 e0 08 ret
40004d90: 91 e8 00 08 restore %g0, %o0, %o0
bool access_ok = rtems_filesystem_check_access(
40004d94: d4 17 bf b2 lduh [ %fp + -78 ], %o2
40004d98: d2 07 bf ac ld [ %fp + -84 ], %o1
40004d9c: 40 00 04 cb call 400060c8 <rtems_filesystem_check_access>
40004da0: 90 10 20 01 mov 1, %o0
if ( access_ok ) {
40004da4: 80 a2 20 00 cmp %o0, 0
40004da8: 02 80 00 06 be 40004dc0 <fchdir+0x114>
40004dac: 92 10 00 1d mov %i5, %o1
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
40004db0: 40 00 22 d3 call 4000d8fc <rtems_filesystem_location_clone>
40004db4: 90 07 bf 88 add %fp, -120, %o0
40004db8: 10 bf ff e4 b 40004d48 <fchdir+0x9c>
40004dbc: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
errno = EACCES;
40004dc0: 40 00 28 84 call 4000efd0 <__errno>
40004dc4: b0 10 3f ff mov -1, %i0
40004dc8: 82 10 20 0d mov 0xd, %g1
40004dcc: 10 bf ff de b 40004d44 <fchdir+0x98>
40004dd0: c2 22 00 00 st %g1, [ %o0 ]
LIBIO_GET_IOP( fd, iop );
40004dd4: 40 00 28 7f call 4000efd0 <__errno>
40004dd8: b0 10 3f ff mov -1, %i0
40004ddc: 82 10 20 09 mov 9, %g1
40004de0: c2 22 00 00 st %g1, [ %o0 ]
40004de4: 81 c7 e0 08 ret
40004de8: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004dec: 91 d0 20 09 ta 9
<== NOT EXECUTED
40004df0: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40004df4: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40004df8: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004dfc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004e00: 01 00 00 00 nop
40004e04: 40 00 28 73 call 4000efd0 <__errno>
40004e08: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40004e0c: 82 10 20 09 mov 9, %g1
40004e10: c2 22 00 00 st %g1, [ %o0 ]
40004e14: 81 c7 e0 08 ret
40004e18: 81 e8 00 00 restore
40004f50 <fchmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
40004f50: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
LIBIO_GET_IOP( fd, iop );
40004f54: 03 10 00 42 sethi %hi(0x40010800), %g1
40004f58: c2 00 63 78 ld [ %g1 + 0x378 ], %g1 ! 40010b78 <rtems_libio_number_iops>
40004f5c: 80 a6 00 01 cmp %i0, %g1
40004f60: 1a 80 00 28 bcc 40005000 <fchmod+0xb0>
40004f64: bb 2e 20 01 sll %i0, 1, %i5
40004f68: b0 07 40 18 add %i5, %i0, %i0
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
40004f6c: 3b 10 00 4e sethi %hi(0x40013800), %i5
<== NOT EXECUTED
40004f70: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
40004f74: ba 17 60 c8 or %i5, 0xc8, %i5
<== NOT EXECUTED
40004f78: b8 06 00 1d add %i0, %i5, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004f7c: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40004f80: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40004f84: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40004f88: c6 27 20 08 st %g3, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004f8c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004f90: 01 00 00 00 nop
40004f94: 80 88 a1 00 btst 0x100, %g2
40004f98: 02 80 00 20 be 40005018 <fchmod+0xc8>
40004f9c: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
40004fa0: b0 06 20 0c add %i0, 0xc, %i0
40004fa4: ba 06 00 1d add %i0, %i5, %i5
40004fa8: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40004fac: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40004fb0: c2 00 40 00 ld [ %g1 ], %g1
40004fb4: 9f c0 40 00 call %g1
40004fb8: 01 00 00 00 nop
rv = rtems_filesystem_chmod( &iop->pathinfo, mode );
40004fbc: 92 10 00 19 mov %i1, %o1
40004fc0: 7f ff ff 97 call 40004e1c <rtems_filesystem_chmod>
40004fc4: 90 10 00 1d mov %i5, %o0
40004fc8: b0 10 00 08 mov %o0, %i0
40004fcc: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40004fd0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40004fd4: c2 00 60 04 ld [ %g1 + 4 ], %g1
40004fd8: 9f c0 40 00 call %g1
40004fdc: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004fe0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40004fe4: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40004fe8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40004fec: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004ff0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004ff4: 01 00 00 00 nop
rtems_filesystem_instance_unlock( &iop->pathinfo );
rtems_libio_iop_drop( iop );
return rv;
}
40004ff8: 81 c7 e0 08 ret
40004ffc: 81 e8 00 00 restore
LIBIO_GET_IOP( fd, iop );
40005000: 40 00 27 f4 call 4000efd0 <__errno>
40005004: b0 10 3f ff mov -1, %i0
40005008: 82 10 20 09 mov 9, %g1
4000500c: c2 22 00 00 st %g1, [ %o0 ]
40005010: 81 c7 e0 08 ret
40005014: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005018: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000501c: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40005020: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005024: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005028: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000502c: 01 00 00 00 nop
40005030: 40 00 27 e8 call 4000efd0 <__errno>
40005034: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40005038: 82 10 20 09 mov 9, %g1
4000503c: c2 22 00 00 st %g1, [ %o0 ]
40005040: 81 c7 e0 08 ret
40005044: 81 e8 00 00 restore
40005174 <fchown>:
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
40005174: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
LIBIO_GET_IOP( fd, iop );
40005178: 03 10 00 42 sethi %hi(0x40010800), %g1
4000517c: c2 00 63 78 ld [ %g1 + 0x378 ], %g1 ! 40010b78 <rtems_libio_number_iops>
40005180: 80 a6 00 01 cmp %i0, %g1
40005184: 1a 80 00 29 bcc 40005228 <fchown+0xb4>
40005188: bb 2e 20 01 sll %i0, 1, %i5
4000518c: b0 07 40 18 add %i5, %i0, %i0
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
40005190: 3b 10 00 4e sethi %hi(0x40013800), %i5
<== NOT EXECUTED
40005194: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
40005198: ba 17 60 c8 or %i5, 0xc8, %i5
<== NOT EXECUTED
4000519c: b8 06 00 1d add %i0, %i5, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400051a0: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400051a4: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400051a8: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400051ac: c6 27 20 08 st %g3, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400051b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400051b4: 01 00 00 00 nop
400051b8: 80 88 a1 00 btst 0x100, %g2
400051bc: 02 80 00 21 be 40005240 <fchown+0xcc>
400051c0: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
400051c4: b0 06 20 0c add %i0, 0xc, %i0
400051c8: ba 06 00 1d add %i0, %i5, %i5
400051cc: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
400051d0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400051d4: c2 00 40 00 ld [ %g1 ], %g1
400051d8: 9f c0 40 00 call %g1
400051dc: 01 00 00 00 nop
rv = rtems_filesystem_chown( &iop->pathinfo, owner, group );
400051e0: 94 10 00 1a mov %i2, %o2
400051e4: 92 10 00 19 mov %i1, %o1
400051e8: 7f ff ff 98 call 40005048 <rtems_filesystem_chown>
400051ec: 90 10 00 1d mov %i5, %o0
400051f0: b0 10 00 08 mov %o0, %i0
400051f4: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
400051f8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400051fc: c2 00 60 04 ld [ %g1 + 4 ], %g1
40005200: 9f c0 40 00 call %g1
40005204: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005208: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000520c: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40005210: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005214: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005218: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000521c: 01 00 00 00 nop
rtems_filesystem_instance_unlock( &iop->pathinfo );
rtems_libio_iop_drop( iop );
return rv;
}
40005220: 81 c7 e0 08 ret
40005224: 81 e8 00 00 restore
LIBIO_GET_IOP( fd, iop );
40005228: 40 00 27 6a call 4000efd0 <__errno>
4000522c: b0 10 3f ff mov -1, %i0
40005230: 82 10 20 09 mov 9, %g1
40005234: c2 22 00 00 st %g1, [ %o0 ]
40005238: 81 c7 e0 08 ret
4000523c: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005240: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005244: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40005248: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000524c: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005250: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005254: 01 00 00 00 nop
40005258: 40 00 27 5e call 4000efd0 <__errno>
4000525c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40005260: 82 10 20 09 mov 9, %g1
40005264: c2 22 00 00 st %g1, [ %o0 ]
40005268: 81 c7 e0 08 ret
4000526c: 81 e8 00 00 restore
40004eb0 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
40004eb0: 9d e3 bf 98 save %sp, -104, %sp
int ret;
va_list ap;
va_start( ap, cmd );
40004eb4: 86 07 a0 4c add %fp, 0x4c, %g3
40004eb8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
LIBIO_GET_IOP( fd, iop );
40004ebc: 09 10 00 4d sethi %hi(0x40013400), %g4
va_start( ap, cmd );
40004ec0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40004ec4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40004ec8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
LIBIO_GET_IOP( fd, iop );
40004ecc: c2 01 22 70 ld [ %g4 + 0x270 ], %g1
40004ed0: 80 a6 00 01 cmp %i0, %g1
40004ed4: 1a 80 00 df bcc 40005250 <fcntl+0x3a0>
40004ed8: c6 27 bf fc st %g3, [ %fp + -4 ]
40004edc: 83 2e 20 01 sll %i0, 1, %g1
<== NOT EXECUTED
40004ee0: 39 10 00 59 sethi %hi(0x40016400), %i4
<== NOT EXECUTED
40004ee4: a0 00 40 18 add %g1, %i0, %l0
<== NOT EXECUTED
40004ee8: b8 17 21 f8 or %i4, 0x1f8, %i4
<== NOT EXECUTED
40004eec: b7 2c 20 04 sll %l0, 4, %i3
<== NOT EXECUTED
40004ef0: ba 07 00 1b add %i4, %i3, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004ef4: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40004ef8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40004efc: b4 20 b0 00 sub %g2, -4096, %i2
<== NOT EXECUTED
40004f00: f4 27 60 08 st %i2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004f04: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004f08: 01 00 00 00 nop
40004f0c: 80 88 a1 00 btst 0x100, %g2
40004f10: 02 80 00 d6 be 40005268 <fcntl+0x3b8>
40004f14: 80 a6 60 14 cmp %i1, 0x14
switch ( cmd ) {
40004f18: 18 80 00 b7 bgu 400051f4 <fcntl+0x344>
<== NEVER TAKEN
40004f1c: 85 2e 60 02 sll %i1, 2, %g2
40004f20: 03 10 00 13 sethi %hi(0x40004c00), %g1
40004f24: 82 10 62 5c or %g1, 0x25c, %g1 ! 40004e5c <dup+0x14>
40004f28: c2 00 40 02 ld [ %g1 + %g2 ], %g1
40004f2c: 81 c0 40 00 jmp %g1
40004f30: 01 00 00 00 nop
errno = ENOTSUP;
40004f34: 40 00 29 72 call 4000f4fc <__errno>
40004f38: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40004f3c: 82 10 20 86 mov 0x86, %g1
<== NOT EXECUTED
40004f40: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004f44: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40004f48: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40004f4c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40004f50: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004f54: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004f58: 01 00 00 00 nop
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
40004f5c: 81 c7 e0 08 ret
40004f60: 81 e8 00 00 restore
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
40004f64: 40 00 02 43 call 40005870 <rtems_libio_fcntl_flags>
40004f68: d0 00 c0 00 ld [ %g3 ], %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004f6c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val & arg;
40004f70: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40004f74: 84 08 bd fe and %g2, -514, %g2
<== NOT EXECUTED
40004f78: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004f7c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004f80: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004f84: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val | arg;
40004f88: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
rtems_libio_iop_flags_set( iop, flags & mask );
40004f8c: 90 0a 22 01 and %o0, 0x201, %o0
<== NOT EXECUTED
40004f90: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
40004f94: d0 27 60 08 st %o0, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004f98: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004f9c: 01 00 00 00 nop
int ret = 0;
40004fa0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
40004fa4: 83 2c 20 04 sll %l0, 4, %g1
40004fa8: b8 07 00 01 add %i4, %g1, %i4
40004fac: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40004fb0: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
40004fb4: 92 10 00 19 mov %i1, %o1
40004fb8: 9f c0 40 00 call %g1
40004fbc: 90 10 00 1d mov %i5, %o0
if (err) {
40004fc0: b8 92 20 00 orcc %o0, 0, %i4
40004fc4: 02 bf ff e0 be 40004f44 <fcntl+0x94>
<== ALWAYS TAKEN
40004fc8: 01 00 00 00 nop
errno = err;
40004fcc: 40 00 29 4c call 4000f4fc <__errno>
<== NOT EXECUTED
40004fd0: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40004fd4: f8 22 00 00 st %i4, [ %o0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004fd8: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40004fdc: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40004fe0: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40004fe4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004fe8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004fec: 01 00 00 00 nop
<== NOT EXECUTED
}
40004ff0: 81 c7 e0 08 ret
<== NOT EXECUTED
40004ff4: 81 e8 00 00 restore
<== NOT EXECUTED
fd2 = va_arg( ap, int );
40004ff8: e6 00 c0 00 ld [ %g3 ], %l3
if ( (uint32_t) fd2 >= rtems_libio_number_iops ) {
40004ffc: c2 01 22 70 ld [ %g4 + 0x270 ], %g1
40005000: 80 a4 c0 01 cmp %l3, %g1
40005004: 1a 80 00 a5 bcc 40005298 <fcntl+0x3e8>
<== NEVER TAKEN
40005008: b5 2c e0 01 sll %l3, 1, %i2
4000500c: b4 06 80 13 add %i2, %l3, %i2
40005010: a3 2e a0 04 sll %i2, 4, %l1
40005014: a4 07 00 11 add %i4, %l1, %l2
if (iop != iop2)
40005018: 80 a7 40 12 cmp %i5, %l2
4000501c: 02 bf ff e2 be 40004fa4 <fcntl+0xf4>
<== NEVER TAKEN
40005020: b0 10 20 00 clr %i0
40005024: c2 04 a0 08 ld [ %l2 + 8 ], %g1
if ((rtems_libio_iop_flags( iop2 ) & LIBIO_FLAGS_OPEN) != 0) {
40005028: 80 88 61 00 btst 0x100, %g1
4000502c: 22 80 00 0a be,a 40005054 <fcntl+0x1a4>
<== NEVER TAKEN
40005030: d0 07 60 08 ld [ %i5 + 8 ], %o0
<== NOT EXECUTED
rv = (*iop2->pathinfo.handlers->close_h)( iop2 );
40005034: c2 04 a0 1c ld [ %l2 + 0x1c ], %g1
40005038: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000503c: 9f c0 40 00 call %g1
40005040: 90 10 00 12 mov %l2, %o0
if (rv == 0) {
40005044: b0 92 20 00 orcc %o0, 0, %i0
40005048: 12 80 00 5d bne 400051bc <fcntl+0x30c>
<== NEVER TAKEN
4000504c: 80 a6 20 00 cmp %i0, 0
40005050: d0 07 60 08 ld [ %i5 + 8 ], %o0
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
40005054: 40 00 02 14 call 400058a4 <rtems_libio_to_fcntl_flags>
40005058: 01 00 00 00 nop
rtems_libio_iop_flags_set( iop2, rtems_libio_fcntl_flags( oflag ) );
4000505c: 40 00 02 05 call 40005870 <rtems_libio_fcntl_flags>
40005060: b0 10 00 08 mov %o0, %i0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005064: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val | arg;
40005068: c4 04 a0 08 ld [ %l2 + 8 ], %g2
<== NOT EXECUTED
4000506c: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
40005070: d0 24 a0 08 st %o0, [ %l2 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005074: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005078: 01 00 00 00 nop
4000507c: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40005080: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005084: c2 00 40 00 ld [ %g1 ], %g1
40005088: 9f c0 40 00 call %g1
4000508c: b5 2e a0 04 sll %i2, 4, %i2
rtems_filesystem_location_clone( &iop2->pathinfo, &iop->pathinfo );
40005090: 92 06 e0 0c add %i3, 0xc, %o1
40005094: 90 04 60 0c add %l1, 0xc, %o0
40005098: 92 07 00 09 add %i4, %o1, %o1
4000509c: 40 00 23 63 call 4000de28 <rtems_filesystem_location_clone>
400050a0: 90 07 00 08 add %i4, %o0, %o0
400050a4: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
400050a8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400050ac: c2 00 60 04 ld [ %g1 + 4 ], %g1
400050b0: 9f c0 40 00 call %g1
400050b4: b4 07 00 1a add %i4, %i2, %i2
rv = (*iop2->pathinfo.handlers->open_h)( iop2, NULL, oflag, 0 );
400050b8: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
400050bc: c2 00 40 00 ld [ %g1 ], %g1
400050c0: 94 10 00 18 mov %i0, %o2
400050c4: 96 10 20 00 clr %o3
400050c8: 92 10 20 00 clr %o1
400050cc: 9f c0 40 00 call %g1
400050d0: 90 10 00 12 mov %l2, %o0
if ( rv == 0 ) {
400050d4: b0 92 20 00 orcc %o0, 0, %i0
400050d8: 22 80 00 38 be,a 400051b8 <fcntl+0x308>
<== ALWAYS TAKEN
400050dc: b0 10 00 13 mov %l3, %i0
if (ret >= 0) {
400050e0: 10 80 00 37 b 400051bc <fcntl+0x30c>
<== NOT EXECUTED
400050e4: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
400050e8: d0 07 60 08 ld [ %i5 + 8 ], %o0
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
400050ec: 40 00 01 ee call 400058a4 <rtems_libio_to_fcntl_flags>
400050f0: 01 00 00 00 nop
diop = rtems_libio_allocate();
400050f4: 40 00 01 ff call 400058f0 <rtems_libio_allocate>
400050f8: a2 10 00 08 mov %o0, %l1
if (diop != NULL) {
400050fc: b4 92 20 00 orcc %o0, 0, %i2
40005100: 02 bf ff 91 be 40004f44 <fcntl+0x94>
<== NEVER TAKEN
40005104: b0 10 3f ff mov -1, %i0
40005108: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
4000510c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005110: c2 00 40 00 ld [ %g1 ], %g1
40005114: 9f c0 40 00 call %g1
40005118: 01 00 00 00 nop
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
4000511c: 90 06 a0 0c add %i2, 0xc, %o0
40005120: 92 06 e0 0c add %i3, 0xc, %o1
40005124: 40 00 23 41 call 4000de28 <rtems_filesystem_location_clone>
40005128: 92 07 00 09 add %i4, %o1, %o1
4000512c: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40005130: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005134: c2 00 60 04 ld [ %g1 + 4 ], %g1
40005138: 9f c0 40 00 call %g1
4000513c: 01 00 00 00 nop
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
40005140: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
40005144: c2 00 40 00 ld [ %g1 ], %g1
40005148: 96 10 20 00 clr %o3
4000514c: 94 10 00 11 mov %l1, %o2
40005150: 92 10 20 00 clr %o1
40005154: 9f c0 40 00 call %g1
40005158: 90 10 00 1a mov %i2, %o0
if ( rv == 0 ) {
4000515c: b0 92 20 00 orcc %o0, 0, %i0
40005160: 02 80 00 32 be 40005228 <fcntl+0x378>
<== ALWAYS TAKEN
40005164: 01 00 00 00 nop
rtems_libio_free( diop );
40005168: 40 00 01 f7 call 40005944 <rtems_libio_free>
<== NOT EXECUTED
4000516c: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
if (ret >= 0) {
40005170: 10 80 00 13 b 400051bc <fcntl+0x30c>
<== NOT EXECUTED
40005174: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
if ( va_arg( ap, int ) )
40005178: f0 00 c0 00 ld [ %g3 ], %i0
4000517c: 80 a6 20 00 cmp %i0, 0
40005180: 02 80 00 22 be 40005208 <fcntl+0x358>
40005184: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005188: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000518c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005190: 84 10 a8 00 or %g2, 0x800, %g2
<== NOT EXECUTED
40005194: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005198: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000519c: 01 00 00 00 nop
int ret = 0;
400051a0: 10 bf ff 81 b 40004fa4 <fcntl+0xf4>
400051a4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
400051a8: d0 07 60 08 ld [ %i5 + 8 ], %o0
ret = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
400051ac: 40 00 01 be call 400058a4 <rtems_libio_to_fcntl_flags>
400051b0: 01 00 00 00 nop
400051b4: b0 10 00 08 mov %o0, %i0
if (ret >= 0) {
400051b8: 80 a6 20 00 cmp %i0, 0
400051bc: 16 bf ff 7b bge 40004fa8 <fcntl+0xf8>
<== ALWAYS TAKEN
400051c0: 83 2c 20 04 sll %l0, 4, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400051c4: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
400051c8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400051cc: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400051d0: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400051d4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400051d8: 01 00 00 00 nop
<== NOT EXECUTED
}
400051dc: 81 c7 e0 08 ret
<== NOT EXECUTED
400051e0: 81 e8 00 00 restore
<== NOT EXECUTED
400051e4: f0 07 60 08 ld [ %i5 + 8 ], %i0
ret = ((rtems_libio_iop_flags(iop) & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
400051e8: b1 36 20 0b srl %i0, 0xb, %i0
400051ec: 10 bf ff 6e b 40004fa4 <fcntl+0xf4>
400051f0: b0 0e 20 01 and %i0, 1, %i0
errno = EINVAL;
400051f4: 40 00 28 c2 call 4000f4fc <__errno>
400051f8: b0 10 3f ff mov -1, %i0
400051fc: 82 10 20 16 mov 0x16, %g1
40005200: 10 bf ff 51 b 40004f44 <fcntl+0x94>
40005204: c2 22 00 00 st %g1, [ %o0 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005208: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val & arg;
4000520c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005210: 84 08 b7 ff and %g2, -2049, %g2
<== NOT EXECUTED
40005214: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005218: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000521c: 01 00 00 00 nop
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
40005220: 10 bf ff 62 b 40004fa8 <fcntl+0xf8>
40005224: 83 2c 20 04 sll %l0, 4, %g1
rtems_libio_fcntl_flags( oflag )
40005228: 40 00 01 92 call 40005870 <rtems_libio_fcntl_flags>
4000522c: 90 10 00 11 mov %l1, %o0
rv = rtems_libio_iop_to_descriptor( diop );
40005230: b0 26 80 1c sub %i2, %i4, %i0
_Atomic_Store_uint(
40005234: 90 12 21 00 or %o0, 0x100, %o0
40005238: 83 3e 20 04 sra %i0, 4, %g1
*obj = desired;
4000523c: d0 26 a0 08 st %o0, [ %i2 + 8 ]
40005240: 31 2a aa aa sethi %hi(0xaaaaa800), %i0
40005244: b0 16 22 ab or %i0, 0x2ab, %i0 ! aaaaaaab <RAM_END+0x6a6aaaab>
40005248: 10 bf ff dc b 400051b8 <fcntl+0x308>
4000524c: b0 58 40 18 smul %g1, %i0, %i0
LIBIO_GET_IOP( fd, iop );
40005250: 40 00 28 ab call 4000f4fc <__errno>
40005254: b0 10 3f ff mov -1, %i0
40005258: 82 10 20 09 mov 9, %g1
4000525c: c2 22 00 00 st %g1, [ %o0 ]
40005260: 81 c7 e0 08 ret
40005264: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005268: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000526c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005270: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005274: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005278: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000527c: 01 00 00 00 nop
40005280: 40 00 28 9f call 4000f4fc <__errno>
40005284: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40005288: 82 10 20 09 mov 9, %g1
4000528c: c2 22 00 00 st %g1, [ %o0 ]
40005290: 81 c7 e0 08 ret
40005294: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EBADF );
40005298: 40 00 28 99 call 4000f4fc <__errno>
<== NOT EXECUTED
4000529c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400052a0: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
400052a4: 10 bf ff 28 b 40004f44 <fcntl+0x94>
<== NOT EXECUTED
400052a8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400052ac <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
400052ac: 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 );
400052b0: 03 10 00 4d sethi %hi(0x40013400), %g1
400052b4: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 40013670 <rtems_libio_number_iops>
400052b8: 80 a6 00 01 cmp %i0, %g1
400052bc: 1a 80 00 24 bcc 4000534c <fdatasync+0xa0>
400052c0: bb 2e 20 01 sll %i0, 1, %i5
return &rtems_libio_iops[ fd ];
400052c4: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400052c8: 31 10 00 59 sethi %hi(0x40016400), %i0
<== NOT EXECUTED
400052cc: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400052d0: b0 16 21 f8 or %i0, 0x1f8, %i0
<== NOT EXECUTED
400052d4: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400052d8: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400052dc: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400052e0: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400052e4: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400052e8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400052ec: 01 00 00 00 nop
400052f0: 84 08 a1 04 and %g2, 0x104, %g2
400052f4: 80 a0 a1 04 cmp %g2, 0x104
400052f8: 12 80 00 0f bne 40005334 <fdatasync+0x88>
400052fc: 01 00 00 00 nop
/*
* Now process the fdatasync().
*/
rv = (*iop->pathinfo.handlers->fdatasync_h)( iop );
40005300: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40005304: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40005308: 9f c0 40 00 call %g1
4000530c: 90 10 00 1d mov %i5, %o0
40005310: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005314: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005318: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000531c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005320: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005324: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005328: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
4000532c: 81 c7 e0 08 ret
40005330: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005334: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005338: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000533c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005340: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005344: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005348: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
4000534c: 40 00 28 6c call 4000f4fc <__errno>
40005350: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40005354: 82 10 20 09 mov 9, %g1
40005358: c2 22 00 00 st %g1, [ %o0 ]
4000535c: 81 c7 e0 08 ret
40005360: 81 e8 00 00 restore
40005394 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
40005394: 9d e3 bf a0 save %sp, -96, %sp
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
LIBIO_GET_IOP( fd, iop );
40005398: 03 10 00 4d sethi %hi(0x40013400), %g1
4000539c: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 40013670 <rtems_libio_number_iops>
400053a0: 80 a6 00 01 cmp %i0, %g1
400053a4: 1a 80 00 43 bcc 400054b0 <fpathconf+0x11c>
400053a8: bb 2e 20 01 sll %i0, 1, %i5
400053ac: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400053b0: 31 10 00 59 sethi %hi(0x40016400), %i0
<== NOT EXECUTED
400053b4: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400053b8: b0 16 21 f8 or %i0, 0x1f8, %i0
<== NOT EXECUTED
400053bc: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400053c0: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400053c4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400053c8: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400053cc: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400053d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400053d4: 01 00 00 00 nop
400053d8: 80 88 a1 00 btst 0x100, %g2
400053dc: 02 80 00 2f be 40005498 <fpathconf+0x104>
<== NEVER TAKEN
400053e0: 80 a6 60 0b cmp %i1, 0xb
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
400053e4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
switch ( name ) {
400053e8: 18 80 00 27 bgu 40005484 <fpathconf+0xf0>
400053ec: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
400053f0: b3 2e 60 02 sll %i1, 2, %i1
400053f4: 03 10 00 14 sethi %hi(0x40005000), %g1
400053f8: 82 10 63 64 or %g1, 0x364, %g1 ! 40005364 <fdatasync+0xb8>
400053fc: c2 00 40 19 ld [ %g1 + %i1 ], %g1
40005400: 81 c0 40 00 jmp %g1
40005404: 01 00 00 00 nop
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
40005408: f0 00 a0 24 ld [ %g2 + 0x24 ], %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000540c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005410: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005414: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005418: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000541c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005420: 01 00 00 00 nop
break;
}
rtems_libio_iop_drop( iop );
return return_value;
}
40005424: 81 c7 e0 08 ret
40005428: 81 e8 00 00 restore
break;
4000542c: 10 bf ff f8 b 4000540c <fpathconf+0x78>
40005430: f0 00 a0 28 ld [ %g2 + 0x28 ], %i0
break;
40005434: 10 bf ff f6 b 4000540c <fpathconf+0x78>
40005438: f0 00 80 00 ld [ %g2 ], %i0
break;
4000543c: 10 bf ff f4 b 4000540c <fpathconf+0x78>
40005440: f0 00 a0 04 ld [ %g2 + 4 ], %i0
break;
40005444: 10 bf ff f2 b 4000540c <fpathconf+0x78>
40005448: f0 00 a0 08 ld [ %g2 + 8 ], %i0
break;
4000544c: 10 bf ff f0 b 4000540c <fpathconf+0x78>
40005450: f0 00 a0 0c ld [ %g2 + 0xc ], %i0
break;
40005454: 10 bf ff ee b 4000540c <fpathconf+0x78>
40005458: f0 00 a0 10 ld [ %g2 + 0x10 ], %i0
break;
4000545c: 10 bf ff ec b 4000540c <fpathconf+0x78>
40005460: f0 00 a0 14 ld [ %g2 + 0x14 ], %i0
break;
40005464: 10 bf ff ea b 4000540c <fpathconf+0x78>
40005468: f0 00 a0 1c ld [ %g2 + 0x1c ], %i0
break;
4000546c: 10 bf ff e8 b 4000540c <fpathconf+0x78>
40005470: f0 00 a0 20 ld [ %g2 + 0x20 ], %i0
break;
40005474: 10 bf ff e6 b 4000540c <fpathconf+0x78>
40005478: f0 00 a0 2c ld [ %g2 + 0x2c ], %i0
break;
4000547c: 10 bf ff e4 b 4000540c <fpathconf+0x78>
40005480: f0 00 a0 18 ld [ %g2 + 0x18 ], %i0
errno = EINVAL;
40005484: 40 00 28 1e call 4000f4fc <__errno>
40005488: b0 10 3f ff mov -1, %i0
4000548c: 82 10 20 16 mov 0x16, %g1
break;
40005490: 10 bf ff df b 4000540c <fpathconf+0x78>
40005494: c2 22 00 00 st %g1, [ %o0 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005498: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000549c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400054a0: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400054a4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400054a8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400054ac: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
400054b0: 40 00 28 13 call 4000f4fc <__errno>
400054b4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
400054b8: 82 10 20 09 mov 9, %g1
400054bc: c2 22 00 00 st %g1, [ %o0 ]
400054c0: 81 c7 e0 08 ret
400054c4: 81 e8 00 00 restore
40004884 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40004884: 9d e3 bf a0 save %sp, -96, %sp
if ( !ptr )
40004888: ba 96 20 00 orcc %i0, 0, %i5
4000488c: 02 80 00 0d be 400048c0 <free+0x3c>
40004890: 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 ) {
40004894: 40 00 00 7c call 40004a84 <_Malloc_System_state>
40004898: 01 00 00 00 nop
4000489c: 80 a2 20 00 cmp %o0, 0
400048a0: 12 80 00 0a bne 400048c8 <free+0x44>
<== NEVER TAKEN
400048a4: 03 10 00 65 sethi %hi(0x40019400), %g1
_Malloc_Deferred_free(ptr);
return;
}
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
400048a8: d0 00 60 84 ld [ %g1 + 0x84 ], %o0 ! 40019484 <RTEMS_Malloc_Heap>
400048ac: 40 00 13 21 call 40009530 <_Protected_heap_Free>
400048b0: 92 10 00 1d mov %i5, %o1
400048b4: 80 a2 20 00 cmp %o0, 0
400048b8: 02 80 00 06 be 400048d0 <free+0x4c>
<== NEVER TAKEN
400048bc: 92 10 00 1d mov %i5, %o1
rtems_fatal( RTEMS_FATAL_SOURCE_INVALID_HEAP_FREE, (rtems_fatal_code) ptr );
}
}
400048c0: 81 c7 e0 08 ret
400048c4: 81 e8 00 00 restore
_Malloc_Deferred_free(ptr);
400048c8: 40 00 00 d1 call 40004c0c <_Malloc_Deferred_free>
<== NOT EXECUTED
400048cc: 81 e8 00 00 restore
<== NOT EXECUTED
400048d0: 40 00 0c 21 call 40007954 <_Terminate>
<== NOT EXECUTED
400048d4: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
400048d8: 01 00 00 00 nop
<== NOT EXECUTED
40005520 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
40005520: 9d e3 bf a0 save %sp, -96, %sp
int rv;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
40005524: 80 a6 60 00 cmp %i1, 0
40005528: 02 80 00 32 be 400055f0 <fstat+0xd0>
<== NEVER TAKEN
4000552c: 03 10 00 4d sethi %hi(0x40013400), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
LIBIO_GET_IOP( fd, iop );
40005530: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 40013670 <rtems_libio_number_iops>
40005534: 80 a6 00 01 cmp %i0, %g1
40005538: 1a 80 00 28 bcc 400055d8 <fstat+0xb8>
4000553c: 91 2e 20 01 sll %i0, 1, %o0
40005540: 39 10 00 59 sethi %hi(0x40016400), %i4
<== NOT EXECUTED
40005544: b0 02 00 18 add %o0, %i0, %i0
<== NOT EXECUTED
40005548: b8 17 21 f8 or %i4, 0x1f8, %i4
<== NOT EXECUTED
4000554c: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
40005550: ba 06 00 1c add %i0, %i4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005554: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40005558: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4000555c: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40005560: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005564: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005568: 01 00 00 00 nop
4000556c: 80 88 a1 00 btst 0x100, %g2
40005570: 02 80 00 14 be 400055c0 <fstat+0xa0>
40005574: 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) );
40005578: 92 10 20 00 clr %o1
4000557c: 40 00 2e 0c call 40010dac <memset>
40005580: 90 10 00 19 mov %i1, %o0
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
40005584: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40005588: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
4000558c: 90 06 20 0c add %i0, 0xc, %o0
40005590: 92 10 00 19 mov %i1, %o1
40005594: 9f c0 40 00 call %g1
40005598: 90 07 00 08 add %i4, %o0, %o0
4000559c: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400055a0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
400055a4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400055a8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400055ac: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400055b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400055b4: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
400055b8: 81 c7 e0 08 ret
400055bc: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400055c0: 91 d0 20 09 ta 9
<== NOT EXECUTED
400055c4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400055c8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400055cc: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400055d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400055d4: 01 00 00 00 nop
LIBIO_GET_IOP( fd, iop );
400055d8: 40 00 27 c9 call 4000f4fc <__errno>
400055dc: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
400055e0: 82 10 20 09 mov 9, %g1
400055e4: c2 22 00 00 st %g1, [ %o0 ]
400055e8: 81 c7 e0 08 ret
400055ec: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EFAULT );
400055f0: 40 00 27 c3 call 4000f4fc <__errno>
<== NOT EXECUTED
400055f4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400055f8: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
400055fc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005600: 81 c7 e0 08 ret
<== NOT EXECUTED
40005604: 81 e8 00 00 restore
<== NOT EXECUTED
4000561c <fsync>:
* POSIX 1003.1b 6.6.1 - Synchronize the State of a File
*/
int fsync(
int fd
)
{
4000561c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
int rv;
LIBIO_GET_IOP( fd, iop );
40005620: 03 10 00 4d sethi %hi(0x40013400), %g1
40005624: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 40013670 <rtems_libio_number_iops>
40005628: 80 a6 00 01 cmp %i0, %g1
4000562c: 1a 80 00 23 bcc 400056b8 <fsync+0x9c>
40005630: bb 2e 20 01 sll %i0, 1, %i5
40005634: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40005638: 31 10 00 59 sethi %hi(0x40016400), %i0
<== NOT EXECUTED
4000563c: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40005640: b0 16 21 f8 or %i0, 0x1f8, %i0
<== NOT EXECUTED
40005644: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005648: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000564c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40005650: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40005654: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005658: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000565c: 01 00 00 00 nop
40005660: 80 88 a1 00 btst 0x100, %g2
40005664: 02 80 00 0f be 400056a0 <fsync+0x84>
40005668: 01 00 00 00 nop
/*
* Now process the fsync().
*/
rv = (*iop->pathinfo.handlers->fsync_h)( iop );
4000566c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40005670: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
40005674: 9f c0 40 00 call %g1
40005678: 90 10 00 1d mov %i5, %o0
4000567c: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005680: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005684: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005688: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000568c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005690: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005694: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
40005698: 81 c7 e0 08 ret
4000569c: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400056a0: 91 d0 20 09 ta 9
<== NOT EXECUTED
400056a4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400056a8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400056ac: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400056b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400056b4: 01 00 00 00 nop
LIBIO_GET_IOP( fd, iop );
400056b8: 40 00 27 91 call 4000f4fc <__errno>
400056bc: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
400056c0: 82 10 20 09 mov 9, %g1
400056c4: c2 22 00 00 st %g1, [ %o0 ]
400056c8: 81 c7 e0 08 ret
400056cc: 81 e8 00 00 restore
4000dbfc <ftruncate>:
#include <unistd.h>
#include <rtems/libio_.h>
int ftruncate( int fd, off_t length )
{
4000dbfc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if ( length >= 0 ) {
4000dc00: 80 a6 60 00 cmp %i1, 0
4000dc04: 06 80 00 39 bl 4000dce8 <ftruncate+0xec>
<== NEVER TAKEN
4000dc08: 03 10 00 5c sethi %hi(0x40017000), %g1
rtems_libio_t *iop;
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
4000dc0c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 400173d0 <rtems_libio_number_iops>
4000dc10: 80 a6 00 01 cmp %i0, %g1
4000dc14: 1a 80 00 1f bcc 4000dc90 <ftruncate+0x94>
4000dc18: bb 2e 20 01 sll %i0, 1, %i5
return &rtems_libio_iops[ fd ];
4000dc1c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
4000dc20: 31 10 00 6a sethi %hi(0x4001a800), %i0
<== NOT EXECUTED
4000dc24: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
4000dc28: b0 16 21 98 or %i0, 0x198, %i0
<== NOT EXECUTED
4000dc2c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dc30: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000dc34: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4000dc38: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4000dc3c: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dc40: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dc44: 01 00 00 00 nop
4000dc48: 82 08 a1 04 and %g2, 0x104, %g1
4000dc4c: 80 a0 61 04 cmp %g1, 0x104
4000dc50: 12 80 00 16 bne 4000dca8 <ftruncate+0xac>
4000dc54: 92 10 00 19 mov %i1, %o1
rv = (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
4000dc58: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000dc5c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4000dc60: 94 10 00 1a mov %i2, %o2
4000dc64: 9f c0 40 00 call %g1
4000dc68: 90 10 00 1d mov %i5, %o0
4000dc6c: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dc70: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000dc74: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000dc78: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000dc7c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dc80: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dc84: 01 00 00 00 nop
4000dc88: 81 c7 e0 08 ret
4000dc8c: 81 e8 00 00 restore
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
4000dc90: 40 00 04 b6 call 4000ef68 <__errno>
4000dc94: b0 10 3f ff mov -1, %i0
4000dc98: 82 10 20 09 mov 9, %g1
4000dc9c: c2 22 00 00 st %g1, [ %o0 ]
4000dca0: 81 c7 e0 08 ret
4000dca4: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dca8: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000dcac: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
4000dcb0: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
4000dcb4: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dcb8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dcbc: 01 00 00 00 nop
4000dcc0: 84 08 a1 00 and %g2, 0x100, %g2
4000dcc4: 80 a0 00 02 cmp %g0, %g2
4000dcc8: b0 10 3f ff mov -1, %i0
4000dccc: 40 00 04 a7 call 4000ef68 <__errno>
4000dcd0: ba 60 20 00 subx %g0, 0, %i5
4000dcd4: ba 0f 60 0d and %i5, 0xd, %i5
4000dcd8: ba 07 60 09 add %i5, 9, %i5
4000dcdc: fa 22 00 00 st %i5, [ %o0 ]
4000dce0: 81 c7 e0 08 ret
4000dce4: 81 e8 00 00 restore
rtems_libio_iop_drop( iop );
} else {
errno = EINVAL;
4000dce8: 40 00 04 a0 call 4000ef68 <__errno>
<== NOT EXECUTED
4000dcec: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000dcf0: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000dcf4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
4000dcf8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dcfc: 81 e8 00 00 restore
<== NOT EXECUTED
400048dc <getchark>:
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
400048dc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( BSP_poll_char )
400048e0: 03 10 00 66 sethi %hi(0x40019800), %g1
<== NOT EXECUTED
400048e4: d0 00 61 dc ld [ %g1 + 0x1dc ], %o0 ! 400199dc <BSP_poll_char>
<== NOT EXECUTED
400048e8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400048ec: 02 80 00 06 be 40004904 <getchark+0x28>
<== NOT EXECUTED
400048f0: 01 00 00 00 nop
<== NOT EXECUTED
return (*BSP_poll_char)();
400048f4: 9f c2 00 00 call %o0
<== NOT EXECUTED
400048f8: 01 00 00 00 nop
<== NOT EXECUTED
400048fc: 81 c7 e0 08 ret
<== NOT EXECUTED
40004900: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
return -1;
}
40004904: 81 c7 e0 08 ret
<== NOT EXECUTED
40004908: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40004958 <getgrent>:
}
struct group *getgrent(void)
{
40004958: 9d e3 bf a0 save %sp, -96, %sp
grp_context *ctx = grp_get_context();
4000495c: 7f ff ff ee call 40004914 <grp_get_context>
40004960: 01 00 00 00 nop
if (ctx == NULL)
40004964: 80 a2 20 00 cmp %o0, 0
40004968: 02 80 00 10 be 400049a8 <getgrent+0x50>
4000496c: 01 00 00 00 nop
return NULL;
if (ctx->fp == NULL)
40004970: c2 02 00 00 ld [ %o0 ], %g1
40004974: 80 a0 60 00 cmp %g1, 0
40004978: 02 80 00 0c be 400049a8 <getgrent+0x50>
<== NEVER TAKEN
4000497c: 94 02 20 04 add %o0, 4, %o2
return NULL;
if (!_libcsupport_scangr(ctx->fp, &ctx->grp, ctx->buf, sizeof(ctx->buf)))
40004980: b0 02 21 04 add %o0, 0x104, %i0
40004984: 96 10 21 00 mov 0x100, %o3
40004988: 92 10 00 18 mov %i0, %o1
4000498c: 40 00 04 cd call 40005cc0 <_libcsupport_scangr>
40004990: 90 10 00 01 mov %g1, %o0
40004994: 80 a2 20 00 cmp %o0, 0
40004998: 02 80 00 04 be 400049a8 <getgrent+0x50>
4000499c: 01 00 00 00 nop
return NULL;
return &ctx->grp;
}
400049a0: 81 c7 e0 08 ret
400049a4: 81 e8 00 00 restore
return NULL;
400049a8: 81 c7 e0 08 ret
400049ac: 91 e8 20 00 restore %g0, 0, %o0
40004b50 <getlogin>:
{
40004b50: 9d e3 bf a0 save %sp, -96, %sp
(void) getlogin_r( _POSIX_types_Getlogin_buffer, LOGIN_NAME_MAX );
40004b54: 40 00 03 21 call 400057d8 <rtems_current_user_env_get>
40004b58: 01 00 00 00 nop
if ( !name )
40004b5c: 90 82 20 14 addcc %o0, 0x14, %o0
40004b60: 02 80 00 04 be 40004b70 <getlogin+0x20>
<== NEVER TAKEN
40004b64: 01 00 00 00 nop
40004b68: 7f ff ff e4 call 40004af8 <getlogin_r.part.0>
40004b6c: 01 00 00 00 nop
return _POSIX_types_Getlogin_buffer;
40004b70: 40 00 03 1a call 400057d8 <rtems_current_user_env_get>
40004b74: 01 00 00 00 nop
}
40004b78: 81 c7 e0 08 ret
40004b7c: 91 ea 20 14 restore %o0, 0x14, %o0
40004b80 <getlogin_r>:
if ( !name )
40004b80: 80 a2 20 00 cmp %o0, 0
40004b84: 02 80 00 09 be 40004ba8 <getlogin_r+0x28>
40004b88: 80 a2 60 08 cmp %o1, 8
if ( namesize < LOGIN_NAME_MAX )
40004b8c: 08 80 00 05 bleu 40004ba0 <getlogin_r+0x20>
<== ALWAYS TAKEN
40004b90: 01 00 00 00 nop
40004b94: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40004b98: 7f ff ff d8 call 40004af8 <getlogin_r.part.0>
<== NOT EXECUTED
40004b9c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
}
40004ba0: 81 c3 e0 08 retl
40004ba4: 90 10 20 22 mov 0x22, %o0
return EFAULT;
40004ba8: 81 c3 e0 08 retl
40004bac: 90 10 20 0e mov 0xe, %o0
4000fadc <ioctl>:
int ioctl(
int fd,
ioctl_command_t command,
...
)
{
4000fadc: 9d e3 bf 98 save %sp, -104, %sp
rtems_libio_t *iop;
void *buffer;
LIBIO_GET_IOP( fd, iop );
va_start(ap, command);
4000fae0: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
LIBIO_GET_IOP( fd, iop );
4000fae4: 03 10 00 49 sethi %hi(0x40012400), %g1
va_start(ap, command);
4000fae8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4000faec: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
LIBIO_GET_IOP( fd, iop );
4000faf0: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
4000faf4: 80 a6 00 01 cmp %i0, %g1
4000faf8: 1a 80 00 27 bcc 4000fb94 <ioctl+0xb8>
4000fafc: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
4000fb00: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
4000fb04: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
4000fb08: 31 10 00 56 sethi %hi(0x40015800), %i0
<== NOT EXECUTED
4000fb0c: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
4000fb10: b0 16 23 88 or %i0, 0x388, %i0
<== NOT EXECUTED
4000fb14: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000fb18: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000fb1c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4000fb20: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4000fb24: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fb28: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000fb2c: 01 00 00 00 nop
4000fb30: 80 88 a1 00 btst 0x100, %g2
4000fb34: 02 80 00 12 be 4000fb7c <ioctl+0xa0>
4000fb38: 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 );
4000fb3c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000fb40: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000fb44: d4 07 a0 4c ld [ %fp + 0x4c ], %o2
4000fb48: 92 10 00 19 mov %i1, %o1
va_start(ap, command);
4000fb4c: c4 27 bf fc st %g2, [ %fp + -4 ]
rc = (*iop->pathinfo.handlers->ioctl_h)( iop, command, buffer );
4000fb50: 9f c0 40 00 call %g1
4000fb54: 90 10 00 1d mov %i5, %o0
4000fb58: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000fb5c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000fb60: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000fb64: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000fb68: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fb6c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000fb70: 01 00 00 00 nop
va_end( ap );
rtems_libio_iop_drop( iop );
return rc;
}
4000fb74: 81 c7 e0 08 ret
4000fb78: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000fb7c: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000fb80: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000fb84: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000fb88: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fb8c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000fb90: 01 00 00 00 nop
LIBIO_GET_IOP( fd, iop );
4000fb94: 40 00 04 27 call 40010c30 <__errno>
4000fb98: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
4000fb9c: 82 10 20 09 mov 9, %g1
4000fba0: c2 22 00 00 st %g1, [ %o0 ]
4000fba4: 81 c7 e0 08 ret
4000fba8: 81 e8 00 00 restore
400188a4 <lseek>:
#include <unistd.h>
#include <rtems/libio_.h>
off_t lseek( int fd, off_t offset, int whence )
{
400188a4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
off_t rv;
LIBIO_GET_IOP( fd, iop );
400188a8: 03 10 00 64 sethi %hi(0x40019000), %g1
400188ac: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 400192e8 <rtems_libio_number_iops>
400188b0: 80 a6 00 01 cmp %i0, %g1
400188b4: 1a 80 00 26 bcc 4001894c <lseek+0xa8>
400188b8: bb 2e 20 01 sll %i0, 1, %i5
400188bc: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400188c0: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
400188c4: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400188c8: b0 16 22 28 or %i0, 0x228, %i0
<== NOT EXECUTED
400188cc: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400188d0: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400188d4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400188d8: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400188dc: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400188e0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400188e4: 01 00 00 00 nop
400188e8: 80 88 a1 00 btst 0x100, %g2
400188ec: 02 80 00 12 be 40018934 <lseek+0x90>
400188f0: 96 10 00 1b mov %i3, %o3
rv = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
400188f4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400188f8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
400188fc: 92 10 00 19 mov %i1, %o1
40018900: 94 10 00 1a mov %i2, %o2
40018904: 9f c0 40 00 call %g1
40018908: 90 10 00 1d mov %i5, %o0
4001890c: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
40018910: b2 10 00 09 mov %o1, %i1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018914: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40018918: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4001891c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018920: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018924: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018928: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
4001892c: 81 c7 e0 08 ret
40018930: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018934: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018938: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4001893c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018940: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018944: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018948: 01 00 00 00 nop
LIBIO_GET_IOP( fd, iop );
4001894c: 7f ff de 0f call 40010188 <__errno>
40018950: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40018954: 82 10 20 09 mov 9, %g1
40018958: c2 22 00 00 st %g1, [ %o0 ]
4001895c: 81 c7 e0 08 ret
40018960: 93 e8 3f ff restore %g0, -1, %o1
40004cc8 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
40004cc8: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Validate the parameters
*/
if ( !size )
40004ccc: 80 a6 20 00 cmp %i0, 0
40004cd0: 02 80 00 0a be 40004cf8 <malloc+0x30>
<== NEVER TAKEN
40004cd4: 90 10 00 18 mov %i0, %o0
return (void *) 0;
return_this = rtems_heap_allocate_aligned_with_boundary( size, 0, 0 );
40004cd8: 94 10 20 00 clr %o2
40004cdc: 7f ff ff 92 call 40004b24 <rtems_heap_allocate_aligned_with_boundary>
40004ce0: 92 10 20 00 clr %o1
if ( !return_this ) {
40004ce4: b0 92 20 00 orcc %o0, 0, %i0
40004ce8: 02 80 00 06 be 40004d00 <malloc+0x38>
40004cec: 01 00 00 00 nop
errno = ENOMEM;
return (void *) 0;
}
return return_this;
}
40004cf0: 81 c7 e0 08 ret
40004cf4: 81 e8 00 00 restore
40004cf8: 81 c7 e0 08 ret
<== NOT EXECUTED
40004cfc: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
errno = ENOMEM;
40004d00: 40 00 28 9a call 4000ef68 <__errno>
40004d04: 01 00 00 00 nop
40004d08: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
40004d0c: c2 22 00 00 st %g1, [ %o0 ]
return (void *) 0;
40004d10: 81 c7 e0 08 ret
40004d14: 81 e8 00 00 restore
40004e38 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40004e38: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
40004e3c: 80 a6 e0 01 cmp %i3, 1
40004e40: 18 80 00 b2 bgu 40005108 <mount+0x2d0>
40004e44: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
40004e48: 40 00 24 21 call 4000decc <rtems_filesystem_get_mount_handler>
40004e4c: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
40004e50: a2 92 20 00 orcc %o0, 0, %l1
40004e54: 02 80 00 ad be 40005108 <mount+0x2d0>
40004e58: 80 a6 60 00 cmp %i1, 0
const char *target = target_or_null != NULL ? target_or_null : "/";
40004e5c: 02 80 00 78 be 4000503c <mount+0x204>
40004e60: 90 10 00 19 mov %i1, %o0
40004e64: 40 00 29 fb call 4000f650 <strlen>
40004e68: a6 10 00 19 mov %i1, %l3
40004e6c: a4 02 20 01 add %o0, 1, %l2
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40004e70: 40 00 29 f8 call 4000f650 <strlen>
40004e74: 90 10 00 1a mov %i2, %o0
strlen( source_or_null ) + 1 : 0;
40004e78: 80 a6 20 00 cmp %i0, 0
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40004e7c: a8 02 20 01 add %o0, 1, %l4
strlen( source_or_null ) + 1 : 0;
40004e80: 02 80 00 61 be 40005004 <mount+0x1cc>
40004e84: ba 02 20 65 add %o0, 0x65, %i5
40004e88: 40 00 29 f2 call 4000f650 <strlen>
40004e8c: 90 10 00 18 mov %i0, %o0
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
40004e90: 92 07 40 12 add %i5, %l2, %o1
strlen( source_or_null ) + 1 : 0;
40004e94: a0 02 20 01 add %o0, 1, %l0
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
40004e98: 90 10 20 01 mov 1, %o0
40004e9c: 7f ff fe 2f call 40004758 <calloc>
40004ea0: 92 02 40 10 add %o1, %l0, %o1
if ( mt_entry != NULL ) {
40004ea4: ba 92 20 00 orcc %o0, 0, %i5
40004ea8: 12 80 00 08 bne 40004ec8 <mount+0x90>
<== ALWAYS TAKEN
40004eac: 84 07 60 64 add %i5, 0x64, %g2
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
40004eb0: 40 00 28 2e call 4000ef68 <__errno>
<== NOT EXECUTED
40004eb4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004eb8: 82 10 20 0c mov 0xc, %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
memcpy( str, filesystemtype, filesystemtype_size );
40004ec8: 92 10 00 1a mov %i2, %o1
40004ecc: 94 10 00 14 mov %l4, %o2
40004ed0: 40 00 28 54 call 4000f020 <memcpy>
40004ed4: 90 10 00 02 mov %g2, %o0
mt_entry->type = str;
40004ed8: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
str += filesystemtype_size;
40004edc: 84 02 00 14 add %o0, %l4, %g2
memcpy( str, source_or_null, source_size );
40004ee0: 94 10 00 10 mov %l0, %o2
40004ee4: 92 10 00 18 mov %i0, %o1
40004ee8: 40 00 28 4e call 4000f020 <memcpy>
40004eec: 90 10 00 02 mov %g2, %o0
mt_entry->dev = str;
40004ef0: d0 27 60 38 st %o0, [ %i5 + 0x38 ]
rtems_filesystem_global_location_t *mt_fs_root =
40004ef4: b4 07 60 40 add %i5, 0x40, %i2
str += source_size;
40004ef8: a0 02 00 10 add %o0, %l0, %l0
memcpy( str, target, target_size );
40004efc: 94 10 00 12 mov %l2, %o2
40004f00: 92 10 00 13 mov %l3, %o1
40004f04: 40 00 28 47 call 4000f020 <memcpy>
40004f08: 90 10 00 10 mov %l0, %o0
mt_entry->mounted = true;
40004f0c: 82 10 20 01 mov 1, %g1
40004f10: c2 2f 60 28 stb %g1, [ %i5 + 0x28 ]
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40004f14: 03 10 00 5e sethi %hi(0x40017800), %g1
40004f18: 82 10 60 50 or %g1, 0x50, %g1 ! 40017850 <rtems_filesystem_default_pathconf>
mt_entry->target = str;
40004f1c: e0 27 60 30 st %l0, [ %i5 + 0x30 ]
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize(
40004f20: 96 10 20 24 mov 0x24, %o3
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40004f24: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->reference_count = 1;
40004f28: 82 10 20 01 mov 1, %g1
mt_entry->mt_fs_root = mt_fs_root;
40004f2c: f4 27 60 24 st %i2, [ %i5 + 0x24 ]
40004f30: 94 10 20 01 mov 1, %o2
mt_fs_root->reference_count = 1;
40004f34: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
40004f38: 92 10 00 1a mov %i2, %o1
mt_fs_root->location.mt_entry = mt_entry;
40004f3c: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
40004f40: 90 07 60 14 add %i5, 0x14, %o0
40004f44: 40 00 08 a7 call 400071e0 <_Chain_Initialize>
40004f48: b6 0e e0 01 and %i3, 1, %i3
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
40004f4c: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
40004f50: 92 10 00 1c mov %i4, %o1
40004f54: 9f c4 40 00 call %l1
40004f58: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40004f5c: b0 92 20 00 orcc %o0, 0, %i0
40004f60: 12 80 00 25 bne 40004ff4 <mount+0x1bc>
40004f64: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
40004f68: 02 80 00 48 be 40005088 <mount+0x250>
40004f6c: 94 10 20 1f mov 0x1f, %o2
rtems_filesystem_location_info_t *currentloc =
40004f70: 92 10 00 19 mov %i1, %o1
40004f74: 40 00 03 02 call 40005b7c <rtems_filesystem_eval_path_start>
40004f78: 90 07 bf c8 add %fp, -56, %o0
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40004f7c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
40004f80: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40004f84: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
40004f88: 9f c0 80 00 call %g2
40004f8c: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
40004f90: 80 a2 20 00 cmp %o0, 0
40004f94: 12 80 00 63 bne 40005120 <mount+0x2e8>
40004f98: 92 07 bf e0 add %fp, -32, %o1
rtems_filesystem_location_copy_and_detach(
40004f9c: 40 00 04 4e call 400060d4 <rtems_filesystem_location_copy_and_detach>
40004fa0: 90 07 bf b0 add %fp, -80, %o0
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40004fa4: 40 00 04 77 call 40006180 <rtems_filesystem_location_transform_to_global>
40004fa8: 90 07 bf b0 add %fp, -80, %o0
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40004fac: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40004fb0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
mt_entry->mt_point_node = mt_point_node;
40004fb4: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40004fb8: b8 10 00 08 mov %o0, %i4
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40004fbc: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
40004fc0: 9f c0 40 00 call %g1
40004fc4: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40004fc8: b0 92 20 00 orcc %o0, 0, %i0
40004fcc: 02 80 00 20 be 4000504c <mount+0x214>
40004fd0: 90 10 00 1c mov %i4, %o0
rtems_filesystem_global_location_release( mt_point_node, true );
40004fd4: 40 00 03 fb call 40005fc0 <rtems_filesystem_global_location_release>
40004fd8: 92 10 20 01 mov 1, %o1
rtems_filesystem_eval_path_cleanup( &ctx );
40004fdc: 40 00 02 f4 call 40005bac <rtems_filesystem_eval_path_cleanup>
40004fe0: 90 07 bf c8 add %fp, -56, %o0
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40004fe4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40004fe8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40004fec: 9f c0 40 00 call %g1
40004ff0: 90 10 00 1d mov %i5, %o0
free( mt_entry );
40004ff4: 7f ff fe 24 call 40004884 <free>
40004ff8: 90 10 00 1d mov %i5, %o0
errno = EINVAL;
rv = -1;
}
return rv;
}
40004ffc: 81 c7 e0 08 ret
40005000: 81 e8 00 00 restore
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
40005004: 92 07 40 12 add %i5, %l2, %o1
40005008: 7f ff fd d4 call 40004758 <calloc>
4000500c: 90 10 20 01 mov 1, %o0
if ( mt_entry != NULL ) {
40005010: ba 92 20 00 orcc %o0, 0, %i5
40005014: 02 bf ff a7 be 40004eb0 <mount+0x78>
<== NEVER TAKEN
40005018: 84 07 60 64 add %i5, 0x64, %g2
memcpy( str, filesystemtype, filesystemtype_size );
4000501c: 92 10 00 1a mov %i2, %o1
40005020: 94 10 00 14 mov %l4, %o2
40005024: 90 10 00 02 mov %g2, %o0
40005028: 40 00 27 fe call 4000f020 <memcpy>
4000502c: b4 07 60 40 add %i5, 0x40, %i2
str += filesystemtype_size;
40005030: a0 02 00 14 add %o0, %l4, %l0
mt_entry->type = str;
40005034: 10 bf ff b2 b 40004efc <mount+0xc4>
40005038: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
const char *target = target_or_null != NULL ? target_or_null : "/";
4000503c: 27 10 00 5c sethi %hi(0x40017000), %l3
40005040: a4 10 20 02 mov 2, %l2
40005044: 10 bf ff 8b b 40004e70 <mount+0x38>
40005048: a6 14 e3 40 or %l3, 0x340, %l3
rtems_libio_lock();
4000504c: 7f ff fe 84 call 40004a5c <rtems_libio_lock>
40005050: 01 00 00 00 nop
old_last = tail->previous;
40005054: 03 10 00 65 sethi %hi(0x40019400), %g1
40005058: 82 10 60 bc or %g1, 0xbc, %g1 ! 400194bc <rtems_filesystem_mount_table>
4000505c: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
40005060: 86 00 60 04 add %g1, 4, %g3
tail->previous = the_node;
40005064: fa 20 60 08 st %i5, [ %g1 + 8 ]
the_node->next = tail;
40005068: c6 27 40 00 st %g3, [ %i5 ]
old_last->next = the_node;
4000506c: fa 20 80 00 st %i5, [ %g2 ]
rtems_libio_unlock();
40005070: 7f ff fe 80 call 40004a70 <rtems_libio_unlock>
40005074: c4 27 60 04 st %g2, [ %i5 + 4 ]
rtems_filesystem_eval_path_cleanup( &ctx );
40005078: 40 00 02 cd call 40005bac <rtems_filesystem_eval_path_cleanup>
4000507c: 90 07 bf c8 add %fp, -56, %o0
40005080: 81 c7 e0 08 ret
40005084: 81 e8 00 00 restore
rtems_libio_lock();
40005088: 7f ff fe 75 call 40004a5c <rtems_libio_lock>
4000508c: 01 00 00 00 nop
return _Chain_Immutable_head( the_chain )->next;
40005090: 03 10 00 65 sethi %hi(0x40019400), %g1
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
40005094: c4 00 60 bc ld [ %g1 + 0xbc ], %g2 ! 400194bc <rtems_filesystem_mount_table>
40005098: 82 10 60 bc or %g1, 0xbc, %g1
4000509c: 86 00 60 04 add %g1, 4, %g3
400050a0: 80 a0 80 03 cmp %g2, %g3
400050a4: 12 80 00 27 bne 40005140 <mount+0x308>
<== NEVER TAKEN
400050a8: 01 00 00 00 nop
old_last = tail->previous;
400050ac: c6 00 60 08 ld [ %g1 + 8 ], %g3
the_node->next = tail;
400050b0: c4 27 40 00 st %g2, [ %i5 ]
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
400050b4: b8 07 60 24 add %i5, 0x24, %i4
tail->previous = the_node;
400050b8: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
400050bc: fa 20 c0 00 st %i5, [ %g3 ]
rtems_libio_unlock();
400050c0: 7f ff fe 6c call 40004a70 <rtems_libio_unlock>
400050c4: c6 27 60 04 st %g3, [ %i5 + 4 ]
rtems_filesystem_global_location_t *new_fs_root =
400050c8: 40 00 03 84 call 40005ed8 <rtems_filesystem_global_location_obtain>
400050cc: 90 10 00 1c mov %i4, %o0
400050d0: b6 10 00 08 mov %o0, %i3
rtems_filesystem_global_location_t *new_fs_current =
400050d4: 40 00 03 81 call 40005ed8 <rtems_filesystem_global_location_obtain>
400050d8: 90 10 00 1c mov %i4, %o0
&rtems_filesystem_root,
400050dc: 40 00 00 fa call 400054c4 <rtems_current_user_env_get>
400050e0: ba 10 00 08 mov %o0, %i5
rtems_filesystem_global_location_assign(
400050e4: 92 10 00 1b mov %i3, %o1
400050e8: 40 00 03 d0 call 40006028 <rtems_filesystem_global_location_assign>
400050ec: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_current,
400050f0: 40 00 00 f5 call 400054c4 <rtems_current_user_env_get>
400050f4: 01 00 00 00 nop
rtems_filesystem_global_location_assign(
400050f8: 40 00 03 cc call 40006028 <rtems_filesystem_global_location_assign>
400050fc: 92 10 00 1d mov %i5, %o1
40005100: 81 c7 e0 08 ret
40005104: 81 e8 00 00 restore
errno = EINVAL;
40005108: 40 00 27 98 call 4000ef68 <__errno>
4000510c: b0 10 3f ff mov -1, %i0
40005110: 82 10 20 16 mov 0x16, %g1
40005114: c2 22 00 00 st %g1, [ %o0 ]
return rv;
40005118: 81 c7 e0 08 ret
4000511c: 81 e8 00 00 restore
rtems_filesystem_eval_path_error( &ctx, EBUSY );
40005120: 90 07 bf c8 add %fp, -56, %o0
40005124: 40 00 01 db call 40005890 <rtems_filesystem_eval_path_error>
40005128: 92 10 20 10 mov 0x10, %o1
rv = -1;
4000512c: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_cleanup( &ctx );
40005130: 40 00 02 9f call 40005bac <rtems_filesystem_eval_path_cleanup>
40005134: 90 07 bf c8 add %fp, -56, %o0
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40005138: 10 bf ff ac b 40004fe8 <mount+0x1b0>
4000513c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
errno = EINVAL;
40005140: 40 00 27 8a call 4000ef68 <__errno>
<== NOT EXECUTED
40005144: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005148: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000514c: 7f ff fe 49 call 40004a70 <rtems_libio_unlock>
<== NOT EXECUTED
40005150: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40005154: 10 bf ff a5 b 40004fe8 <mount+0x1b0>
<== NOT EXECUTED
40005158: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
40005258 <open>:
/**
* POSIX 1003.1 5.3.1 - Open a File
*/
int open( const char *path, int oflag, ... )
{
40005258: 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 );
4000525c: 82 07 a0 50 add %fp, 0x50, %g1
va_start( ap, oflag );
40005260: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
40005264: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40005268: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
4000526c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
iop = rtems_libio_allocate();
40005270: 40 00 22 b9 call 4000dd54 <rtems_libio_allocate>
40005274: c2 27 bf 64 st %g1, [ %fp + -156 ]
if ( iop != NULL ) {
40005278: ba 92 20 00 orcc %o0, 0, %i5
4000527c: 02 80 00 76 be 40005454 <open+0x1fc>
40005280: 82 06 60 01 add %i1, 1, %g1
bool make = (oflag & O_CREAT) == O_CREAT;
40005284: 86 0e 62 00 and %i1, 0x200, %g3
bool read_access = (rwflag & _FREAD) == _FREAD;
40005288: 94 08 60 01 and %g1, 1, %o2
bool exclusive = (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
4000528c: 84 0e 6a 00 and %i1, 0xa00, %g2
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40005290: 94 02 bf ff add %o2, -1, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40005294: b8 88 60 02 andcc %g1, 2, %i4
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40005298: 94 0a bf fc and %o2, -4, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
4000529c: 02 80 00 03 be 400052a8 <open+0x50>
400052a0: 94 02 a0 1c add %o2, 0x1c, %o2
400052a4: 94 12 a0 02 or %o2, 2, %o2
| (make ? RTEMS_FS_MAKE : 0)
400052a8: 80 a0 e0 00 cmp %g3, 0
400052ac: 32 80 00 02 bne,a 400052b4 <open+0x5c>
400052b0: 94 12 a0 20 or %o2, 0x20, %o2
| (exclusive ? RTEMS_FS_EXCLUSIVE : 0);
400052b4: 80 a0 aa 00 cmp %g2, 0xa00
400052b8: 22 80 00 02 be,a 400052c0 <open+0x68>
400052bc: 94 12 a0 40 or %o2, 0x40, %o2
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
400052c0: 92 10 00 18 mov %i0, %o1
400052c4: 40 00 02 2e call 40005b7c <rtems_filesystem_eval_path_start>
400052c8: 90 07 bf 68 add %fp, -152, %o0
400052cc: f6 07 bf 74 ld [ %fp + -140 ], %i3
if ( rtems_filesystem_eval_path_has_token( &ctx ) ) {
400052d0: 80 a6 e0 00 cmp %i3, 0
400052d4: 12 80 00 45 bne 400053e8 <open+0x190>
400052d8: 80 a7 20 00 cmp %i4, 0
if ( write_access ) {
400052dc: 02 80 00 0e be 40005314 <open+0xbc>
400052e0: c2 07 bf 90 ld [ %fp + -112 ], %g1
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
400052e4: c0 27 bf ac clr [ %fp + -84 ]
(void) ( *loc->handlers->fstat_h )( loc, &st );
400052e8: 92 07 bf a0 add %fp, -96, %o1
400052ec: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
400052f0: 9f c0 40 00 call %g1
400052f4: 90 07 bf 80 add %fp, -128, %o0
if ( S_ISDIR( type ) ) {
400052f8: 05 00 00 3c sethi %hi(0xf000), %g2
400052fc: c2 07 bf ac ld [ %fp + -84 ], %g1
40005300: 82 08 40 02 and %g1, %g2, %g1
40005304: 05 00 00 10 sethi %hi(0x4000), %g2
40005308: 80 a0 40 02 cmp %g1, %g2
4000530c: 02 80 00 4e be 40005444 <open+0x1ec>
40005310: 92 10 20 15 mov 0x15, %o1
rtems_filesystem_location_copy_and_detach(
40005314: 92 07 bf 80 add %fp, -128, %o1
40005318: 40 00 03 6f call 400060d4 <rtems_filesystem_location_copy_and_detach>
4000531c: 90 07 60 0c add %i5, 0xc, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
40005320: 40 00 02 23 call 40005bac <rtems_filesystem_eval_path_cleanup>
40005324: 90 07 bf 68 add %fp, -152, %o0
_Atomic_Store_uint(
40005328: 40 00 22 7e call 4000dd20 <rtems_libio_fcntl_flags>
4000532c: 90 10 00 19 mov %i1, %o0
rv = (*iop->pathinfo.handlers->open_h)( iop, path, oflag, mode );
40005330: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
atomic_store_explicit( obj, desired, order );
#else
(void) order;
RTEMS_COMPILER_MEMORY_BARRIER();
*obj = desired;
40005334: d0 27 60 08 st %o0, [ %i5 + 8 ]
40005338: 92 10 00 18 mov %i0, %o1
4000533c: c2 00 40 00 ld [ %g1 ], %g1
40005340: 96 10 00 1a mov %i2, %o3
40005344: 94 10 00 19 mov %i1, %o2
40005348: 9f c0 40 00 call %g1
4000534c: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40005350: b0 92 20 00 orcc %o0, 0, %i0
40005354: 12 80 00 13 bne 400053a0 <open+0x148>
40005358: 80 a6 20 00 cmp %i0, 0
int fd = rtems_libio_iop_to_descriptor( iop );
4000535c: 31 10 00 6a sethi %hi(0x4001a800), %i0
40005360: 03 2a aa aa sethi %hi(0xaaaaa800), %g1
40005364: b0 16 21 98 or %i0, 0x198, %i0
<== NOT EXECUTED
40005368: 82 10 62 ab or %g1, 0x2ab, %g1
<== NOT EXECUTED
4000536c: b0 27 40 18 sub %i5, %i0, %i0
<== NOT EXECUTED
40005370: b1 3e 20 04 sra %i0, 4, %i0
<== NOT EXECUTED
40005374: b0 5e 00 01 smul %i0, %g1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005378: 91 d0 20 09 ta 9
<== NOT EXECUTED
ISR_Level level;
(void) order;
_ISR_Local_disable( level );
val = *obj;
*obj = val | arg;
4000537c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005380: 84 10 a1 00 or %g2, 0x100, %g2
<== NOT EXECUTED
40005384: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005388: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000538c: 01 00 00 00 nop
if ( truncate ) {
40005390: 80 8e 64 00 btst 0x400, %i1
40005394: 12 80 00 07 bne 400053b0 <open+0x158>
40005398: 92 10 20 00 clr %o1
if ( rv < 0 ) {
4000539c: 80 a6 20 00 cmp %i0, 0
400053a0: 06 80 00 0e bl 400053d8 <open+0x180>
400053a4: 01 00 00 00 nop
}
va_end( ap );
return rv;
}
400053a8: 81 c7 e0 08 ret
400053ac: 81 e8 00 00 restore
rv = ftruncate( fd, 0 );
400053b0: 94 10 20 00 clr %o2
400053b4: 40 00 22 12 call 4000dbfc <ftruncate>
400053b8: 90 10 00 18 mov %i0, %o0
if ( rv != 0 ) {
400053bc: 80 a2 20 00 cmp %o0, 0
400053c0: 02 bf ff f7 be 4000539c <open+0x144>
400053c4: 90 10 00 1d mov %i5, %o0
(*iop->pathinfo.handlers->close_h)( iop );
400053c8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400053cc: c2 00 60 04 ld [ %g1 + 4 ], %g1
400053d0: 9f c0 40 00 call %g1
400053d4: b0 10 3f ff mov -1, %i0
rtems_libio_free( iop );
400053d8: 40 00 22 74 call 4000dda8 <rtems_libio_free>
400053dc: 90 10 00 1d mov %i5, %o0
400053e0: 81 c7 e0 08 ret
400053e4: 81 e8 00 00 restore
400053e8: e0 07 bf 70 ld [ %fp + -144 ], %l0
rv = rtems_filesystem_mknod(
400053ec: 98 10 20 00 clr %o4
400053f0: 9a 10 20 00 clr %o5
400053f4: 17 00 00 20 sethi %hi(0x8000), %o3
400053f8: 94 10 00 1b mov %i3, %o2
400053fc: 96 16 80 0b or %i2, %o3, %o3
40005400: 92 10 00 10 mov %l0, %o1
40005404: 7f ff fe 4c call 40004d34 <rtems_filesystem_mknod>
40005408: 90 07 bf 80 add %fp, -128, %o0
if ( rv == 0 ) {
4000540c: 80 a2 20 00 cmp %o0, 0
40005410: 02 80 00 06 be 40005428 <open+0x1d0>
<== ALWAYS TAKEN
40005414: 92 10 20 00 clr %o1
rtems_filesystem_eval_path_error( ctx, 0 );
40005418: 40 00 01 1e call 40005890 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
4000541c: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
if ( write_access ) {
40005420: 10 bf ff af b 400052dc <open+0x84>
<== NOT EXECUTED
40005424: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
ctx->flags = flags;
40005428: c0 27 bf 78 clr [ %fp + -136 ]
rtems_filesystem_eval_path_continue( ctx );
4000542c: 90 07 bf 68 add %fp, -152, %o0
ctx->path = path;
40005430: e0 27 bf 68 st %l0, [ %fp + -152 ]
40005434: 40 00 01 5f call 400059b0 <rtems_filesystem_eval_path_continue>
40005438: f6 27 bf 6c st %i3, [ %fp + -148 ]
if ( write_access ) {
4000543c: 10 bf ff a8 b 400052dc <open+0x84>
40005440: 80 a7 20 00 cmp %i4, 0
rtems_filesystem_eval_path_error( &ctx, EISDIR );
40005444: 40 00 01 13 call 40005890 <rtems_filesystem_eval_path_error>
40005448: 90 07 bf 68 add %fp, -152, %o0
rtems_filesystem_location_copy_and_detach(
4000544c: 10 bf ff b3 b 40005318 <open+0xc0>
40005450: 92 07 bf 80 add %fp, -128, %o1
errno = ENFILE;
40005454: 40 00 26 c5 call 4000ef68 <__errno>
40005458: b0 10 3f ff mov -1, %i0
4000545c: 82 10 20 17 mov 0x17, %g1
40005460: c2 22 00 00 st %g1, [ %o0 ]
}
40005464: 81 c7 e0 08 ret
40005468: 81 e8 00 00 restore
4000e7a4 <posix_memalign>:
void **pointer,
size_t alignment,
size_t size
)
{
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
4000e7a4: 84 02 7f ff add %o1, -1, %g2
4000e7a8: 80 88 80 09 btst %g2, %o1
4000e7ac: 12 80 00 07 bne 4000e7c8 <posix_memalign+0x24>
<== NEVER TAKEN
4000e7b0: 80 a2 60 03 cmp %o1, 3
4000e7b4: 08 80 00 05 bleu 4000e7c8 <posix_memalign+0x24>
<== NEVER TAKEN
4000e7b8: 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 );
4000e7bc: 82 13 c0 00 mov %o7, %g1
4000e7c0: 40 00 00 6f call 4000e97c <rtems_memalign>
4000e7c4: 9e 10 40 00 mov %g1, %o7
}
4000e7c8: 81 c3 e0 08 retl
<== NOT EXECUTED
4000e7cc: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
400189ac <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
400189ac: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
400189b0: 80 a6 60 00 cmp %i1, 0
400189b4: 02 80 00 32 be 40018a7c <read+0xd0>
<== NEVER TAKEN
400189b8: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
400189bc: 02 80 00 22 be 40018a44 <read+0x98>
<== NEVER TAKEN
400189c0: 84 10 20 00 clr %g2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
400189c4: 03 10 00 64 sethi %hi(0x40019000), %g1
400189c8: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 400192e8 <rtems_libio_number_iops>
400189cc: 80 a6 00 01 cmp %i0, %g1
400189d0: 1a 80 00 25 bcc 40018a64 <read+0xb8>
<== NEVER TAKEN
400189d4: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
400189d8: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400189dc: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
400189e0: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400189e4: b0 16 22 28 or %i0, 0x228, %i0
<== NOT EXECUTED
400189e8: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400189ec: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400189f0: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400189f4: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400189f8: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400189fc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018a00: 01 00 00 00 nop
40018a04: 84 08 a1 02 and %g2, 0x102, %g2
40018a08: 80 a0 a1 02 cmp %g2, 0x102
40018a0c: 12 80 00 10 bne 40018a4c <read+0xa0>
40018a10: 94 10 00 1a mov %i2, %o2
/*
* Now process the read().
*/
n = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
40018a14: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40018a18: c2 00 60 08 ld [ %g1 + 8 ], %g1
40018a1c: 92 10 00 19 mov %i1, %o1
40018a20: 9f c0 40 00 call %g1
40018a24: 90 10 00 1d mov %i5, %o0
40018a28: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018a2c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40018a30: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
40018a34: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
40018a38: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018a3c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018a40: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return n;
}
40018a44: 81 c7 e0 08 ret
40018a48: 91 e8 00 02 restore %g0, %g2, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018a4c: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018a50: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40018a54: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018a58: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018a5c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018a60: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
40018a64: 7f ff dd c9 call 40010188 <__errno>
40018a68: 01 00 00 00 nop
40018a6c: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
40018a70: 84 10 3f ff mov -1, %g2
40018a74: 10 bf ff f4 b 40018a44 <read+0x98>
40018a78: c2 22 00 00 st %g1, [ %o0 ]
rtems_libio_check_buffer( buffer );
40018a7c: 7f ff dd c3 call 40010188 <__errno>
<== NOT EXECUTED
40018a80: 01 00 00 00 nop
<== NOT EXECUTED
40018a84: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40018a88: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40018a8c: 10 bf ff ee b 40018a44 <read+0x98>
<== NOT EXECUTED
40018a90: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000619c <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
4000619c: 9d e3 bf a0 save %sp, -96, %sp
if ( iov == NULL )
400061a0: 80 a6 60 00 cmp %i1, 0
400061a4: 02 80 00 3f be 400062a0 <readv+0x104>
400061a8: 80 a6 a0 00 cmp %i2, 0
if ( iovcnt <= 0 )
400061ac: 04 80 00 3d ble 400062a0 <readv+0x104>
400061b0: 80 a6 a4 00 cmp %i2, 0x400
if ( iovcnt > IOV_MAX )
400061b4: 14 80 00 3b bg 400062a0 <readv+0x104>
400061b8: bb 2e a0 03 sll %i2, 3, %i5
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
400061bc: 09 1f ff ff sethi %hi(0x7ffffc00), %g4
400061c0: 82 10 00 19 mov %i1, %g1
400061c4: ba 07 40 19 add %i5, %i1, %i5
total = 0;
400061c8: 96 10 20 00 clr %o3
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
400061cc: 88 11 23 ff or %g4, 0x3ff, %g4
size_t len = iov[ v ].iov_len;
400061d0: c4 00 60 04 ld [ %g1 + 4 ], %g2
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
400061d4: 86 21 00 0b sub %g4, %o3, %g3
400061d8: 80 a0 80 03 cmp %g2, %g3
400061dc: 18 80 00 31 bgu 400062a0 <readv+0x104>
400061e0: 01 00 00 00 nop
if ( iov[ v ].iov_base == NULL && len != 0 ) {
400061e4: c6 00 40 00 ld [ %g1 ], %g3
400061e8: 80 a0 e0 00 cmp %g3, 0
400061ec: 12 80 00 05 bne 40006200 <readv+0x64>
400061f0: 96 02 c0 02 add %o3, %g2, %o3
400061f4: 80 a0 a0 00 cmp %g2, 0
400061f8: 12 80 00 2a bne 400062a0 <readv+0x104>
400061fc: 01 00 00 00 nop
40006200: 82 00 60 08 add %g1, 8, %g1
for ( v = 0 ; v < iovcnt ; ++v ) {
40006204: 80 a7 40 01 cmp %i5, %g1
40006208: 32 bf ff f3 bne,a 400061d4 <readv+0x38>
4000620c: c4 00 60 04 ld [ %g1 + 4 ], %g2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
40006210: 03 10 00 43 sethi %hi(0x40010c00), %g1
40006214: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1 ! 40010ef8 <rtems_libio_number_iops>
40006218: 80 a6 00 01 cmp %i0, %g1
4000621c: 1a 80 00 2e bcc 400062d4 <readv+0x138>
40006220: bb 2e 20 01 sll %i0, 1, %i5
return &rtems_libio_iops[ fd ];
40006224: 03 10 00 50 sethi %hi(0x40014000), %g1
<== NOT EXECUTED
40006228: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
4000622c: 82 10 63 c8 or %g1, 0x3c8, %g1
<== NOT EXECUTED
40006230: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40006234: ba 07 40 01 add %i5, %g1, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006238: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000623c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40006240: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40006244: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006248: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000624c: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
40006250: 84 08 a1 02 and %g2, 0x102, %g2
40006254: 80 a0 a1 02 cmp %g2, 0x102
40006258: 12 80 00 19 bne 400062bc <readv+0x120>
4000625c: 80 a2 e0 00 cmp %o3, 0
if ( total > 0 ) {
40006260: 04 80 00 08 ble 40006280 <readv+0xe4>
40006264: 94 10 00 1a mov %i2, %o2
return ( *iop->pathinfo.handlers->readv_h )( iop, iov, iovcnt, total );
40006268: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000626c: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40006270: 92 10 00 19 mov %i1, %o1
40006274: 9f c0 40 00 call %g1
40006278: 90 10 00 1d mov %i5, %o0
4000627c: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006280: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40006284: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40006288: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000628c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006290: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006294: 01 00 00 00 nop
iov,
iovcnt,
LIBIO_FLAGS_READ,
readv_adapter
);
}
40006298: 81 c7 e0 08 ret
4000629c: 91 e8 00 0b restore %g0, %o3, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
400062a0: 40 00 23 a6 call 4000f138 <__errno>
400062a4: 01 00 00 00 nop
400062a8: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
400062ac: c2 22 00 00 st %g1, [ %o0 ]
400062b0: 96 10 3f ff mov -1, %o3
400062b4: 81 c7 e0 08 ret
400062b8: 91 e8 00 0b restore %g0, %o3, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400062bc: 91 d0 20 09 ta 9
<== NOT EXECUTED
400062c0: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400062c4: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400062c8: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400062cc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400062d0: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
400062d4: 40 00 23 99 call 4000f138 <__errno>
400062d8: 01 00 00 00 nop
400062dc: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
400062e0: 96 10 3f ff mov -1, %o3
400062e4: 10 bf ff f4 b 400062b4 <readv+0x118>
400062e8: c2 22 00 00 st %g1, [ %o0 ]
40016ac4 <realloc>:
return new_ptr;
}
void *realloc( void *ptr, size_t size )
{
40016ac4: 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 ) {
40016ac8: 80 a6 60 00 cmp %i1, 0
40016acc: 02 80 00 40 be 40016bcc <realloc+0x108>
<== NEVER TAKEN
40016ad0: 80 a6 20 00 cmp %i0, 0
free( ptr );
return NULL;
}
if ( ptr == NULL ) {
40016ad4: 02 80 00 34 be 40016ba4 <realloc+0xe0>
<== ALWAYS TAKEN
40016ad8: 03 10 00 65 sethi %hi(0x40019400), %g1
return malloc( size );
}
heap = RTEMS_Malloc_Heap;
switch ( _Malloc_System_state() ) {
40016adc: 7f ff b7 ea call 40004a84 <_Malloc_System_state>
<== NOT EXECUTED
40016ae0: fa 00 60 84 ld [ %g1 + 0x84 ], %i5 ! 40019484 <RTEMS_Malloc_Heap>
<== NOT EXECUTED
40016ae4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40016ae8: 02 80 00 21 be 40016b6c <realloc+0xa8>
<== NOT EXECUTED
40016aec: 01 00 00 00 nop
<== NOT EXECUTED
40016af0: 80 a2 20 01 cmp %o0, 1
<== NOT EXECUTED
40016af4: 32 80 00 2e bne,a 40016bac <realloc+0xe8>
<== NOT EXECUTED
40016af8: 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 );
40016afc: 98 07 bf fc add %fp, -4, %o4
<== NOT EXECUTED
40016b00: 96 07 bf f8 add %fp, -8, %o3
<== NOT EXECUTED
40016b04: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
40016b08: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40016b0c: 40 00 00 34 call 40016bdc <_Heap_Resize_block>
<== NOT EXECUTED
40016b10: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40016b14: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
break;
default:
return NULL;
}
switch ( status ) {
40016b18: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40016b1c: 02 80 00 12 be 40016b64 <realloc+0xa0>
<== NOT EXECUTED
40016b20: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
40016b24: 80 a7 20 01 cmp %i4, 1
<== NOT EXECUTED
40016b28: 12 80 00 23 bne 40016bb4 <realloc+0xf0>
<== NOT EXECUTED
40016b2c: f8 07 bf f8 ld [ %fp + -8 ], %i4
<== NOT EXECUTED
new_ptr = malloc( new_size );
40016b30: 7f ff b8 66 call 40004cc8 <malloc>
<== NOT EXECUTED
40016b34: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
if ( new_ptr == NULL ) {
40016b38: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
40016b3c: 02 80 00 0a be 40016b64 <realloc+0xa0>
<== NOT EXECUTED
40016b40: 80 a7 00 19 cmp %i4, %i1
<== NOT EXECUTED
memcpy( new_ptr, old_ptr, ( new_size < old_size ) ? new_size : old_size );
40016b44: 08 80 00 03 bleu 40016b50 <realloc+0x8c>
<== NOT EXECUTED
40016b48: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
40016b4c: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
40016b50: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40016b54: 7f ff e1 33 call 4000f020 <memcpy>
<== NOT EXECUTED
40016b58: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
free( old_ptr );
40016b5c: 7f ff b7 4a call 40004884 <free>
<== NOT EXECUTED
40016b60: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return new_alloc( ptr, size, old_size );
default:
errno = EINVAL;
return NULL;
}
}
40016b64: 81 c7 e0 08 ret
<== NOT EXECUTED
40016b68: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40016b6c: 7f ff c1 7b call 40007158 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40016b70: 01 00 00 00 nop
<== NOT EXECUTED
_Malloc_Process_deferred_frees();
40016b74: 7f ff b7 d3 call 40004ac0 <_Malloc_Process_deferred_frees>
<== NOT EXECUTED
40016b78: 01 00 00 00 nop
<== NOT EXECUTED
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
40016b7c: 98 07 bf fc add %fp, -4, %o4
<== NOT EXECUTED
40016b80: 96 07 bf f8 add %fp, -8, %o3
<== NOT EXECUTED
40016b84: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
40016b88: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40016b8c: 40 00 00 14 call 40016bdc <_Heap_Resize_block>
<== NOT EXECUTED
40016b90: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40016b94: 7f ff c1 76 call 4000716c <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
40016b98: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
break;
40016b9c: 10 bf ff e0 b 40016b1c <realloc+0x58>
<== NOT EXECUTED
40016ba0: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
return malloc( size );
40016ba4: 7f ff b8 49 call 40004cc8 <malloc>
40016ba8: 91 e8 00 19 restore %g0, %i1, %o0
}
40016bac: 81 c7 e0 08 ret
<== NOT EXECUTED
40016bb0: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
errno = EINVAL;
40016bb4: 7f ff e0 ed call 4000ef68 <__errno>
<== NOT EXECUTED
40016bb8: ba 10 20 00 clr %i5
<== NOT EXECUTED
40016bbc: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40016bc0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40016bc4: 81 c7 e0 08 ret
<== NOT EXECUTED
40016bc8: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
free( ptr );
40016bcc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40016bd0: 7f ff b7 2d call 40004884 <free>
<== NOT EXECUTED
40016bd4: ba 10 20 00 clr %i5
<== NOT EXECUTED
return NULL;
40016bd8: 30 bf ff e3 b,a 40016b64 <realloc+0xa0>
<== NOT EXECUTED
4000ed4c <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000ed4c: 9d e3 bf a0 save %sp, -96, %sp
4000ed50: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t local_value = 0;
4000ed54: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1) {
4000ed58: 10 80 00 04 b 4000ed68 <rtems_assoc_local_by_remote_bitfield+0x1c>
4000ed5c: ba 10 20 01 mov 1, %i5
4000ed60: 02 80 00 0c be 4000ed90 <rtems_assoc_local_by_remote_bitfield+0x44>
4000ed64: bb 2f 60 01 sll %i5, 1, %i5
if (b & remote_value)
4000ed68: 80 8e 40 1d btst %i1, %i5
4000ed6c: 22 bf ff fd be,a 4000ed60 <rtems_assoc_local_by_remote_bitfield+0x14>
4000ed70: b8 87 3f ff addcc %i4, -1, %i4
local_value |= rtems_assoc_local_by_remote(ap, b);
4000ed74: 92 10 00 1d mov %i5, %o1
4000ed78: 40 00 00 08 call 4000ed98 <rtems_assoc_local_by_remote>
4000ed7c: 90 10 00 18 mov %i0, %o0
for (b = 1; b; b <<= 1) {
4000ed80: bb 2f 60 01 sll %i5, 1, %i5
4000ed84: b8 87 3f ff addcc %i4, -1, %i4
4000ed88: 12 bf ff f8 bne 4000ed68 <rtems_assoc_local_by_remote_bitfield+0x1c>
<== ALWAYS TAKEN
4000ed8c: b6 16 c0 08 or %i3, %o0, %i3
}
return local_value;
}
4000ed90: 81 c7 e0 08 ret
4000ed94: 91 e8 00 1b restore %g0, %i3, %o0
4000cc88 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
4000cc88: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000cc8c: d0 06 00 00 ld [ %i0 ], %o0
{
4000cc90: ba 10 00 18 mov %i0, %i5
if (rtems_assoc_is_default(ap))
4000cc94: 80 a2 20 00 cmp %o0, 0
4000cc98: 02 80 00 16 be 4000ccf0 <rtems_assoc_ptr_by_local+0x68>
<== NEVER TAKEN
4000cc9c: b0 10 20 00 clr %i0
4000cca0: 13 10 00 45 sethi %hi(0x40011400), %o1
4000cca4: 40 00 09 92 call 4000f2ec <strcmp>
4000cca8: 92 12 60 78 or %o1, 0x78, %o1 ! 40011478 <IMFS_LIMITS_AND_OPTIONS+0x34>
4000ccac: 80 a2 20 00 cmp %o0, 0
4000ccb0: 22 80 00 12 be,a 4000ccf8 <rtems_assoc_ptr_by_local+0x70>
<== NEVER TAKEN
4000ccb4: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
4000ccb8: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000ccbc: 80 a6 40 01 cmp %i1, %g1
4000ccc0: 32 80 00 08 bne,a 4000cce0 <rtems_assoc_ptr_by_local+0x58>
<== ALWAYS TAKEN
4000ccc4: ba 07 60 0c add %i5, 0xc, %i5
for ( ; ap->name; ap++)
4000ccc8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000cccc: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
if (ap->local_value == local_value)
4000ccd0: 80 a0 40 19 cmp %g1, %i1
4000ccd4: 22 80 00 07 be,a 4000ccf0 <rtems_assoc_ptr_by_local+0x68>
4000ccd8: b0 10 00 1d mov %i5, %i0
for ( ; ap->name; ap++)
4000ccdc: ba 07 60 0c add %i5, 0xc, %i5
4000cce0: c2 07 40 00 ld [ %i5 ], %g1
4000cce4: 80 a0 60 00 cmp %g1, 0
4000cce8: 32 bf ff fa bne,a 4000ccd0 <rtems_assoc_ptr_by_local+0x48>
<== ALWAYS TAKEN
4000ccec: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000ccf0: 81 c7 e0 08 ret
4000ccf4: 81 e8 00 00 restore
default_ap = ap++;
4000ccf8: 82 07 60 0c add %i5, 0xc, %g1
<== NOT EXECUTED
for ( ; ap->name; ap++)
4000ccfc: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
4000cd00: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000cd04: 12 bf ff ed bne 4000ccb8 <rtems_assoc_ptr_by_local+0x30>
<== NOT EXECUTED
4000cd08: ba 10 00 01 mov %g1, %i5
<== NOT EXECUTED
4000cd0c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000cd10: 81 e8 00 00 restore
<== NOT EXECUTED
4000edc0 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000edc0: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000edc4: d0 06 00 00 ld [ %i0 ], %o0
{
4000edc8: ba 10 00 18 mov %i0, %i5
if (rtems_assoc_is_default(ap))
4000edcc: 80 a2 20 00 cmp %o0, 0
4000edd0: 02 80 00 16 be 4000ee28 <rtems_assoc_ptr_by_remote+0x68>
<== NEVER TAKEN
4000edd4: b0 10 20 00 clr %i0
4000edd8: 13 10 00 5f sethi %hi(0x40017c00), %o1
4000eddc: 40 00 01 c2 call 4000f4e4 <strcmp>
4000ede0: 92 12 61 68 or %o1, 0x168, %o1 ! 40017d68 <status_code_to_errno+0xa8>
4000ede4: 80 a2 20 00 cmp %o0, 0
4000ede8: 22 80 00 12 be,a 4000ee30 <rtems_assoc_ptr_by_remote+0x70>
<== NEVER TAKEN
4000edec: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
4000edf0: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000edf4: 80 a6 40 01 cmp %i1, %g1
4000edf8: 32 80 00 08 bne,a 4000ee18 <rtems_assoc_ptr_by_remote+0x58>
4000edfc: ba 07 60 0c add %i5, 0xc, %i5
for ( ; ap->name; ap++)
4000ee00: 81 c7 e0 08 ret
4000ee04: 91 e8 00 1d restore %g0, %i5, %o0
if (ap->remote_value == remote_value)
4000ee08: 80 a0 40 19 cmp %g1, %i1
4000ee0c: 22 80 00 07 be,a 4000ee28 <rtems_assoc_ptr_by_remote+0x68>
4000ee10: b0 10 00 1d mov %i5, %i0
for ( ; ap->name; ap++)
4000ee14: ba 07 60 0c add %i5, 0xc, %i5
4000ee18: c2 07 40 00 ld [ %i5 ], %g1
4000ee1c: 80 a0 60 00 cmp %g1, 0
4000ee20: 32 bf ff fa bne,a 4000ee08 <rtems_assoc_ptr_by_remote+0x48>
4000ee24: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000ee28: 81 c7 e0 08 ret
4000ee2c: 81 e8 00 00 restore
default_ap = ap++;
4000ee30: 82 07 60 0c add %i5, 0xc, %g1
<== NOT EXECUTED
for ( ; ap->name; ap++)
4000ee34: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
4000ee38: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000ee3c: 12 bf ff ed bne 4000edf0 <rtems_assoc_ptr_by_remote+0x30>
<== NOT EXECUTED
4000ee40: ba 10 00 01 mov %g1, %i5
<== NOT EXECUTED
4000ee44: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ee48: 81 e8 00 00 restore
<== NOT EXECUTED
4000e0f0 <rtems_deviceio_control>:
ioctl_command_t command,
void *buffer,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e0f0: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_ioctl_args_t args;
args.iop = iop;
4000e0f4: f0 27 bf f0 st %i0, [ %fp + -16 ]
<== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control( major, minor, &args );
4000e0f8: 94 07 bf f0 add %fp, -16, %o2
<== NOT EXECUTED
args.command = command;
4000e0fc: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_control( major, minor, &args );
4000e100: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = buffer;
4000e104: f4 27 bf f8 st %i2, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_control( major, minor, &args );
4000e108: 40 00 01 15 call 4000e55c <rtems_io_control>
<== NOT EXECUTED
4000e10c: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000e110: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e114: 12 80 00 05 bne 4000e128 <rtems_deviceio_control+0x38>
<== NOT EXECUTED
4000e118: 01 00 00 00 nop
<== NOT EXECUTED
return args.ioctl_return;
4000e11c: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000e120: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e124: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno(status);
4000e128: 40 00 00 df call 4000e4a4 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e12c: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000e130: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e134: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e010 <rtems_deviceio_read>:
void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e010: 9d e3 bf 80 save %sp, -128, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_rw_args_t args;
args.iop = iop;
args.offset = iop->offset;
4000e014: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
args.buffer = buf;
args.count = nbyte;
args.flags = iop->flags;
4000e018: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.iop = iop;
4000e01c: f0 27 bf e0 st %i0, [ %fp + -32 ]
<== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_read( major, minor, &args );
4000e020: 94 07 bf e0 add %fp, -32, %o2
<== NOT EXECUTED
args.offset = iop->offset;
4000e024: c4 3f bf e8 std %g2, [ %fp + -24 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000e028: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = buf;
4000e02c: f2 27 bf f0 st %i1, [ %fp + -16 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000e030: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
args.count = nbyte;
4000e034: f4 27 bf f4 st %i2, [ %fp + -12 ]
<== NOT EXECUTED
{
4000e038: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
args.flags = iop->flags;
4000e03c: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000e040: 40 00 01 8e call 4000e678 <rtems_io_read>
<== NOT EXECUTED
4000e044: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000e048: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e04c: 12 80 00 09 bne 4000e070 <rtems_deviceio_read+0x60>
<== NOT EXECUTED
4000e050: 01 00 00 00 nop
<== NOT EXECUTED
iop->offset += args.bytes_moved;
4000e054: f4 1f 40 00 ldd [ %i5 ], %i2
<== NOT EXECUTED
4000e058: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000e05c: 86 86 c0 18 addcc %i3, %i0, %g3
<== NOT EXECUTED
4000e060: 84 46 a0 00 addx %i2, 0, %g2
<== NOT EXECUTED
4000e064: c4 3f 40 00 std %g2, [ %i5 ]
<== NOT EXECUTED
return (ssize_t) args.bytes_moved;
4000e068: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e06c: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno( status );
4000e070: 40 00 01 0d call 4000e4a4 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e074: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000e078: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e07c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e080 <rtems_deviceio_write>:
const void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e080: 9d e3 bf 80 save %sp, -128, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_rw_args_t args;
args.iop = iop;
args.offset = iop->offset;
4000e084: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
args.buffer = RTEMS_DECONST( void *, buf );
args.count = nbyte;
args.flags = iop->flags;
4000e088: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.iop = iop;
4000e08c: f0 27 bf e0 st %i0, [ %fp + -32 ]
<== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_write( major, minor, &args );
4000e090: 94 07 bf e0 add %fp, -32, %o2
<== NOT EXECUTED
args.offset = iop->offset;
4000e094: c4 3f bf e8 std %g2, [ %fp + -24 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000e098: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = RTEMS_DECONST( void *, buf );
4000e09c: f2 27 bf f0 st %i1, [ %fp + -16 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000e0a0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
args.count = nbyte;
4000e0a4: f4 27 bf f4 st %i2, [ %fp + -12 ]
<== NOT EXECUTED
{
4000e0a8: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
args.flags = iop->flags;
4000e0ac: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000e0b0: 40 00 01 8a call 4000e6d8 <rtems_io_write>
<== NOT EXECUTED
4000e0b4: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000e0b8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e0bc: 12 80 00 09 bne 4000e0e0 <rtems_deviceio_write+0x60>
<== NOT EXECUTED
4000e0c0: 01 00 00 00 nop
<== NOT EXECUTED
iop->offset += args.bytes_moved;
4000e0c4: f4 1f 40 00 ldd [ %i5 ], %i2
<== NOT EXECUTED
4000e0c8: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000e0cc: 86 86 c0 18 addcc %i3, %i0, %g3
<== NOT EXECUTED
4000e0d0: 84 46 a0 00 addx %i2, 0, %g2
<== NOT EXECUTED
4000e0d4: c4 3f 40 00 std %g2, [ %i5 ]
<== NOT EXECUTED
return (ssize_t) args.bytes_moved;
4000e0d8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e0dc: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno( status );
4000e0e0: 40 00 00 f1 call 4000e4a4 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e0e4: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000e0e8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e0ec: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
40005550 <rtems_filesystem_check_access>:
int flags,
mode_t object_mode,
uid_t object_uid,
gid_t object_gid
)
{
40005550: 9d e3 bf a0 save %sp, -96, %sp
const rtems_user_env_t *uenv = rtems_current_user_env_get();
40005554: 7f ff ff dc call 400054c4 <rtems_current_user_env_get>
40005558: 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) {
4000555c: c2 12 20 10 lduh [ %o0 + 0x10 ], %g1
40005560: 80 a0 60 00 cmp %g1, 0
40005564: 02 80 00 24 be 400055f4 <rtems_filesystem_check_access+0xa4>
40005568: 80 a0 40 1a cmp %g1, %i2
4000556c: 22 80 00 23 be,a 400055f8 <rtems_filesystem_check_access+0xa8>
40005570: b1 2e 20 06 sll %i0, 6, %i0
access_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = uenv->egid;
if (
task_gid == 0
40005574: c2 12 20 12 lduh [ %o0 + 0x12 ], %g1
if (
40005578: 80 a0 60 00 cmp %g1, 0
4000557c: 02 80 00 18 be 400055dc <rtems_filesystem_check_access+0x8c>
<== ALWAYS TAKEN
40005580: 80 a0 40 1b cmp %g1, %i3
40005584: 22 80 00 17 be,a 400055e0 <rtems_filesystem_check_access+0x90>
<== NOT EXECUTED
40005588: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
4000558c: c6 02 20 24 ld [ %o0 + 0x24 ], %g3
<== NOT EXECUTED
40005590: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40005594: 22 80 00 14 be,a 400055e4 <rtems_filesystem_check_access+0x94>
<== NOT EXECUTED
40005598: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
if (uenv->groups[i] == object_gid) {
4000559c: c2 12 20 28 lduh [ %o0 + 0x28 ], %g1
<== NOT EXECUTED
400055a0: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
400055a4: 02 80 00 0e be 400055dc <rtems_filesystem_check_access+0x8c>
<== NOT EXECUTED
400055a8: 90 02 20 2a add %o0, 0x2a, %o0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
400055ac: 10 80 00 06 b 400055c4 <rtems_filesystem_check_access+0x74>
<== NOT EXECUTED
400055b0: 82 10 20 00 clr %g1
<== NOT EXECUTED
if (uenv->groups[i] == object_gid) {
400055b4: c4 12 3f fe lduh [ %o0 + -2 ], %g2
<== NOT EXECUTED
400055b8: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
400055bc: 22 80 00 09 be,a 400055e0 <rtems_filesystem_check_access+0x90>
<== NOT EXECUTED
400055c0: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
400055c4: 82 00 60 01 inc %g1
<== NOT EXECUTED
400055c8: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
400055cc: 12 bf ff fa bne 400055b4 <rtems_filesystem_check_access+0x64>
<== NOT EXECUTED
400055d0: 90 02 20 02 add %o0, 2, %o0
<== NOT EXECUTED
} else {
access_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (access_flags & object_mode) == access_flags;
400055d4: 10 80 00 04 b 400055e4 <rtems_filesystem_check_access+0x94>
<== NOT EXECUTED
400055d8: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
access_flags <<= RTEMS_FS_GRP_SHIFT;
400055dc: b1 2e 20 03 sll %i0, 3, %i0
return (access_flags & object_mode) == access_flags;
400055e0: b0 2e 00 19 andn %i0, %i1, %i0
}
400055e4: 80 a0 00 18 cmp %g0, %i0
400055e8: b0 60 3f ff subx %g0, -1, %i0
400055ec: 81 c7 e0 08 ret
400055f0: 81 e8 00 00 restore
access_flags <<= RTEMS_FS_USR_SHIFT;
400055f4: b1 2e 20 06 sll %i0, 6, %i0
return (access_flags & object_mode) == access_flags;
400055f8: b0 2e 00 19 andn %i0, %i1, %i0
}
400055fc: 80 a0 00 18 cmp %g0, %i0
40005600: b0 60 3f ff subx %g0, -1, %i0
40005604: 81 c7 e0 08 ret
40005608: 81 e8 00 00 restore
40004e1c <rtems_filesystem_chmod>:
int rtems_filesystem_chmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
40004e1c: 9d e3 bf 40 save %sp, -192, %sp
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40004e20: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
int rv;
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
40004e24: c2 0f 20 29 ldub [ %i4 + 0x29 ], %g1
{
40004e28: ba 10 00 18 mov %i0, %i5
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
40004e2c: 80 a0 60 00 cmp %g1, 0
40004e30: 12 80 00 07 bne 40004e4c <rtems_filesystem_chmod+0x30>
40004e34: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
40004e38: 03 10 00 43 sethi %hi(0x40010c00), %g1
40004e3c: 82 10 63 c8 or %g1, 0x3c8, %g1 ! 40010fc8 <rtems_filesystem_null_handlers>
40004e40: 80 a0 80 01 cmp %g2, %g1
40004e44: 12 80 00 3d bne 40004f38 <rtems_filesystem_chmod+0x11c>
<== NEVER TAKEN
40004e48: 01 00 00 00 nop
struct stat st;
memset( &st, 0, sizeof(st) );
40004e4c: c0 27 bf a0 clr [ %fp + -96 ]
rv = (*loc->handlers->fstat_h)( loc, &st );
40004e50: 92 07 bf a0 add %fp, -96, %o1
memset( &st, 0, sizeof(st) );
40004e54: c0 27 bf a4 clr [ %fp + -92 ]
40004e58: c0 27 bf a8 clr [ %fp + -88 ]
40004e5c: c0 27 bf ac clr [ %fp + -84 ]
40004e60: c0 27 bf b0 clr [ %fp + -80 ]
40004e64: c0 27 bf b4 clr [ %fp + -76 ]
40004e68: c0 27 bf b8 clr [ %fp + -72 ]
40004e6c: c0 27 bf bc clr [ %fp + -68 ]
40004e70: c0 27 bf c0 clr [ %fp + -64 ]
40004e74: c0 27 bf c4 clr [ %fp + -60 ]
40004e78: c0 27 bf c8 clr [ %fp + -56 ]
40004e7c: c0 27 bf cc clr [ %fp + -52 ]
40004e80: c0 27 bf d0 clr [ %fp + -48 ]
40004e84: c0 27 bf d4 clr [ %fp + -44 ]
40004e88: c0 27 bf d8 clr [ %fp + -40 ]
40004e8c: c0 27 bf dc clr [ %fp + -36 ]
40004e90: c0 27 bf e0 clr [ %fp + -32 ]
40004e94: c0 27 bf e4 clr [ %fp + -28 ]
40004e98: c0 27 bf e8 clr [ %fp + -24 ]
40004e9c: c0 27 bf ec clr [ %fp + -20 ]
40004ea0: c0 27 bf f0 clr [ %fp + -16 ]
40004ea4: c0 27 bf f4 clr [ %fp + -12 ]
40004ea8: c0 27 bf f8 clr [ %fp + -8 ]
40004eac: c0 27 bf fc clr [ %fp + -4 ]
rv = (*loc->handlers->fstat_h)( loc, &st );
40004eb0: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1
40004eb4: 9f c0 40 00 call %g1
40004eb8: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40004ebc: b0 92 20 00 orcc %o0, 0, %i0
40004ec0: 02 80 00 04 be 40004ed0 <rtems_filesystem_chmod+0xb4>
40004ec4: 01 00 00 00 nop
errno = EROFS;
rv = -1;
}
return rv;
}
40004ec8: 81 c7 e0 08 ret
40004ecc: 81 e8 00 00 restore
uid_t uid = geteuid();
40004ed0: 40 00 01 10 call 40005310 <geteuid>
40004ed4: 01 00 00 00 nop
if ( uid == 0 || st.st_uid == uid ) {
40004ed8: 91 2a 20 10 sll %o0, 0x10, %o0
40004edc: 91 32 20 10 srl %o0, 0x10, %o0
40004ee0: 80 a2 20 00 cmp %o0, 0
40004ee4: 12 80 00 0c bne 40004f14 <rtems_filesystem_chmod+0xf8>
40004ee8: c2 17 bf b2 lduh [ %fp + -78 ], %g1
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
40004eec: c2 07 20 0c ld [ %i4 + 0xc ], %g1
mode = (st.st_mode & ~mask) | (mode & mask);
40004ef0: d2 07 bf ac ld [ %fp + -84 ], %o1
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
40004ef4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
mode = (st.st_mode & ~mask) | (mode & mask);
40004ef8: b2 0e 6f ff and %i1, 0xfff, %i1
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
40004efc: 90 10 00 1d mov %i5, %o0
mode = (st.st_mode & ~mask) | (mode & mask);
40004f00: 92 0a 70 00 and %o1, -4096, %o1
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
40004f04: 9f c0 40 00 call %g1
40004f08: 92 12 40 19 or %o1, %i1, %o1
if ( uid == 0 || st.st_uid == uid ) {
40004f0c: 81 c7 e0 08 ret
40004f10: 91 e8 00 08 restore %g0, %o0, %o0
40004f14: 80 a0 40 08 cmp %g1, %o0
40004f18: 22 bf ff f6 be,a 40004ef0 <rtems_filesystem_chmod+0xd4>
40004f1c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
errno = EPERM;
40004f20: 40 00 28 2c call 4000efd0 <__errno>
40004f24: b0 10 3f ff mov -1, %i0
40004f28: 82 10 20 01 mov 1, %g1
40004f2c: c2 22 00 00 st %g1, [ %o0 ]
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
40004f30: 81 c7 e0 08 ret
40004f34: 81 e8 00 00 restore
errno = EROFS;
40004f38: 40 00 28 26 call 4000efd0 <__errno>
<== NOT EXECUTED
40004f3c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004f40: 82 10 20 1e mov 0x1e, %g1
<== NOT EXECUTED
40004f44: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40004f48: 81 c7 e0 08 ret
<== NOT EXECUTED
40004f4c: 81 e8 00 00 restore
<== NOT EXECUTED
40005048 <rtems_filesystem_chown>:
int rtems_filesystem_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
40005048: 9d e3 bf 40 save %sp, -192, %sp
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
4000504c: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
int rv;
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
40005050: c2 0f 20 29 ldub [ %i4 + 0x29 ], %g1
{
40005054: ba 10 00 18 mov %i0, %i5
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
40005058: 80 a0 60 00 cmp %g1, 0
4000505c: 12 80 00 07 bne 40005078 <rtems_filesystem_chown+0x30>
40005060: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
40005064: 03 10 00 43 sethi %hi(0x40010c00), %g1
40005068: 82 10 63 c8 or %g1, 0x3c8, %g1 ! 40010fc8 <rtems_filesystem_null_handlers>
4000506c: 80 a0 80 01 cmp %g2, %g1
40005070: 12 80 00 3b bne 4000515c <rtems_filesystem_chown+0x114>
<== NEVER TAKEN
40005074: 01 00 00 00 nop
struct stat st;
memset( &st, 0, sizeof(st) );
40005078: c0 27 bf a0 clr [ %fp + -96 ]
rv = (*loc->handlers->fstat_h)( loc, &st );
4000507c: 92 07 bf a0 add %fp, -96, %o1
memset( &st, 0, sizeof(st) );
40005080: c0 27 bf a4 clr [ %fp + -92 ]
40005084: c0 27 bf a8 clr [ %fp + -88 ]
40005088: c0 27 bf ac clr [ %fp + -84 ]
4000508c: c0 27 bf b0 clr [ %fp + -80 ]
40005090: c0 27 bf b4 clr [ %fp + -76 ]
40005094: c0 27 bf b8 clr [ %fp + -72 ]
40005098: c0 27 bf bc clr [ %fp + -68 ]
4000509c: c0 27 bf c0 clr [ %fp + -64 ]
400050a0: c0 27 bf c4 clr [ %fp + -60 ]
400050a4: c0 27 bf c8 clr [ %fp + -56 ]
400050a8: c0 27 bf cc clr [ %fp + -52 ]
400050ac: c0 27 bf d0 clr [ %fp + -48 ]
400050b0: c0 27 bf d4 clr [ %fp + -44 ]
400050b4: c0 27 bf d8 clr [ %fp + -40 ]
400050b8: c0 27 bf dc clr [ %fp + -36 ]
400050bc: c0 27 bf e0 clr [ %fp + -32 ]
400050c0: c0 27 bf e4 clr [ %fp + -28 ]
400050c4: c0 27 bf e8 clr [ %fp + -24 ]
400050c8: c0 27 bf ec clr [ %fp + -20 ]
400050cc: c0 27 bf f0 clr [ %fp + -16 ]
400050d0: c0 27 bf f4 clr [ %fp + -12 ]
400050d4: c0 27 bf f8 clr [ %fp + -8 ]
400050d8: c0 27 bf fc clr [ %fp + -4 ]
rv = (*loc->handlers->fstat_h)( loc, &st );
400050dc: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1
400050e0: 9f c0 40 00 call %g1
400050e4: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
400050e8: b0 92 20 00 orcc %o0, 0, %i0
400050ec: 02 80 00 04 be 400050fc <rtems_filesystem_chown+0xb4>
400050f0: 01 00 00 00 nop
errno = EROFS;
rv = -1;
}
return rv;
}
400050f4: 81 c7 e0 08 ret
400050f8: 81 e8 00 00 restore
uid_t uid = geteuid();
400050fc: 40 00 00 85 call 40005310 <geteuid>
40005100: 01 00 00 00 nop
if ( uid == 0 || st.st_uid == uid ) {
40005104: 91 2a 20 10 sll %o0, 0x10, %o0
40005108: 91 32 20 10 srl %o0, 0x10, %o0
4000510c: 80 a2 20 00 cmp %o0, 0
40005110: 12 80 00 0a bne 40005138 <rtems_filesystem_chown+0xf0>
40005114: c2 17 bf b2 lduh [ %fp + -78 ], %g1
rv = (*mt_entry->ops->chown_h)( loc, owner, group );
40005118: c2 07 20 0c ld [ %i4 + 0xc ], %g1
4000511c: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
40005120: 94 10 00 1a mov %i2, %o2
40005124: 92 10 00 19 mov %i1, %o1
40005128: 9f c0 40 00 call %g1
4000512c: 90 10 00 1d mov %i5, %o0
40005130: 81 c7 e0 08 ret
40005134: 91 e8 00 08 restore %g0, %o0, %o0
if ( uid == 0 || st.st_uid == uid ) {
40005138: 80 a0 40 08 cmp %g1, %o0
4000513c: 22 bf ff f8 be,a 4000511c <rtems_filesystem_chown+0xd4>
40005140: c2 07 20 0c ld [ %i4 + 0xc ], %g1
errno = EPERM;
40005144: 40 00 27 a3 call 4000efd0 <__errno>
40005148: b0 10 3f ff mov -1, %i0
4000514c: 82 10 20 01 mov 1, %g1
40005150: c2 22 00 00 st %g1, [ %o0 ]
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
40005154: 81 c7 e0 08 ret
40005158: 81 e8 00 00 restore
errno = EROFS;
4000515c: 40 00 27 9d call 4000efd0 <__errno>
<== NOT EXECUTED
40005160: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005164: 82 10 20 1e mov 0x1e, %g1
<== NOT EXECUTED
40005168: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
4000516c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005170: 81 e8 00 00 restore
<== NOT EXECUTED
40017850 <rtems_filesystem_default_pathconf>:
40017850: 00 00 00 05 00 00 00 80 00 00 00 07 00 00 00 ff ................
40017860: 00 00 00 ff 00 00 04 00 00 00 00 00 00 00 00 00 ................
40017870: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
40017880: 2e 00 00 00 00 00 00 00 2e 2e 00 00 ............
40005db4 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40005db4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_lock();
40005db8: 7f ff fb 29 call 40004a5c <rtems_libio_lock>
40005dbc: 01 00 00 00 nop
next = the_node->next;
40005dc0: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
40005dc4: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
40005dc8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
rtems_libio_unlock();
40005dcc: 7f ff fb 29 call 40004a70 <rtems_libio_unlock>
40005dd0: c4 20 40 00 st %g2, [ %g1 ]
release_with_count(global_loc, 1);
40005dd4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
40005dd8: 40 00 00 14 call 40005e28 <release_with_count>
40005ddc: 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);
40005de0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40005de4: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40005de8: 9f c0 40 00 call %g1
40005dec: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
40005df0: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
40005df4: 80 a2 20 00 cmp %o0, 0
40005df8: 02 80 00 07 be 40005e14 <rtems_filesystem_do_unmount+0x60>
<== NEVER TAKEN
40005dfc: 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 );
40005e00: 40 00 04 5f call 40006f7c <rtems_event_system_send>
40005e04: 13 20 00 00 sethi %hi(0x80000000), %o1
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
40005e08: 80 a2 20 00 cmp %o0, 0
40005e0c: 32 80 00 04 bne,a 40005e1c <rtems_filesystem_do_unmount+0x68>
<== NEVER TAKEN
40005e10: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
<== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
40005e14: 7f ff fa 9c call 40004884 <free>
<== NOT EXECUTED
40005e18: 81 e8 00 00 restore
rtems_fatal_error_occurred(0xdeadbeef);
40005e1c: 40 00 04 86 call 40007034 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40005e20: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
40005e24: 01 00 00 00 nop
<== NOT EXECUTED
4000622c <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;
4000622c: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
40006230: c4 02 20 04 ld [ %o0 + 4 ], %g2
40006234: 86 00 40 02 add %g1, %g2, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006238: 80 a0 40 03 cmp %g1, %g3
4000623c: 22 80 00 17 be,a 40006298 <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NEVER TAKEN
40006240: 84 10 20 00 clr %g2
<== NOT EXECUTED
return c == '/' || c == '\\';
40006244: c8 48 40 00 ldsb [ %g1 ], %g4
40006248: 80 a1 20 2f cmp %g4, 0x2f
4000624c: 02 80 00 04 be 4000625c <rtems_filesystem_eval_path_eat_delimiter+0x30>
40006250: 80 a1 20 5c cmp %g4, 0x5c
40006254: 32 80 00 11 bne,a 40006298 <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NEVER TAKEN
40006258: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
++current;
4000625c: 82 00 60 01 inc %g1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006260: 80 a0 c0 01 cmp %g3, %g1
40006264: 02 80 00 0d be 40006298 <rtems_filesystem_eval_path_eat_delimiter+0x6c>
40006268: 84 10 20 00 clr %g2
4000626c: c4 48 40 00 ldsb [ %g1 ], %g2
40006270: 80 a0 a0 2f cmp %g2, 0x2f
40006274: 02 bf ff fa be 4000625c <rtems_filesystem_eval_path_eat_delimiter+0x30>
40006278: 80 a0 a0 5c cmp %g2, 0x5c
4000627c: 22 bf ff f9 be,a 40006260 <rtems_filesystem_eval_path_eat_delimiter+0x34>
40006280: 82 00 60 01 inc %g1
40006284: 84 20 c0 01 sub %g3, %g1, %g2
++current;
40006288: 86 10 00 01 mov %g1, %g3
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
4000628c: c4 22 20 04 st %g2, [ %o0 + 4 ]
}
40006290: 81 c3 e0 08 retl
40006294: c6 22 00 00 st %g3, [ %o0 ]
ctx->path = current;
40006298: c6 22 00 00 st %g3, [ %o0 ]
}
4000629c: 81 c3 e0 08 retl
400062a0: c4 22 20 04 st %g2, [ %o0 + 4 ]
40005890 <rtems_filesystem_eval_path_error>:
{
40005890: 9d e3 bf a0 save %sp, -96, %sp
ctx->path = NULL;
40005894: c0 26 00 00 clr [ %i0 ]
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
40005898: 03 10 00 5e sethi %hi(0x40017800), %g1
ctx->pathlen = 0;
4000589c: c0 26 20 04 clr [ %i0 + 4 ]
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
400058a0: 82 10 60 d8 or %g1, 0xd8, %g1
ctx->token = NULL;
400058a4: c0 26 20 08 clr [ %i0 + 8 ]
ctx->tokenlen = 0;
400058a8: c0 26 20 0c clr [ %i0 + 0xc ]
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
400058ac: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
400058b0: 80 a0 80 01 cmp %g2, %g1
400058b4: 02 80 00 0b be 400058e0 <rtems_filesystem_eval_path_error+0x50>
400058b8: 80 a6 60 00 cmp %i1, 0
if (eno != 0) {
400058bc: 12 80 00 04 bne 400058cc <rtems_filesystem_eval_path_error+0x3c>
<== ALWAYS TAKEN
400058c0: 01 00 00 00 nop
rtems_filesystem_location_detach(&ctx->currentloc);
400058c4: 40 00 01 23 call 40005d50 <rtems_filesystem_location_detach>
<== NOT EXECUTED
400058c8: 91 ee 20 18 restore %i0, 0x18, %o0
<== NOT EXECUTED
errno = eno;
400058cc: 40 00 25 a7 call 4000ef68 <__errno>
400058d0: b0 06 20 18 add %i0, 0x18, %i0
400058d4: f2 22 00 00 st %i1, [ %o0 ]
rtems_filesystem_location_detach(&ctx->currentloc);
400058d8: 40 00 01 1e call 40005d50 <rtems_filesystem_location_detach>
400058dc: 81 e8 00 00 restore
}
400058e0: 81 c7 e0 08 ret
400058e4: 81 e8 00 00 restore
40005640 <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
)
{
40005640: 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);
40005644: 21 10 00 5e sethi %hi(0x40017800), %l0
{
40005648: ba 10 00 18 mov %i0, %i5
return &ctx->currentloc;
4000564c: a2 06 20 18 add %i0, 0x18, %l1
status = (*config->eval_token)(ctx, arg, "..", 2);
40005650: a0 14 20 88 or %l0, 0x88, %l0
status = (*config->eval_token)(ctx, arg, ".", 1);
40005654: 31 10 00 5e sethi %hi(0x40017800), %i0
40005658: b0 16 20 80 or %i0, 0x80, %i0 ! 40017880 <rtems_filesystem_default_pathconf+0x30>
rtems_filesystem_eval_path_next_token(ctx);
4000565c: 40 00 03 12 call 400062a4 <rtems_filesystem_eval_path_next_token>
40005660: 90 10 00 1d mov %i5, %o0
*tokenlen = ctx->tokenlen;
40005664: f8 07 60 0c ld [ %i5 + 0xc ], %i4
if (tokenlen > 0) {
40005668: 80 a7 20 00 cmp %i4, 0
4000566c: 02 80 00 19 be 400056d0 <rtems_filesystem_eval_path_generic+0x90>
40005670: f6 07 60 08 ld [ %i5 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
40005674: c2 06 80 00 ld [ %i2 ], %g1
40005678: 92 10 00 19 mov %i1, %o1
4000567c: 9f c0 40 00 call %g1
40005680: 90 10 00 1d mov %i5, %o0
40005684: 80 a2 20 00 cmp %o0, 0
40005688: 02 80 00 60 be 40005808 <rtems_filesystem_eval_path_generic+0x1c8>
4000568c: 80 a7 20 01 cmp %i4, 1
return tokenlen == 1 && token [0] == '.';
40005690: 02 80 00 12 be 400056d8 <rtems_filesystem_eval_path_generic+0x98>
40005694: 80 a7 20 02 cmp %i4, 2
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
40005698: 22 80 00 33 be,a 40005764 <rtems_filesystem_eval_path_generic+0x124>
4000569c: c2 4e c0 00 ldsb [ %i3 ], %g1
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
400056a0: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400056a4: 96 10 00 1c mov %i4, %o3
400056a8: 94 10 00 1b mov %i3, %o2
400056ac: 92 10 00 19 mov %i1, %o1
400056b0: 9f c0 40 00 call %g1
400056b4: 90 10 00 1d mov %i5, %o0
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
400056b8: 80 a2 20 02 cmp %o0, 2
400056bc: 22 80 00 19 be,a 40005720 <rtems_filesystem_eval_path_generic+0xe0>
400056c0: c2 07 60 04 ld [ %i5 + 4 ], %g1
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
400056c4: 80 a2 20 00 cmp %o0, 0
400056c8: 02 bf ff e5 be 4000565c <rtems_filesystem_eval_path_generic+0x1c>
400056cc: 01 00 00 00 nop
400056d0: 81 c7 e0 08 ret
400056d4: 81 e8 00 00 restore
return tokenlen == 1 && token [0] == '.';
400056d8: c2 4e c0 00 ldsb [ %i3 ], %g1
400056dc: 80 a0 60 2e cmp %g1, 0x2e
400056e0: 32 bf ff f1 bne,a 400056a4 <rtems_filesystem_eval_path_generic+0x64>
400056e4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (rtems_filesystem_eval_path_has_path(ctx)) {
400056e8: c2 07 60 04 ld [ %i5 + 4 ], %g1
400056ec: 80 a0 60 00 cmp %g1, 0
400056f0: 22 80 00 40 be,a 400057f0 <rtems_filesystem_eval_path_generic+0x1b0>
400056f4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
status = (*config->eval_token)(ctx, arg, ".", 1);
400056f8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400056fc: 96 10 20 01 mov 1, %o3
40005700: 94 10 00 18 mov %i0, %o2
40005704: 92 10 00 19 mov %i1, %o1
40005708: 9f c0 40 00 call %g1
4000570c: 90 10 00 1d mov %i5, %o0
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
40005710: 80 a2 20 02 cmp %o0, 2
40005714: 12 bf ff ed bne 400056c8 <rtems_filesystem_eval_path_generic+0x88>
<== ALWAYS TAKEN
40005718: 80 a2 20 00 cmp %o0, 0
if (rtems_filesystem_eval_path_has_path(ctx)) {
4000571c: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40005720: 80 a0 60 00 cmp %g1, 0
40005724: 12 80 00 04 bne 40005734 <rtems_filesystem_eval_path_generic+0xf4>
40005728: 01 00 00 00 nop
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
4000572c: 81 c7 e0 08 ret
40005730: 81 e8 00 00 restore
rtems_filesystem_eval_path_eat_delimiter(ctx);
40005734: 40 00 02 be call 4000622c <rtems_filesystem_eval_path_eat_delimiter>
40005738: 90 10 00 1d mov %i5, %o0
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
4000573c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
if (
40005740: 80 88 60 80 btst 0x80, %g1
40005744: 02 80 00 06 be 4000575c <rtems_filesystem_eval_path_generic+0x11c>
40005748: b2 10 20 02 mov 2, %i1
|| rtems_filesystem_eval_path_has_path(ctx)
4000574c: c2 07 60 04 ld [ %i5 + 4 ], %g1
40005750: 80 a0 60 00 cmp %g1, 0
40005754: 02 bf ff f6 be 4000572c <rtems_filesystem_eval_path_generic+0xec>
40005758: 01 00 00 00 nop
rtems_filesystem_eval_path_error(ctx, ENOENT);
4000575c: 40 00 00 4d call 40005890 <rtems_filesystem_eval_path_error>
40005760: 91 e8 00 1d restore %g0, %i5, %o0
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
40005764: 80 a0 60 2e cmp %g1, 0x2e
40005768: 32 bf ff cf bne,a 400056a4 <rtems_filesystem_eval_path_generic+0x64>
4000576c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40005770: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
40005774: 80 a0 60 2e cmp %g1, 0x2e
40005778: 32 bf ff cb bne,a 400056a4 <rtems_filesystem_eval_path_generic+0x64>
<== NEVER TAKEN
4000577c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40005780: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40005784: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
40005788: c4 00 60 0c ld [ %g1 + 0xc ], %g2
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
4000578c: c6 02 60 14 ld [ %o1 + 0x14 ], %g3
40005790: 80 a0 40 03 cmp %g1, %g3
40005794: 12 80 00 0a bne 400057bc <rtems_filesystem_eval_path_generic+0x17c>
40005798: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
4000579c: 9f c0 80 00 call %g2
400057a0: 90 10 00 11 mov %l1, %o0
400057a4: 80 a2 20 00 cmp %o0, 0
400057a8: 32 bf ff d5 bne,a 400056fc <rtems_filesystem_eval_path_generic+0xbc>
400057ac: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400057b0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
400057b4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400057b8: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
400057bc: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
400057c0: 9f c0 80 00 call %g2
400057c4: 90 10 00 11 mov %l1, %o0
} else if (is_fs_root(currentloc)) {
400057c8: 80 a2 20 00 cmp %o0, 0
400057cc: 12 80 00 12 bne 40005814 <rtems_filesystem_eval_path_generic+0x1d4>
400057d0: 96 10 20 02 mov 2, %o3
status = (*config->eval_token)(ctx, arg, "..", 2);
400057d4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400057d8: 94 10 00 10 mov %l0, %o2
400057dc: 92 10 00 19 mov %i1, %o1
400057e0: 9f c0 40 00 call %g1
400057e4: 90 10 00 1d mov %i5, %o0
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
400057e8: 10 bf ff b5 b 400056bc <rtems_filesystem_eval_path_generic+0x7c>
400057ec: 80 a2 20 02 cmp %o0, 2
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
400057f0: 80 88 61 00 btst 0x100, %g1
400057f4: 22 bf ff c2 be,a 400056fc <rtems_filesystem_eval_path_generic+0xbc>
<== ALWAYS TAKEN
400057f8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
rtems_filesystem_eval_path_error(ctx, EINVAL);
400057fc: b2 10 20 16 mov 0x16, %i1
<== NOT EXECUTED
40005800: 40 00 00 24 call 40005890 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005804: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
40005808: b2 10 20 14 mov 0x14, %i1
4000580c: 40 00 00 21 call 40005890 <rtems_filesystem_eval_path_error>
40005810: 91 e8 00 1d restore %g0, %i5, %o0
if (currentloc->mt_entry->mt_point_node != NULL) {
40005814: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40005818: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
4000581c: 80 a0 a0 00 cmp %g2, 0
40005820: 22 bf ff b7 be,a 400056fc <rtems_filesystem_eval_path_generic+0xbc>
<== NEVER TAKEN
40005824: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
size_t tokenlen = ctx->tokenlen;
40005828: c8 07 60 0c ld [ %i5 + 0xc ], %g4
ctx->path -= tokenlen;
4000582c: c6 07 40 00 ld [ %i5 ], %g3
ctx->pathlen += tokenlen;
40005830: c4 07 60 04 ld [ %i5 + 4 ], %g2
ctx->path -= tokenlen;
40005834: 86 20 c0 04 sub %g3, %g4, %g3
ctx->pathlen += tokenlen;
40005838: 84 00 80 04 add %g2, %g4, %g2
ctx->path -= tokenlen;
4000583c: c6 27 40 00 st %g3, [ %i5 ]
rtems_filesystem_eval_path_restart(
40005840: b2 00 60 20 add %g1, 0x20, %i1
ctx->pathlen += tokenlen;
40005844: c4 27 60 04 st %g2, [ %i5 + 4 ]
ctx->tokenlen = 0;
40005848: c0 27 60 0c clr [ %i5 + 0xc ]
4000584c: 40 00 00 e7 call 40005be8 <rtems_filesystem_eval_path_restart>
40005850: 91 e8 00 1d restore %g0, %i5, %o0
400062a4 <rtems_filesystem_eval_path_next_token>:
const char *current = ctx->path;
400062a4: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
400062a8: c6 02 20 04 ld [ %o0 + 4 ], %g3
400062ac: 86 00 40 03 add %g1, %g3, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
400062b0: 80 a0 40 03 cmp %g1, %g3
400062b4: 32 80 00 09 bne,a 400062d8 <rtems_filesystem_eval_path_next_token+0x34>
<== ALWAYS TAKEN
400062b8: c4 48 40 00 ldsb [ %g1 ], %g2
400062bc: 10 80 00 20 b 4000633c <rtems_filesystem_eval_path_next_token+0x98>
<== NOT EXECUTED
400062c0: 9a 10 20 00 clr %o5
<== NOT EXECUTED
++current;
400062c4: 82 00 60 01 inc %g1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
400062c8: 80 a0 c0 01 cmp %g3, %g1
400062cc: 22 80 00 22 be,a 40006354 <rtems_filesystem_eval_path_next_token+0xb0>
400062d0: 82 10 00 03 mov %g3, %g1
400062d4: c4 48 40 00 ldsb [ %g1 ], %g2
400062d8: 80 a0 a0 2f cmp %g2, 0x2f
400062dc: 02 bf ff fa be 400062c4 <rtems_filesystem_eval_path_next_token+0x20>
400062e0: 80 a0 a0 5c cmp %g2, 0x5c
400062e4: 22 bf ff f9 be,a 400062c8 <rtems_filesystem_eval_path_next_token+0x24>
400062e8: 82 00 60 01 inc %g1
ctx->path = current;
400062ec: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
400062f0: 9a 20 c0 01 sub %g3, %g1, %o5
400062f4: da 22 20 04 st %o5, [ %o0 + 4 ]
400062f8: 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)) {
400062fc: 80 a0 a0 5c cmp %g2, 0x5c
40006300: 02 80 00 1f be 4000637c <rtems_filesystem_eval_path_next_token+0xd8>
<== NEVER TAKEN
40006304: 80 a0 a0 2f cmp %g2, 0x2f
40006308: 02 80 00 1e be 40006380 <rtems_filesystem_eval_path_next_token+0xdc>
<== NEVER TAKEN
4000630c: 88 10 00 0d mov %o5, %g4
40006310: 10 80 00 07 b 4000632c <rtems_filesystem_eval_path_next_token+0x88>
40006314: 84 10 00 01 mov %g1, %g2
40006318: 80 a1 20 2f cmp %g4, 0x2f
4000631c: 02 80 00 10 be 4000635c <rtems_filesystem_eval_path_next_token+0xb8>
40006320: 80 a1 20 5c cmp %g4, 0x5c
40006324: 02 80 00 0f be 40006360 <rtems_filesystem_eval_path_next_token+0xbc>
40006328: 88 20 c0 02 sub %g3, %g2, %g4
++current;
4000632c: 84 00 a0 01 inc %g2
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40006330: 80 a0 80 03 cmp %g2, %g3
40006334: 32 bf ff f9 bne,a 40006318 <rtems_filesystem_eval_path_next_token+0x74>
40006338: c8 48 80 00 ldsb [ %g2 ], %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000633c: 88 10 20 00 clr %g4
}
ctx->path = current;
40006340: c6 22 00 00 st %g3, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
40006344: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
40006348: 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);
}
4000634c: 81 c3 e0 08 retl
40006350: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006354: 10 bf ff fa b 4000633c <rtems_filesystem_eval_path_next_token+0x98>
40006358: 9a 10 20 00 clr %o5
4000635c: 88 20 c0 02 sub %g3, %g2, %g4
40006360: 9a 20 80 01 sub %g2, %g1, %o5
++current;
40006364: 86 10 00 02 mov %g2, %g3
ctx->pathlen = (size_t) (end - current);
40006368: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->path = current;
4000636c: c6 22 00 00 st %g3, [ %o0 ]
ctx->token = begin;
40006370: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
40006374: 81 c3 e0 08 retl
40006378: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000637c: 88 10 00 0d mov %o5, %g4
<== NOT EXECUTED
40006380: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
40006384: 10 bf ff ef b 40006340 <rtems_filesystem_eval_path_next_token+0x9c>
<== NOT EXECUTED
40006388: 9a 10 20 00 clr %o5
<== NOT EXECUTED
40005c4c <rtems_filesystem_eval_path_recursive>:
{
40005c4c: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
40005c50: 80 a6 a0 00 cmp %i2, 0
40005c54: 02 80 00 22 be 40005cdc <rtems_filesystem_eval_path_recursive+0x90>
<== NEVER TAKEN
40005c58: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
40005c5c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40005c60: 80 a0 60 1f cmp %g1, 0x1f
40005c64: 14 80 00 20 bg 40005ce4 <rtems_filesystem_eval_path_recursive+0x98>
<== NEVER TAKEN
40005c68: 01 00 00 00 nop
return c == '/' || c == '\\';
40005c6c: c4 4e 40 00 ldsb [ %i1 ], %g2
const char *saved_path = ctx->path;
40005c70: f6 06 00 00 ld [ %i0 ], %i3
if (rtems_filesystem_is_delimiter(path [0])) {
40005c74: 80 a0 a0 2f cmp %g2, 0x2f
40005c78: 02 80 00 1d be 40005cec <rtems_filesystem_eval_path_recursive+0xa0>
40005c7c: f8 06 20 04 ld [ %i0 + 4 ], %i4
40005c80: 80 a0 a0 5c cmp %g2, 0x5c
40005c84: 02 80 00 1b be 40005cf0 <rtems_filesystem_eval_path_recursive+0xa4>
<== NEVER TAKEN
40005c88: 92 07 60 30 add %i5, 0x30, %o1
++ctx->recursionlevel;
40005c8c: 82 00 60 01 inc %g1
ctx->path = path;
40005c90: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
40005c94: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
40005c98: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
40005c9c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40005ca0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40005ca4: c2 00 60 08 ld [ %g1 + 8 ], %g1
40005ca8: 9f c0 40 00 call %g1
40005cac: 90 10 00 1d mov %i5, %o0
while (ctx->pathlen > 0) {
40005cb0: c2 07 60 04 ld [ %i5 + 4 ], %g1
40005cb4: 80 a0 60 00 cmp %g1, 0
40005cb8: 32 bf ff fa bne,a 40005ca0 <rtems_filesystem_eval_path_recursive+0x54>
40005cbc: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
--ctx->recursionlevel;
40005cc0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40005cc4: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
40005cc8: f6 27 40 00 st %i3, [ %i5 ]
--ctx->recursionlevel;
40005ccc: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
ctx->pathlen = saved_pathlen;
40005cd0: f8 27 60 04 st %i4, [ %i5 + 4 ]
}
40005cd4: 81 c7 e0 08 ret
40005cd8: 81 e8 00 00 restore
rtems_filesystem_eval_path_error(ctx, ENOENT);
40005cdc: 7f ff fe ed call 40005890 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005ce0: 93 e8 20 02 restore %g0, 2, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ELOOP);
40005ce4: 7f ff fe eb call 40005890 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005ce8: 93 e8 20 5c restore %g0, 0x5c, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
40005cec: 92 07 60 30 add %i5, 0x30, %o1
40005cf0: 7f ff ff be call 40005be8 <rtems_filesystem_eval_path_restart>
40005cf4: 90 10 00 1d mov %i5, %o0
40005cf8: 10 bf ff e5 b 40005c8c <rtems_filesystem_eval_path_recursive+0x40>
40005cfc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40006724 <rtems_filesystem_eval_path_start_with_parent>:
{
40006724: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
40006728: 40 00 23 7a call 4000f510 <strlen>
4000672c: 90 10 00 19 mov %i1, %o0
while (pathlen > 0) {
40006730: a0 92 20 00 orcc %o0, 0, %l0
40006734: 02 80 00 32 be 400067fc <rtems_filesystem_eval_path_start_with_parent+0xd8>
<== NEVER TAKEN
40006738: a2 10 00 19 mov %i1, %l1
size_t i = pathlen - 1;
4000673c: ba 04 3f ff add %l0, -1, %i5
return c == '/' || c == '\\';
40006740: c2 4e 40 1d ldsb [ %i1 + %i5 ], %g1
if (rtems_filesystem_is_delimiter(path [i])) {
40006744: 80 a0 60 2f cmp %g1, 0x2f
40006748: 02 80 00 30 be 40006808 <rtems_filesystem_eval_path_start_with_parent+0xe4>
<== NEVER TAKEN
4000674c: 80 a0 60 5c cmp %g1, 0x5c
40006750: 12 80 00 0c bne 40006780 <rtems_filesystem_eval_path_start_with_parent+0x5c>
<== ALWAYS TAKEN
40006754: 80 a7 60 00 cmp %i5, 0
40006758: 10 80 00 2e b 40006810 <rtems_filesystem_eval_path_start_with_parent+0xec>
<== NOT EXECUTED
4000675c: ba 10 00 10 mov %l0, %i5
<== NOT EXECUTED
40006760: c4 4e 40 01 ldsb [ %i1 + %g1 ], %g2
40006764: 80 a0 a0 2f cmp %g2, 0x2f
40006768: 02 80 00 21 be 400067ec <rtems_filesystem_eval_path_start_with_parent+0xc8>
4000676c: 80 a0 a0 5c cmp %g2, 0x5c
40006770: 02 80 00 20 be 400067f0 <rtems_filesystem_eval_path_start_with_parent+0xcc>
<== NEVER TAKEN
40006774: a2 10 00 19 mov %i1, %l1
size_t i = pathlen - 1;
40006778: ba 10 00 01 mov %g1, %i5
while (pathlen > 0) {
4000677c: 80 a7 60 00 cmp %i5, 0
40006780: 12 bf ff f8 bne 40006760 <rtems_filesystem_eval_path_start_with_parent+0x3c>
40006784: 82 07 7f ff add %i5, -1, %g1
parentpath = ".";
40006788: 23 10 00 43 sethi %hi(0x40010c00), %l1
parentpathlen = 1;
4000678c: ba 10 20 01 mov 1, %i5
parentpath = ".";
40006790: a2 14 63 70 or %l1, 0x370, %l1
&rtems_filesystem_root,
40006794: 7f ff fd f7 call 40005f70 <rtems_current_user_env_get>
40006798: 01 00 00 00 nop
&rtems_filesystem_current
4000679c: 7f ff fd f5 call 40005f70 <rtems_current_user_env_get>
400067a0: a4 10 00 08 mov %o0, %l2
currentloc = rtems_filesystem_eval_path_start_with_root_and_current(
400067a4: 98 04 a0 04 add %l2, 4, %o4
400067a8: 9a 10 00 08 mov %o0, %o5
400067ac: 96 10 00 1c mov %i4, %o3
400067b0: 94 10 00 1d mov %i5, %o2
400067b4: 92 10 00 11 mov %l1, %o1
400067b8: 7f ff ff 79 call 4000659c <rtems_filesystem_eval_path_start_with_root_and_current>
400067bc: 90 10 00 18 mov %i0, %o0
rtems_filesystem_location_clone(parentloc, currentloc);
400067c0: 92 10 00 08 mov %o0, %o1
400067c4: 40 00 1c 4e call 4000d8fc <rtems_filesystem_location_clone>
400067c8: 90 10 00 1b mov %i3, %o0
ctx->path = name;
400067cc: f2 26 00 00 st %i1, [ %i0 ]
rtems_filesystem_eval_path_continue(ctx);
400067d0: 90 10 00 18 mov %i0, %o0
ctx->pathlen = namelen;
400067d4: e0 26 20 04 st %l0, [ %i0 + 4 ]
return &ctx->currentloc;
400067d8: b0 06 20 18 add %i0, 0x18, %i0
rtems_filesystem_eval_path_continue(ctx);
400067dc: 7f ff ff 53 call 40006528 <rtems_filesystem_eval_path_continue>
400067e0: f4 26 3f f8 st %i2, [ %i0 + -8 ]
}
400067e4: 81 c7 e0 08 ret
400067e8: 81 e8 00 00 restore
name = path + parentpathlen;
400067ec: a2 10 00 19 mov %i1, %l1
400067f0: a0 24 00 1d sub %l0, %i5, %l0
400067f4: 10 bf ff e8 b 40006794 <rtems_filesystem_eval_path_start_with_parent+0x70>
400067f8: b2 06 40 1d add %i1, %i5, %i1
return 0;
400067fc: ba 10 20 00 clr %i5
<== NOT EXECUTED
const char *name = NULL;
40006800: 10 bf ff e5 b 40006794 <rtems_filesystem_eval_path_start_with_parent+0x70>
<== NOT EXECUTED
40006804: b2 10 20 00 clr %i1
<== NOT EXECUTED
if (rtems_filesystem_is_delimiter(path [i])) {
40006808: ba 10 00 10 mov %l0, %i5
<== NOT EXECUTED
name = path + parentpathlen;
4000680c: a2 10 00 19 mov %i1, %l1
<== NOT EXECUTED
if (rtems_filesystem_is_delimiter(path [i])) {
40006810: a0 10 20 00 clr %l0
<== NOT EXECUTED
name = path + parentpathlen;
40006814: 10 bf ff e0 b 40006794 <rtems_filesystem_eval_path_start_with_parent+0x70>
<== NOT EXECUTED
40006818: b2 06 40 1d add %i1, %i5, %i1
<== NOT EXECUTED
40005a24 <rtems_filesystem_eval_path_start_with_root_and_current>:
{
40005a24: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
40005a28: 94 10 20 30 mov 0x30, %o2
40005a2c: 92 10 20 00 clr %o1
40005a30: 40 00 25 b8 call 4000f110 <memset>
40005a34: 90 06 20 08 add %i0, 8, %o0
ctx->path = path;
40005a38: f2 26 00 00 st %i1, [ %i0 ]
if (ctx->pathlen > 0) {
40005a3c: 80 a6 a0 00 cmp %i2, 0
ctx->pathlen = pathlen;
40005a40: f4 26 20 04 st %i2, [ %i0 + 4 ]
if (ctx->pathlen > 0) {
40005a44: 02 80 00 1d be 40005ab8 <rtems_filesystem_eval_path_start_with_root_and_current+0x94>
40005a48: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
40005a4c: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
40005a50: 40 00 01 22 call 40005ed8 <rtems_filesystem_global_location_obtain>
40005a54: 90 10 00 1c mov %i4, %o0
return c == '/' || c == '\\';
40005a58: 83 2e e0 18 sll %i3, 0x18, %g1
40005a5c: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
40005a60: 80 a0 60 2f cmp %g1, 0x2f
40005a64: 02 80 00 2f be 40005b20 <rtems_filesystem_eval_path_start_with_root_and_current+0xfc>
40005a68: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
40005a6c: 80 a0 60 5c cmp %g1, 0x5c
40005a70: 22 80 00 2d be,a 40005b24 <rtems_filesystem_eval_path_start_with_root_and_current+0x100>
<== NEVER TAKEN
40005a74: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain(
40005a78: 40 00 01 18 call 40005ed8 <rtems_filesystem_global_location_obtain>
40005a7c: 90 10 00 1d mov %i5, %o0
40005a80: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
40005a84: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40005a88: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005a8c: c2 00 40 00 ld [ %g1 ], %g1
40005a90: 9f c0 40 00 call %g1
40005a94: ba 06 20 18 add %i0, 0x18, %i5
rtems_filesystem_location_clone(
40005a98: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40005a9c: 40 00 20 33 call 4000db68 <rtems_filesystem_location_clone>
40005aa0: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
40005aa4: 90 10 00 18 mov %i0, %o0
40005aa8: 7f ff ff c2 call 400059b0 <rtems_filesystem_eval_path_continue>
40005aac: b0 10 00 1d mov %i5, %i0
}
40005ab0: 81 c7 e0 08 ret
40005ab4: 81 e8 00 00 restore
rtems_filesystem_global_location_t *global_loc = NULL;
40005ab8: c0 27 bf fc clr [ %fp + -4 ]
return rtems_filesystem_global_location_obtain( &global_loc );
40005abc: 40 00 01 07 call 40005ed8 <rtems_filesystem_global_location_obtain>
40005ac0: 90 07 bf fc add %fp, -4, %o0
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
40005ac4: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
40005ac8: 90 07 bf fc add %fp, -4, %o0
40005acc: 40 00 01 03 call 40005ed8 <rtems_filesystem_global_location_obtain>
40005ad0: c0 27 bf fc clr [ %fp + -4 ]
ctx->startloc = rtems_filesystem_global_location_obtain_null();
40005ad4: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
errno = ENOENT;
40005ad8: 40 00 25 24 call 4000ef68 <__errno>
40005adc: ba 06 20 18 add %i0, 0x18, %i5
40005ae0: 82 10 20 02 mov 2, %g1
40005ae4: c2 22 00 00 st %g1, [ %o0 ]
40005ae8: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
40005aec: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40005af0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005af4: c2 00 40 00 ld [ %g1 ], %g1
40005af8: 9f c0 40 00 call %g1
40005afc: 01 00 00 00 nop
rtems_filesystem_location_clone(
40005b00: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40005b04: 40 00 20 19 call 4000db68 <rtems_filesystem_location_clone>
40005b08: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
40005b0c: 90 10 00 18 mov %i0, %o0
40005b10: 7f ff ff a8 call 400059b0 <rtems_filesystem_eval_path_continue>
40005b14: b0 10 00 1d mov %i5, %i0
}
40005b18: 81 c7 e0 08 ret
40005b1c: 81 e8 00 00 restore
++ctx->path;
40005b20: c4 06 00 00 ld [ %i0 ], %g2
--ctx->pathlen;
40005b24: c2 06 20 04 ld [ %i0 + 4 ], %g1
++ctx->path;
40005b28: 84 00 a0 01 inc %g2
--ctx->pathlen;
40005b2c: 82 00 7f ff add %g1, -1, %g1
++ctx->path;
40005b30: c4 26 00 00 st %g2, [ %i0 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
40005b34: 90 06 20 30 add %i0, 0x30, %o0
--ctx->pathlen;
40005b38: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
40005b3c: 40 00 00 e7 call 40005ed8 <rtems_filesystem_global_location_obtain>
40005b40: ba 06 20 18 add %i0, 0x18, %i5
40005b44: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
40005b48: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
40005b4c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005b50: c2 00 40 00 ld [ %g1 ], %g1
40005b54: 9f c0 40 00 call %g1
40005b58: 01 00 00 00 nop
rtems_filesystem_location_clone(
40005b5c: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40005b60: 40 00 20 02 call 4000db68 <rtems_filesystem_location_clone>
40005b64: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
40005b68: 90 10 00 18 mov %i0, %o0
40005b6c: 7f ff ff 91 call 400059b0 <rtems_filesystem_eval_path_continue>
40005b70: b0 10 00 1d mov %i5, %i0
}
40005b74: 81 c7 e0 08 ret
40005b78: 81 e8 00 00 restore
4000decc <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000decc: 9d e3 bf 98 save %sp, -104, %sp
4000ded0: 82 10 00 18 mov %i0, %g1
find_arg fa = {
4000ded4: c0 27 bf fc clr [ %fp + -4 ]
4000ded8: b0 10 20 00 clr %i0
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
4000dedc: 80 a0 60 00 cmp %g1, 0
4000dee0: 02 80 00 07 be 4000defc <rtems_filesystem_get_mount_handler+0x30>
<== NEVER TAKEN
4000dee4: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_filesystem_iterate( find_handler, &fa );
4000dee8: 92 07 bf f8 add %fp, -8, %o1
4000deec: 11 10 00 37 sethi %hi(0x4000dc00), %o0
4000def0: 7f ff ff cb call 4000de1c <rtems_filesystem_iterate>
4000def4: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 4000dde8 <find_handler>
4000def8: f0 07 bf fc ld [ %fp + -4 ], %i0
}
return fa.mount_h;
}
4000defc: 81 c7 e0 08 ret
4000df00: 81 e8 00 00 restore
40006028 <rtems_filesystem_global_location_assign>:
{
40006028: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000602c: 91 d0 20 09 ta 9
<== NOT EXECUTED
lhs_global_loc = *lhs_global_loc_ptr;
40006030: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
*lhs_global_loc_ptr = rhs_global_loc;
40006034: d2 20 80 00 st %o1, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006038: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000603c: 01 00 00 00 nop
rtems_filesystem_global_location_release(lhs_global_loc, true);
40006040: 92 10 20 01 mov 1, %o1 ! 1 <_TLS_Alignment>
40006044: 82 13 c0 00 mov %o7, %g1
40006048: 7f ff ff de call 40005fc0 <rtems_filesystem_global_location_release>
4000604c: 9e 10 40 00 mov %g1, %o7
40005ed8 <rtems_filesystem_global_location_obtain>:
{
40005ed8: 9d e3 bf 98 save %sp, -104, %sp
if (deferred_released_global_locations != NULL) {
40005edc: 3b 10 00 69 sethi %hi(0x4001a400), %i5
40005ee0: c2 07 63 70 ld [ %i5 + 0x370 ], %g1 ! 4001a770 <deferred_released_global_locations>
40005ee4: 80 a0 60 00 cmp %g1, 0
40005ee8: 02 80 00 1e be 40005f60 <rtems_filesystem_global_location_obtain+0x88>
40005eec: 01 00 00 00 nop
40005ef0: ba 17 63 70 or %i5, 0x370, %i5
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005ef4: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
40005ef8: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
40005efc: 80 a2 20 00 cmp %o0, 0
40005f00: 02 80 00 07 be 40005f1c <rtems_filesystem_global_location_obtain+0x44>
<== NEVER TAKEN
40005f04: 92 10 20 00 clr %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
40005f08: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
<== NOT EXECUTED
count = current->deferred_released_count;
40005f0c: d2 02 20 20 ld [ %o0 + 0x20 ], %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
40005f10: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
current->deferred_released_next = NULL;
40005f14: c0 22 20 1c clr [ %o0 + 0x1c ]
<== NOT EXECUTED
current->deferred_released_count = 0;
40005f18: c0 22 20 20 clr [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005f1c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005f20: 01 00 00 00 nop
if (current != NULL) {
40005f24: 80 a2 20 00 cmp %o0, 0
40005f28: 02 80 00 0e be 40005f60 <rtems_filesystem_global_location_obtain+0x88>
<== NEVER TAKEN
40005f2c: 01 00 00 00 nop
release_with_count(current, count);
40005f30: 7f ff ff be call 40005e28 <release_with_count>
40005f34: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005f38: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
40005f3c: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
40005f40: 80 a2 20 00 cmp %o0, 0
40005f44: 12 bf ff f1 bne 40005f08 <rtems_filesystem_global_location_obtain+0x30>
40005f48: 92 10 20 00 clr %o1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005f4c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005f50: 01 00 00 00 nop
if (current != NULL) {
40005f54: 80 a2 20 00 cmp %o0, 0
40005f58: 12 bf ff f6 bne 40005f30 <rtems_filesystem_global_location_obtain+0x58>
<== NEVER TAKEN
40005f5c: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005f60: 91 d0 20 09 ta 9
<== NOT EXECUTED
global_loc = *global_loc_ptr;
40005f64: f0 06 00 00 ld [ %i0 ], %i0
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
40005f68: 80 a6 20 00 cmp %i0, 0
40005f6c: 02 80 00 07 be 40005f88 <rtems_filesystem_global_location_obtain+0xb0>
40005f70: 01 00 00 00 nop
40005f74: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
40005f78: c4 08 a0 28 ldub [ %g2 + 0x28 ], %g2
40005f7c: 80 a0 a0 00 cmp %g2, 0
40005f80: 32 80 00 0a bne,a 40005fa8 <rtems_filesystem_global_location_obtain+0xd0>
<== ALWAYS TAKEN
40005f84: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
errno = ENXIO;
40005f88: 40 00 23 f8 call 4000ef68 <__errno>
40005f8c: c2 27 bf fc st %g1, [ %fp + -4 ]
40005f90: 84 10 20 06 mov 6, %g2
<== NOT EXECUTED
40005f94: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
global_loc = &rtems_filesystem_global_location_null;
40005f98: 31 10 00 65 sethi %hi(0x40019400), %i0
<== NOT EXECUTED
40005f9c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
40005fa0: b0 16 21 10 or %i0, 0x110, %i0
<== NOT EXECUTED
++global_loc->reference_count;
40005fa4: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
<== NOT EXECUTED
40005fa8: 84 00 a0 01 inc %g2
<== NOT EXECUTED
40005fac: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005fb0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005fb4: 01 00 00 00 nop
}
40005fb8: 81 c7 e0 08 ret
40005fbc: 81 e8 00 00 restore
40005fc0 <rtems_filesystem_global_location_release>:
if (!deferred) {
40005fc0: 80 a2 60 00 cmp %o1, 0
40005fc4: 22 80 00 16 be,a 4000601c <rtems_filesystem_global_location_release+0x5c>
40005fc8: 92 10 20 01 mov 1, %o1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005fcc: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (global_loc->deferred_released_count == 0) {
40005fd0: c6 02 20 20 ld [ %o0 + 0x20 ], %g3
40005fd4: 80 a0 e0 00 cmp %g3, 0
40005fd8: 22 80 00 08 be,a 40005ff8 <rtems_filesystem_global_location_release+0x38>
40005fdc: 07 10 00 69 sethi %hi(0x4001a400), %g3
++global_loc->deferred_released_count;
40005fe0: 86 00 e0 01 inc %g3
<== NOT EXECUTED
40005fe4: c6 22 20 20 st %g3, [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005fe8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005fec: 01 00 00 00 nop
}
40005ff0: 81 c3 e0 08 retl
40005ff4: 01 00 00 00 nop
rtems_filesystem_global_location_t *head =
40005ff8: c8 00 e3 70 ld [ %g3 + 0x370 ], %g4
global_loc->deferred_released_next = head;
40005ffc: c8 22 20 1c st %g4, [ %o0 + 0x1c ]
global_loc->deferred_released_count = 1;
40006000: 88 10 20 01 mov 1, %g4
deferred_released_global_locations = global_loc;
40006004: d0 20 e3 70 st %o0, [ %g3 + 0x370 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 1;
40006008: c8 22 20 20 st %g4, [ %o0 + 0x20 ]
<== NOT EXECUTED
4000600c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006010: 01 00 00 00 nop
}
40006014: 81 c3 e0 08 retl
40006018: 01 00 00 00 nop
release_with_count(global_loc, 1);
4000601c: 82 13 c0 00 mov %o7, %g1
40006020: 7f ff ff 82 call 40005e28 <release_with_count>
40006024: 9e 10 40 00 mov %g1, %o7
40004784 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40004784: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40004788: 05 10 00 5c sethi %hi(0x40017000), %g2
4000478c: 82 10 a3 44 or %g2, 0x344, %g1 ! 40017344 <rtems_filesystem_root_configuration>
40004790: d0 00 a3 44 ld [ %g2 + 0x344 ], %o0
40004794: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
40004798: d6 00 60 0c ld [ %g1 + 0xc ], %o3
4000479c: d4 00 60 08 ld [ %g1 + 8 ], %o2
400047a0: 40 00 01 a6 call 40004e38 <mount>
400047a4: d2 00 60 04 ld [ %g1 + 4 ], %o1
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
400047a8: 80 a2 20 00 cmp %o0, 0
400047ac: 12 80 00 0a bne 400047d4 <rtems_filesystem_initialize+0x50>
<== NEVER TAKEN
400047b0: 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 );
400047b4: 11 10 00 5d sethi %hi(0x40017400), %o0
400047b8: 40 00 01 58 call 40004d18 <mkdir>
400047bc: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 400177e0 <IMFS_node_control_sym_link+0x14>
if ( rv != 0 )
400047c0: 80 a2 20 00 cmp %o0, 0
400047c4: 12 80 00 07 bne 400047e0 <rtems_filesystem_initialize+0x5c>
<== NEVER TAKEN
400047c8: 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.
*/
}
400047cc: 81 c7 e0 08 ret
400047d0: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xABCD0002 );
400047d4: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
<== NOT EXECUTED
400047d8: 40 00 0a 17 call 40007034 <rtems_fatal_error_occurred>
<== NOT EXECUTED
400047dc: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0x6b8d0002>
<== NOT EXECUTED
rtems_fatal_error_occurred( 0xABCD0003 );
400047e0: 40 00 0a 15 call 40007034 <rtems_fatal_error_occurred>
<== NOT EXECUTED
400047e4: 90 12 20 03 or %o0, 3, %o0
<== NOT EXECUTED
400047e8: 01 00 00 00 nop
<== NOT EXECUTED
4000de1c <rtems_filesystem_iterate>:
{
4000de1c: 9d e3 bf a0 save %sp, -96, %sp
while ( table_entry->type && !stop ) {
4000de20: 3b 10 00 5c sethi %hi(0x40017000), %i5
4000de24: c2 07 63 c0 ld [ %i5 + 0x3c0 ], %g1 ! 400173c0 <rtems_filesystem_table>
4000de28: 80 a0 60 00 cmp %g1, 0
4000de2c: 12 80 00 06 bne 4000de44 <rtems_filesystem_iterate+0x28>
<== ALWAYS TAKEN
4000de30: ba 17 63 c0 or %i5, 0x3c0, %i5
4000de34: 30 80 00 0f b,a 4000de70 <rtems_filesystem_iterate+0x54>
<== NOT EXECUTED
4000de38: 80 a2 20 00 cmp %o0, 0
4000de3c: 32 80 00 22 bne,a 4000dec4 <rtems_filesystem_iterate+0xa8>
4000de40: b8 0f 20 ff and %i4, 0xff, %i4
stop = (*routine)( table_entry, routine_arg );
4000de44: 90 10 00 1d mov %i5, %o0
4000de48: 9f c6 00 00 call %i0
4000de4c: 92 10 00 19 mov %i1, %o1
++table_entry;
4000de50: ba 07 60 08 add %i5, 8, %i5
while ( table_entry->type && !stop ) {
4000de54: c2 07 40 00 ld [ %i5 ], %g1
4000de58: 80 a0 60 00 cmp %g1, 0
4000de5c: 12 bf ff f7 bne 4000de38 <rtems_filesystem_iterate+0x1c>
4000de60: b8 10 00 08 mov %o0, %i4
if ( !stop ) {
4000de64: b8 8a 20 ff andcc %o0, 0xff, %i4
4000de68: 12 80 00 17 bne 4000dec4 <rtems_filesystem_iterate+0xa8>
4000de6c: 01 00 00 00 nop
rtems_libio_lock();
4000de70: 7f ff da fb call 40004a5c <rtems_libio_lock>
4000de74: 37 10 00 65 sethi %hi(0x40019400), %i3
return _Chain_Immutable_head( the_chain )->next;
4000de78: fa 06 e3 00 ld [ %i3 + 0x300 ], %i5 ! 40019700 <filesystem_chain>
4000de7c: b6 16 e3 00 or %i3, 0x300, %i3
for (
4000de80: b6 06 e0 04 add %i3, 4, %i3
4000de84: 80 a7 40 1b cmp %i5, %i3
4000de88: 12 80 00 06 bne 4000dea0 <rtems_filesystem_iterate+0x84>
<== NEVER TAKEN
4000de8c: b8 10 20 00 clr %i4
4000de90: 30 80 00 0b b,a 4000debc <rtems_filesystem_iterate+0xa0>
!rtems_chain_is_tail( chain, node ) && !stop;
4000de94: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000de98: 12 80 00 09 bne 4000debc <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
4000de9c: 01 00 00 00 nop
<== NOT EXECUTED
stop = (*routine)( &fsn->entry, routine_arg );
4000dea0: 90 07 60 08 add %i5, 8, %o0
<== NOT EXECUTED
4000dea4: 9f c6 00 00 call %i0
<== NOT EXECUTED
4000dea8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000deac: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
for (
4000deb0: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
4000deb4: 12 bf ff f8 bne 4000de94 <rtems_filesystem_iterate+0x78>
<== NOT EXECUTED
4000deb8: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rtems_libio_unlock();
4000debc: 7f ff da ed call 40004a70 <rtems_libio_unlock>
4000dec0: b8 0f 20 ff and %i4, 0xff, %i4
}
4000dec4: 81 c7 e0 08 ret
4000dec8: 91 e8 00 1c restore %g0, %i4, %o0
40005d00 <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;
40005d00: da 02 60 08 ld [ %o1 + 8 ], %o5
dst->node_access_2 = src->node_access_2;
40005d04: c8 02 60 0c ld [ %o1 + 0xc ], %g4
dst->handlers = src->handlers;
40005d08: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
dst->mt_entry = src->mt_entry;
40005d0c: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
40005d10: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40005d14: da 22 20 08 st %o5, [ %o0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005d18: c8 22 20 0c st %g4, [ %o0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005d1c: c6 22 20 10 st %g3, [ %o0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005d20: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
40005d24: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
<== NOT EXECUTED
old_last = tail->previous;
40005d28: c8 00 e0 1c ld [ %g3 + 0x1c ], %g4
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005d2c: 9a 00 e0 18 add %g3, 0x18, %o5
<== NOT EXECUTED
the_node->next = tail;
40005d30: da 22 00 00 st %o5, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005d34: d0 20 e0 1c st %o0, [ %g3 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005d38: d0 21 00 00 st %o0, [ %g4 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005d3c: c8 22 20 04 st %g4, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005d40: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005d44: 01 00 00 00 nop
rtems_chain_initialize_node(&dst->mt_entry_node);
rtems_filesystem_location_add_to_mt_entry(dst);
return dst;
}
40005d48: 81 c3 e0 08 retl
40005d4c: 01 00 00 00 nop
400060d4 <rtems_filesystem_location_copy_and_detach>:
{
400060d4: 9d e3 bf a0 save %sp, -96, %sp
dst->node_access = src->node_access;
400060d8: c8 06 60 08 ld [ %i1 + 8 ], %g4
dst->node_access_2 = src->node_access_2;
400060dc: c6 06 60 0c ld [ %i1 + 0xc ], %g3
dst->handlers = src->handlers;
400060e0: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
dst->mt_entry = src->mt_entry;
400060e4: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
400060e8: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
dst->node_access = src->node_access;
400060ec: c8 26 20 08 st %g4, [ %i0 + 8 ]
dst->node_access_2 = src->node_access_2;
400060f0: c6 26 20 0c st %g3, [ %i0 + 0xc ]
dst->handlers = src->handlers;
400060f4: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400060f8: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
400060fc: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40006100: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006104: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006108: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
4000610c: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40006110: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006114: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006118: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000611c: 01 00 00 00 nop
rtems_filesystem_location_remove_from_mt_entry(detach);
40006120: 7f ff ff cc call 40006050 <rtems_filesystem_location_remove_from_mt_entry>
40006124: 90 10 00 19 mov %i1, %o0
dst->node_access = src->node_access;
40006128: 03 10 00 65 sethi %hi(0x40019400), %g1
4000612c: 82 10 61 10 or %g1, 0x110, %g1 ! 40019510 <rtems_filesystem_global_location_null>
40006130: c4 00 60 08 ld [ %g1 + 8 ], %g2
40006134: c4 26 60 08 st %g2, [ %i1 + 8 ]
dst->node_access_2 = src->node_access_2;
40006138: c4 00 60 0c ld [ %g1 + 0xc ], %g2
4000613c: c4 26 60 0c st %g2, [ %i1 + 0xc ]
dst->handlers = src->handlers;
40006140: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
dst->mt_entry = src->mt_entry;
40006144: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
40006148: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
4000614c: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006150: 91 d0 20 09 ta 9
<== NOT EXECUTED
40006154: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
old_last = tail->previous;
40006158: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
return &the_chain->Tail.Node;
4000615c: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006160: c8 26 40 00 st %g4, [ %i1 ]
<== NOT EXECUTED
tail->previous = the_node;
40006164: f2 20 a0 1c st %i1, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40006168: f2 20 c0 00 st %i1, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000616c: c6 26 60 04 st %g3, [ %i1 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006170: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006174: 01 00 00 00 nop
}
40006178: 81 c7 e0 08 ret
4000617c: 81 e8 00 00 restore
40005d50 <rtems_filesystem_location_detach>:
void rtems_filesystem_location_detach(
rtems_filesystem_location_info_t *detach
)
{
40005d50: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_free(detach);
40005d54: 40 00 1f 98 call 4000dbb4 <rtems_filesystem_location_free>
40005d58: 90 10 00 18 mov %i0, %o0
dst->node_access = src->node_access;
40005d5c: 03 10 00 65 sethi %hi(0x40019400), %g1
<== NOT EXECUTED
40005d60: 82 10 61 10 or %g1, 0x110, %g1 ! 40019510 <rtems_filesystem_global_location_null>
<== NOT EXECUTED
40005d64: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
40005d68: c4 26 20 08 st %g2, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005d6c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40005d70: c4 26 20 0c st %g2, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005d74: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40005d78: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
40005d7c: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005d80: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005d84: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005d88: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40005d8c: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005d90: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40005d94: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005d98: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005d9c: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005da0: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005da4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005da8: 01 00 00 00 nop
rtems_filesystem_location_initialize_to_null(detach);
}
40005dac: 81 c7 e0 08 ret
40005db0: 81 e8 00 00 restore
40006050 <rtems_filesystem_location_remove_from_mt_entry>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006050: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous = the_node->previous;
40006054: c6 02 20 04 ld [ %o0 + 4 ], %g3
next = the_node->next;
40006058: c8 02 00 00 ld [ %o0 ], %g4
next->previous = previous;
4000605c: c6 21 20 04 st %g3, [ %g4 + 4 ]
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
40006060: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
previous->next = next;
40006064: c8 20 c0 00 st %g4, [ %g3 ]
40006068: c6 08 a0 28 ldub [ %g2 + 0x28 ], %g3
4000606c: 80 a0 e0 00 cmp %g3, 0
40006070: 12 80 00 07 bne 4000608c <rtems_filesystem_location_remove_from_mt_entry+0x3c>
40006074: 01 00 00 00 nop
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
40006078: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
4000607c: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
40006080: 80 a1 00 03 cmp %g4, %g3
40006084: 22 80 00 06 be,a 4000609c <rtems_filesystem_location_remove_from_mt_entry+0x4c>
40006088: c6 00 a0 24 ld [ %g2 + 0x24 ], %g3
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000608c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006090: 01 00 00 00 nop
}
40006094: 81 c3 e0 08 retl
40006098: 01 00 00 00 nop
&& mt_entry->mt_fs_root->reference_count == 1;
4000609c: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3
400060a0: 80 a0 e0 01 cmp %g3, 1
400060a4: 12 bf ff fa bne 4000608c <rtems_filesystem_location_remove_from_mt_entry+0x3c>
<== ALWAYS TAKEN
400060a8: 86 00 a0 14 add %g2, 0x14, %g3
return &the_chain->Tail.Node;
400060ac: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
head->previous = NULL;
400060b0: c0 20 a0 18 clr [ %g2 + 0x18 ]
<== NOT EXECUTED
head->next = tail;
400060b4: c8 20 a0 14 st %g4, [ %g2 + 0x14 ]
<== NOT EXECUTED
tail->previous = head;
400060b8: c6 20 a0 1c st %g3, [ %g2 + 0x1c ]
<== NOT EXECUTED
400060bc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400060c0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
400060c4: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
400060c8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400060cc: 7f ff ff 3a call 40005db4 <rtems_filesystem_do_unmount>
<== NOT EXECUTED
400060d0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40006180 <rtems_filesystem_location_transform_to_global>:
{
40006180: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
40006184: 7f ff fa d1 call 40004cc8 <malloc>
40006188: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
4000618c: ba 92 20 00 orcc %o0, 0, %i5
40006190: 02 80 00 1c be 40006200 <rtems_filesystem_location_transform_to_global+0x80>
<== NEVER TAKEN
40006194: b8 10 20 01 mov 1, %i4
dst->node_access = src->node_access;
40006198: c8 06 20 08 ld [ %i0 + 8 ], %g4
dst->node_access_2 = src->node_access_2;
4000619c: c6 06 20 0c ld [ %i0 + 0xc ], %g3
<== NOT EXECUTED
dst->handlers = src->handlers;
400061a0: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
400061a4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
global_loc->deferred_released_next = NULL;
400061a8: c0 27 60 1c clr [ %i5 + 0x1c ]
<== NOT EXECUTED
global_loc->reference_count = 1;
400061ac: f8 27 60 18 st %i4, [ %i5 + 0x18 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 0;
400061b0: c0 27 60 20 clr [ %i5 + 0x20 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
400061b4: c8 27 60 08 st %g4, [ %i5 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
400061b8: c6 27 60 0c st %g3, [ %i5 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
400061bc: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
400061c0: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400061c4: 91 d0 20 09 ta 9
<== NOT EXECUTED
400061c8: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
400061cc: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
400061d0: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
400061d4: c8 27 40 00 st %g4, [ %i5 ]
<== NOT EXECUTED
tail->previous = the_node;
400061d8: fa 20 a0 1c st %i5, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
400061dc: fa 20 c0 00 st %i5, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
400061e0: c6 27 60 04 st %g3, [ %i5 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400061e4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400061e8: 01 00 00 00 nop
rtems_filesystem_location_remove_from_mt_entry(loc);
400061ec: 90 10 00 18 mov %i0, %o0
400061f0: 7f ff ff 98 call 40006050 <rtems_filesystem_location_remove_from_mt_entry>
400061f4: b0 10 00 1d mov %i5, %i0
}
400061f8: 81 c7 e0 08 ret
400061fc: 81 e8 00 00 restore
rtems_filesystem_location_free(loc);
40006200: 40 00 1e 6d call 4000dbb4 <rtems_filesystem_location_free>
<== NOT EXECUTED
40006204: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
40006208: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
4000620c: 7f ff ff 33 call 40005ed8 <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40006210: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
errno = ENOMEM;
40006214: 40 00 23 55 call 4000ef68 <__errno>
<== NOT EXECUTED
40006218: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
4000621c: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40006220: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40006224: 81 c7 e0 08 ret
<== NOT EXECUTED
40006228: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40004d34 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40004d34: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
40004d38: 40 00 01 e3 call 400054c4 <rtems_current_user_env_get>
40004d3c: 01 00 00 00 nop
40004d40: d6 02 20 08 ld [ %o0 + 8 ], %o3
40004d44: 96 2e c0 0b andn %i3, %o3, %o3
switch (mode & S_IFMT) {
40004d48: 03 00 00 3c sethi %hi(0xf000), %g1
40004d4c: 05 00 00 10 sethi %hi(0x4000), %g2
40004d50: 82 0a c0 01 and %o3, %g1, %g1
40004d54: 80 a0 40 02 cmp %g1, %g2
40004d58: 22 80 00 0c be,a 40004d88 <rtems_filesystem_mknod+0x54>
40004d5c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40004d60: 08 80 00 14 bleu 40004db0 <rtems_filesystem_mknod+0x7c>
40004d64: 05 00 00 04 sethi %hi(0x1000), %g2
40004d68: 05 00 00 18 sethi %hi(0x6000), %g2
40004d6c: 80 a0 40 02 cmp %g1, %g2
40004d70: 02 80 00 05 be 40004d84 <rtems_filesystem_mknod+0x50>
<== NEVER TAKEN
40004d74: 05 00 00 20 sethi %hi(0x8000), %g2
40004d78: 80 a0 40 02 cmp %g1, %g2
40004d7c: 12 80 00 13 bne 40004dc8 <rtems_filesystem_mknod+0x94>
<== NEVER TAKEN
40004d80: 01 00 00 00 nop
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
40004d84: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
40004d88: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40004d8c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40004d90: 98 10 00 1c mov %i4, %o4
40004d94: 9a 10 00 1d mov %i5, %o5
40004d98: 94 10 00 1a mov %i2, %o2
40004d9c: 92 10 00 19 mov %i1, %o1
40004da0: 9f c0 40 00 call %g1
40004da4: 90 10 00 18 mov %i0, %o0
40004da8: 81 c7 e0 08 ret
40004dac: 91 e8 00 08 restore %g0, %o0, %o0
switch (mode & S_IFMT) {
40004db0: 80 a0 40 02 cmp %g1, %g2
40004db4: 02 bf ff f4 be 40004d84 <rtems_filesystem_mknod+0x50>
40004db8: 05 00 00 08 sethi %hi(0x2000), %g2
40004dbc: 80 a0 40 02 cmp %g1, %g2
40004dc0: 22 bf ff f2 be,a 40004d88 <rtems_filesystem_mknod+0x54>
40004dc4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
errno = EINVAL;
40004dc8: 40 00 28 68 call 4000ef68 <__errno>
40004dcc: b0 10 3f ff mov -1, %i0
40004dd0: 82 10 20 16 mov 0x16, %g1
40004dd4: c2 22 00 00 st %g1, [ %o0 ]
}
return rv;
}
40004dd8: 81 c7 e0 08 ret
40004ddc: 81 e8 00 00 restore
400178d8 <rtems_filesystem_null_handlers>:
400178d8: 40 00 63 8c 40 00 d5 a8 40 00 d7 fc 40 00 d8 94 @.c.@...@...@...
400178e8: 40 00 d6 30 40 00 d7 b4 40 00 63 94 40 00 d6 14 @..0@...@.c.@...
400178f8: 40 00 d5 d4 40 00 d5 d4 40 00 d5 c4 40 00 d7 f4 @...@...@...@...
40017908: 40 00 d6 4c 40 00 d8 18 40 00 d8 b0 40 00 d7 d0 @..L@...@...@...
40017918: 52 54 45 4d 53 00 00 00 4e 6f 64 65 20 25 68 64 RTEMS...Node %hd
...
40017930: 35 2e 30 2e 30 00 00 00 77 2f 46 50 55 00 00 00 5.0.0...w/FPU...
40017940: 53 50 41 52 43 00 00 00 25 73 2f 25 73 00 00 00 SPARC...%s/%s...
40004b24 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
40004b24: 9d e3 bf a0 save %sp, -96, %sp
40004b28: 03 10 00 6b sethi %hi(0x4001ac00), %g1
40004b2c: c2 00 61 c4 ld [ %g1 + 0x1c4 ], %g1 ! 4001adc4 <_System_state_Current>
Heap_Control *heap = RTEMS_Malloc_Heap;
40004b30: 05 10 00 65 sethi %hi(0x40019400), %g2
if ( _System_state_Is_up( state ) ) {
40004b34: 80 a0 60 02 cmp %g1, 2
40004b38: 02 80 00 21 be 40004bbc <rtems_heap_allocate_aligned_with_boundary+0x98>
40004b3c: f8 00 a0 84 ld [ %g2 + 0x84 ], %i4
} else if ( _System_state_Is_before_multitasking( state ) ) {
40004b40: 80 a0 60 01 cmp %g1, 1
40004b44: 02 80 00 22 be 40004bcc <rtems_heap_allocate_aligned_with_boundary+0xa8>
40004b48: 96 10 00 1a mov %i2, %o3
boundary
);
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
p = _Heap_Allocate_aligned_with_boundary(
40004b4c: 94 10 00 19 mov %i1, %o2
40004b50: 92 10 00 18 mov %i0, %o1
40004b54: 40 00 09 ec call 40007304 <_Heap_Allocate_aligned_with_boundary>
40004b58: 90 10 00 1c mov %i4, %o0
40004b5c: 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 ) {
40004b60: 80 a7 60 00 cmp %i5, 0
40004b64: 12 80 00 0b bne 40004b90 <rtems_heap_allocate_aligned_with_boundary+0x6c>
40004b68: 80 a6 60 00 cmp %i1, 0
40004b6c: 12 80 00 09 bne 40004b90 <rtems_heap_allocate_aligned_with_boundary+0x6c>
<== NEVER TAKEN
40004b70: 80 a6 a0 00 cmp %i2, 0
40004b74: 12 80 00 23 bne 40004c00 <rtems_heap_allocate_aligned_with_boundary+0xdc>
<== NEVER TAKEN
40004b78: 03 10 00 5c sethi %hi(0x40017000), %g1
p = (*rtems_malloc_extend_handler)( heap, size );
40004b7c: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 400172e8 <rtems_malloc_extend_handler>
40004b80: 92 10 00 18 mov %i0, %o1
40004b84: 9f c0 40 00 call %g1
40004b88: 90 10 00 1c mov %i4, %o0
40004b8c: 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 )
40004b90: 80 a7 60 00 cmp %i5, 0
40004b94: 02 80 00 1b be 40004c00 <rtems_heap_allocate_aligned_with_boundary+0xdc>
40004b98: 03 10 00 66 sethi %hi(0x40019800), %g1
40004b9c: c2 00 62 8c ld [ %g1 + 0x28c ], %g1 ! 40019a8c <rtems_malloc_dirty_helper>
40004ba0: 80 a0 60 00 cmp %g1, 0
40004ba4: 02 80 00 04 be 40004bb4 <rtems_heap_allocate_aligned_with_boundary+0x90>
<== ALWAYS TAKEN
40004ba8: 92 10 00 18 mov %i0, %o1
(*rtems_malloc_dirty_helper)( p, size );
40004bac: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004bb0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return p;
}
40004bb4: 81 c7 e0 08 ret
40004bb8: 91 e8 00 1d restore %g0, %i5, %o0
40004bbc: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
if ( _Thread_Dispatch_is_enabled() ) {
40004bc0: 80 a0 60 00 cmp %g1, 0
40004bc4: 32 80 00 10 bne,a 40004c04 <rtems_heap_allocate_aligned_with_boundary+0xe0>
<== NEVER TAKEN
40004bc8: ba 10 20 00 clr %i5
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40004bcc: 40 00 09 63 call 40007158 <_RTEMS_Lock_allocator>
40004bd0: 01 00 00 00 nop
_Malloc_Process_deferred_frees();
40004bd4: 7f ff ff bb call 40004ac0 <_Malloc_Process_deferred_frees>
40004bd8: 01 00 00 00 nop
p = _Heap_Allocate_aligned_with_boundary(
40004bdc: 96 10 00 1a mov %i2, %o3
40004be0: 94 10 00 19 mov %i1, %o2
40004be4: 92 10 00 18 mov %i0, %o1
40004be8: 40 00 09 c7 call 40007304 <_Heap_Allocate_aligned_with_boundary>
40004bec: 90 10 00 1c mov %i4, %o0
_RTEMS_Unlock_allocator();
40004bf0: 40 00 09 5f call 4000716c <_RTEMS_Unlock_allocator>
40004bf4: ba 10 00 08 mov %o0, %i5
break;
40004bf8: 10 bf ff db b 40004b64 <rtems_heap_allocate_aligned_with_boundary+0x40>
40004bfc: 80 a7 60 00 cmp %i5, 0
return NULL;
40004c00: ba 10 20 00 clr %i5
}
40004c04: 81 c7 e0 08 ret
40004c08: 91 e8 00 1d restore %g0, %i5, %o0
400054f0 <rtems_libio_free_user_env>:
if (!uses_global_env) {
400054f0: 03 10 00 65 sethi %hi(0x40019400), %g1
<== NOT EXECUTED
400054f4: 82 10 60 c8 or %g1, 0xc8, %g1 ! 400194c8 <rtems_global_user_env>
<== NOT EXECUTED
400054f8: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
400054fc: 02 80 00 05 be 40005510 <rtems_libio_free_user_env+0x20>
<== NOT EXECUTED
40005500: 01 00 00 00 nop
<== NOT EXECUTED
40005504: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40005508: 7f ff ff e6 call 400054a0 <rtems_libio_free_user_env.part.1>
<== NOT EXECUTED
4000550c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
}
}
40005510: 81 c3 e0 08 retl
<== NOT EXECUTED
40005514: 01 00 00 00 nop
<== NOT EXECUTED
400051e0 <rtems_libio_post_driver>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void rtems_libio_post_driver(void)
{
400051e0: 9d e3 bf a0 save %sp, -96, %sp
/*
* Attempt to open /dev/console.
*/
if ( open( CONSOLE_DEVICE_NAME, O_RDONLY, 0 ) != STDIN_FILENO ) {
400051e4: 94 10 20 00 clr %o2
400051e8: 92 10 20 00 clr %o1
400051ec: 3b 10 00 5d sethi %hi(0x40017400), %i5
400051f0: 40 00 00 1a call 40005258 <open>
400051f4: 90 17 63 e8 or %i5, 0x3e8, %o0 ! 400177e8 <IMFS_node_control_sym_link+0x1c>
400051f8: 80 a2 20 00 cmp %o0, 0
400051fc: 02 80 00 04 be 4000520c <rtems_libio_post_driver+0x2c>
<== ALWAYS TAKEN
40005200: 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);
}
40005204: 81 c7 e0 08 ret
<== NOT EXECUTED
40005208: 81 e8 00 00 restore
<== NOT EXECUTED
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDOUT_FILENO ) {
4000520c: 92 10 20 01 mov 1, %o1
40005210: 40 00 00 12 call 40005258 <open>
40005214: 90 17 63 e8 or %i5, 0x3e8, %o0
40005218: 80 a2 20 01 cmp %o0, 1
4000521c: 12 80 00 0a bne 40005244 <rtems_libio_post_driver+0x64>
<== NEVER TAKEN
40005220: 94 10 20 00 clr %o2
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
40005224: 92 10 20 01 mov 1, %o1
40005228: 40 00 00 0c call 40005258 <open>
4000522c: 90 17 63 e8 or %i5, 0x3e8, %o0
40005230: 80 a2 20 02 cmp %o0, 2
40005234: 12 80 00 06 bne 4000524c <rtems_libio_post_driver+0x6c>
<== NEVER TAKEN
40005238: 31 10 00 37 sethi %hi(0x4000dc00), %i0
atexit(rtems_libio_exit);
4000523c: 40 00 27 44 call 4000ef4c <atexit>
40005240: 91 ee 21 00 restore %i0, 0x100, %o0
_Internal_error( INTERNAL_ERROR_LIBIO_STDOUT_FD_OPEN_FAILED );
40005244: 40 00 09 d7 call 400079a0 <_Internal_error>
<== NOT EXECUTED
40005248: 90 10 20 24 mov 0x24, %o0
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
4000524c: 40 00 09 d5 call 400079a0 <_Internal_error>
<== NOT EXECUTED
40005250: 90 10 20 25 mov 0x25, %o0
<== NOT EXECUTED
40005254: 01 00 00 00 nop
<== NOT EXECUTED
400050a4 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
400050a4: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = pthread_getspecific(rtems_current_user_env_key);
400050a8: 39 10 00 49 sethi %hi(0x40012400), %i4
400050ac: 40 00 04 62 call 40006234 <pthread_getspecific>
400050b0: d0 07 20 f0 ld [ %i4 + 0xf0 ], %o0 ! 400124f0 <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) {
400050b4: 3b 10 00 43 sethi %hi(0x40010c00), %i5
400050b8: ba 17 61 50 or %i5, 0x150, %i5 ! 40010d50 <rtems_global_user_env>
400050bc: 80 a2 00 1d cmp %o0, %i5
400050c0: 02 80 00 04 be 400050d0 <rtems_libio_set_private_env+0x2c>
<== NEVER TAKEN
400050c4: 80 a2 20 00 cmp %o0, 0
400050c8: 12 80 00 30 bne 40005188 <rtems_libio_set_private_env+0xe4>
400050cc: b0 10 20 00 clr %i0
Thread_Life_state life_state =
400050d0: 40 00 17 4a call 4000adf8 <_Thread_Set_life_protection>
400050d4: 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));
400050d8: 92 10 20 48 mov 0x48, %o1
Thread_Life_state life_state =
400050dc: b4 10 00 08 mov %o0, %i2
if (sc != RTEMS_SUCCESSFUL) {
rtems_libio_free_user_env(new_env);
}
} else {
sc = RTEMS_NO_MEMORY;
400050e0: b0 10 20 1a mov 0x1a, %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
400050e4: 7f ff fb c5 call 40003ff8 <calloc>
400050e8: 90 10 20 01 mov 1, %o0
if (new_env != NULL) {
400050ec: 80 a2 20 00 cmp %o0, 0
400050f0: 02 80 00 24 be 40005180 <rtems_libio_set_private_env+0xdc>
400050f4: b6 10 00 08 mov %o0, %i3
*new_env = *old_env;
400050f8: 94 10 20 48 mov 0x48, %o2
400050fc: 40 00 22 de call 4000dc74 <memcpy>
40005100: 92 10 00 1d mov %i5, %o1
rtems_filesystem_global_location_obtain(&old_env->root_directory);
40005104: 40 00 02 d4 call 40005c54 <rtems_filesystem_global_location_obtain>
40005108: 90 07 60 04 add %i5, 4, %o0
new_env->root_directory =
4000510c: d0 26 e0 04 st %o0, [ %i3 + 4 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
40005110: 40 00 02 d1 call 40005c54 <rtems_filesystem_global_location_obtain>
40005114: 90 10 00 1d mov %i5, %o0
if (
40005118: c2 06 e0 04 ld [ %i3 + 4 ], %g1
new_env->current_directory =
4000511c: d0 26 c0 00 st %o0, [ %i3 ]
if (
40005120: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40005124: 03 10 00 3d sethi %hi(0x4000f400), %g1
40005128: 82 10 63 88 or %g1, 0x388, %g1 ! 4000f788 <rtems_filesystem_null_handlers>
4000512c: 80 a0 80 01 cmp %g2, %g1
40005130: 22 80 00 0f be,a 4000516c <rtems_libio_set_private_env+0xc8>
<== NEVER TAKEN
40005134: b0 10 20 0d mov 0xd, %i0
<== NOT EXECUTED
&& !rtems_filesystem_global_location_is_null(new_env->current_directory)
40005138: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
4000513c: 80 a0 80 01 cmp %g2, %g1
40005140: 02 80 00 0a be 40005168 <rtems_libio_set_private_env+0xc4>
<== NEVER TAKEN
40005144: d0 07 20 f0 ld [ %i4 + 0xf0 ], %o0
int eno = pthread_setspecific(
40005148: 92 10 00 1b mov %i3, %o1
4000514c: 40 00 04 b5 call 40006420 <pthread_setspecific>
40005150: b0 10 20 00 clr %i0
if (eno == 0) {
40005154: 80 a2 20 00 cmp %o0, 0
40005158: 02 80 00 0a be 40005180 <rtems_libio_set_private_env+0xdc>
<== ALWAYS TAKEN
4000515c: 01 00 00 00 nop
40005160: 10 80 00 03 b 4000516c <rtems_libio_set_private_env+0xc8>
<== NOT EXECUTED
40005164: b0 10 20 05 mov 5, %i0 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
sc = RTEMS_UNSATISFIED;
40005168: b0 10 20 0d mov 0xd, %i0
<== NOT EXECUTED
if (!uses_global_env) {
4000516c: 80 a6 c0 1d cmp %i3, %i5
<== NOT EXECUTED
40005170: 02 80 00 04 be 40005180 <rtems_libio_set_private_env+0xdc>
<== NOT EXECUTED
40005174: 01 00 00 00 nop
<== NOT EXECUTED
40005178: 7f ff ff ad call 4000502c <rtems_libio_free_user_env.part.1>
<== NOT EXECUTED
4000517c: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
}
_Thread_Set_life_protection(life_state);
40005180: 40 00 17 1e call 4000adf8 <_Thread_Set_life_protection>
40005184: 90 10 00 1a mov %i2, %o0
}
return sc;
}
40005188: 81 c7 e0 08 ret
4000518c: 81 e8 00 00 restore
400058a4 <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 ) {
400058a4: 84 0a 20 06 and %o0, 6, %g2
400058a8: 80 a0 a0 06 cmp %g2, 6
400058ac: 02 80 00 05 be 400058c0 <rtems_libio_to_fcntl_flags+0x1c>
400058b0: 82 10 20 02 mov 2, %g1
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
400058b4: 80 8a 20 02 btst 2, %o0
400058b8: 02 80 00 0b be 400058e4 <rtems_libio_to_fcntl_flags+0x40>
<== NEVER TAKEN
400058bc: 82 10 20 00 clr %g1
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 ) {
400058c0: 80 8a 20 01 btst 1, %o0
400058c4: 02 80 00 04 be 400058d4 <rtems_libio_to_fcntl_flags+0x30>
400058c8: 80 8a 22 00 btst 0x200, %o0
fcntl_flags |= O_NONBLOCK;
400058cc: 05 00 00 10 sethi %hi(0x4000), %g2
400058d0: 82 10 40 02 or %g1, %g2, %g1
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
400058d4: 32 80 00 02 bne,a 400058dc <rtems_libio_to_fcntl_flags+0x38>
400058d8: 82 10 60 08 or %g1, 8, %g1
fcntl_flags |= O_APPEND;
}
return fcntl_flags;
}
400058dc: 81 c3 e0 08 retl
400058e0: 90 10 00 01 mov %g1, %o0
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
400058e4: 83 32 20 02 srl %o0, 2, %g1
<== NOT EXECUTED
400058e8: 10 bf ff f6 b 400058c0 <rtems_libio_to_fcntl_flags+0x1c>
<== NOT EXECUTED
400058ec: 82 08 60 01 and %g1, 1, %g1
<== NOT EXECUTED
40005190 <rtems_libio_use_global_env>:
void rtems_libio_use_global_env(void)
{
40005190: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = pthread_getspecific(rtems_current_user_env_key);
40005194: 39 10 00 49 sethi %hi(0x40012400), %i4
40005198: 40 00 04 27 call 40006234 <pthread_getspecific>
4000519c: d0 07 20 f0 ld [ %i4 + 0xf0 ], %o0 ! 400124f0 <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) {
400051a0: 03 10 00 43 sethi %hi(0x40010c00), %g1
400051a4: 82 10 61 50 or %g1, 0x150, %g1 ! 40010d50 <rtems_global_user_env>
400051a8: 80 a2 00 01 cmp %o0, %g1
400051ac: 02 80 00 0f be 400051e8 <rtems_libio_use_global_env+0x58>
<== NEVER TAKEN
400051b0: ba 10 00 08 mov %o0, %i5
400051b4: 80 a2 20 00 cmp %o0, 0
400051b8: 02 80 00 0c be 400051e8 <rtems_libio_use_global_env+0x58>
<== NEVER TAKEN
400051bc: 01 00 00 00 nop
Thread_Life_state life_state =
400051c0: 40 00 17 0e call 4000adf8 <_Thread_Set_life_protection>
400051c4: 90 10 20 01 mov 1, %o0 ! 1 <_TLS_Alignment>
400051c8: b0 10 00 08 mov %o0, %i0
400051cc: 7f ff ff 98 call 4000502c <rtems_libio_free_user_env.part.1>
400051d0: 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);
400051d4: d0 07 20 f0 ld [ %i4 + 0xf0 ], %o0
400051d8: 40 00 04 92 call 40006420 <pthread_setspecific>
400051dc: 92 10 20 00 clr %o1
_Thread_Set_life_protection(life_state);
400051e0: 40 00 17 06 call 4000adf8 <_Thread_Set_life_protection>
<== NOT EXECUTED
400051e4: 81 e8 00 00 restore
}
}
400051e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400051ec: 81 e8 00 00 restore
<== NOT EXECUTED
4000e97c <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
4000e97c: 9d e3 bf a0 save %sp, -96, %sp
4000e980: ba 10 00 18 mov %i0, %i5
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
4000e984: 80 a7 60 00 cmp %i5, 0
4000e988: 02 80 00 0d be 4000e9bc <rtems_memalign+0x40>
<== NEVER TAKEN
4000e98c: b0 10 20 16 mov 0x16, %i0
return EINVAL;
*pointer = NULL;
4000e990: c0 27 40 00 clr [ %i5 ]
/*
* Perform the aligned allocation requested
*/
return_this = rtems_heap_allocate_aligned_with_boundary( size, alignment, 0 );
4000e994: 94 10 20 00 clr %o2
4000e998: 92 10 00 19 mov %i1, %o1
4000e99c: 7f ff da f0 call 4000555c <rtems_heap_allocate_aligned_with_boundary>
4000e9a0: 90 10 00 1a mov %i2, %o0
if ( !return_this )
4000e9a4: 80 a2 20 00 cmp %o0, 0
4000e9a8: 22 80 00 05 be,a 4000e9bc <rtems_memalign+0x40>
<== NEVER TAKEN
4000e9ac: b0 10 20 0c mov 0xc, %i0
<== NOT EXECUTED
return ENOMEM;
*pointer = return_this;
4000e9b0: d0 27 40 00 st %o0, [ %i5 ]
return 0;
4000e9b4: 81 c7 e0 08 ret
4000e9b8: 91 e8 20 00 restore %g0, 0, %o0
}
4000e9bc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e9c0: 81 e8 00 00 restore
<== NOT EXECUTED
4000e124 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
4000e124: 9d e3 bf 40 save %sp, -192, %sp
int success = 0;
char *dup_path = strdup(path);
4000e128: 40 00 0a 90 call 40010b68 <strdup>
4000e12c: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
4000e130: b8 92 20 00 orcc %o0, 0, %i4
4000e134: 02 80 00 6e be 4000e2ec <rtems_mkdir+0x1c8>
4000e138: 01 00 00 00 nop
if (p[0] == '/') /* Skip leading '/'. */
4000e13c: c2 0f 00 00 ldub [ %i4 ], %g1
4000e140: 83 28 60 18 sll %g1, 0x18, %g1
4000e144: 85 38 60 18 sra %g1, 0x18, %g2
4000e148: 80 a0 a0 2f cmp %g2, 0x2f
4000e14c: 12 80 00 05 bne 4000e160 <rtems_mkdir+0x3c>
<== NEVER TAKEN
4000e150: ba 10 00 1c mov %i4, %i5
4000e154: c2 0f 20 01 ldub [ %i4 + 1 ], %g1
++p;
4000e158: ba 07 20 01 add %i4, 1, %i5
4000e15c: 83 28 60 18 sll %g1, 0x18, %g1
if (p[0] == '\0')
4000e160: 83 38 60 18 sra %g1, 0x18, %g1
4000e164: ba 07 60 01 inc %i5
*p = '/';
4000e168: b6 10 20 00 clr %i3
4000e16c: 84 10 20 01 mov 1, %g2
4000e170: b0 10 20 2f mov 0x2f, %i0
} else if (!S_ISDIR(sb.st_mode)) {
4000e174: 23 00 00 3c sethi %hi(0xf000), %l1
if (p[0] == '\0')
4000e178: 80 a0 60 00 cmp %g1, 0
4000e17c: 02 80 00 18 be 4000e1dc <rtems_mkdir+0xb8>
<== NEVER TAKEN
4000e180: 21 00 00 10 sethi %hi(0x4000), %l0
else if (p[0] != '/')
4000e184: 80 a0 60 2f cmp %g1, 0x2f
4000e188: 12 80 00 0f bne 4000e1c4 <rtems_mkdir+0xa0>
<== ALWAYS TAKEN
4000e18c: 80 a0 a0 00 cmp %g2, 0
*p = '\0';
4000e190: c0 2f 7f ff clrb [ %i5 + -1 ]
<== NOT EXECUTED
if (first) {
4000e194: 12 80 00 5c bne 4000e304 <rtems_mkdir+0x1e0>
<== NOT EXECUTED
4000e198: f4 0f 40 00 ldub [ %i5 ], %i2
<== NOT EXECUTED
if (last)
4000e19c: 80 8e a0 ff btst 0xff, %i2
<== NOT EXECUTED
4000e1a0: 02 80 00 17 be 4000e1fc <rtems_mkdir+0xd8>
<== NOT EXECUTED
4000e1a4: 92 10 21 ff mov 0x1ff, %o1
<== NOT EXECUTED
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4000e1a8: 7f ff db 34 call 40004e78 <mkdir>
<== NOT EXECUTED
4000e1ac: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000e1b0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e1b4: 06 80 00 1f bl 4000e230 <rtems_mkdir+0x10c>
<== NOT EXECUTED
4000e1b8: b4 10 20 00 clr %i2
<== NOT EXECUTED
*p = '/';
4000e1bc: f0 2f 7f ff stb %i0, [ %i5 + -1 ]
<== NOT EXECUTED
4000e1c0: 84 10 20 00 clr %g2
<== NOT EXECUTED
4000e1c4: c2 0f 40 00 ldub [ %i5 ], %g1
4000e1c8: 83 28 60 18 sll %g1, 0x18, %g1
if (p[0] == '\0')
4000e1cc: 83 38 60 18 sra %g1, 0x18, %g1
4000e1d0: 80 a0 60 00 cmp %g1, 0
4000e1d4: 12 bf ff ec bne 4000e184 <rtems_mkdir+0x60>
4000e1d8: ba 07 60 01 inc %i5
if (first) {
4000e1dc: 80 a0 a0 00 cmp %g2, 0
4000e1e0: 02 80 00 07 be 4000e1fc <rtems_mkdir+0xd8>
<== NEVER TAKEN
4000e1e4: 01 00 00 00 nop
oumask = umask(0);
4000e1e8: 40 00 00 c5 call 4000e4fc <umask>
4000e1ec: 90 10 20 00 clr %o0 ! 0 <PROM_START>
4000e1f0: b6 10 00 08 mov %o0, %i3
(void)umask(numask);
4000e1f4: 40 00 00 c2 call 4000e4fc <umask>
4000e1f8: 90 0a 3f 3f and %o0, -193, %o0
(void)umask(oumask);
4000e1fc: 40 00 00 c0 call 4000e4fc <umask>
4000e200: 90 10 00 1b mov %i3, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4000e204: 92 10 00 19 mov %i1, %o1
4000e208: 7f ff db 1c call 40004e78 <mkdir>
4000e20c: 90 10 00 1c mov %i4, %o0
4000e210: 80 a2 20 00 cmp %o0, 0
4000e214: 06 80 00 07 bl 4000e230 <rtems_mkdir+0x10c>
4000e218: b4 10 20 01 mov 1, %i2
(void)umask(oumask);
4000e21c: b0 10 20 00 clr %i0
success = build(dup_path, mode);
free(dup_path);
4000e220: 7f ff d9 c1 call 40004924 <free>
4000e224: 90 10 00 1c mov %i4, %o0
4000e228: 81 c7 e0 08 ret
4000e22c: 81 e8 00 00 restore
if (errno == EEXIST || errno == EISDIR) {
4000e230: 40 00 08 be call 40010528 <__errno>
4000e234: 01 00 00 00 nop
4000e238: c2 02 00 00 ld [ %o0 ], %g1
4000e23c: 80 a0 60 11 cmp %g1, 0x11
4000e240: 02 80 00 08 be 4000e260 <rtems_mkdir+0x13c>
<== ALWAYS TAKEN
4000e244: 92 07 bf a0 add %fp, -96, %o1
4000e248: 40 00 08 b8 call 40010528 <__errno>
<== NOT EXECUTED
4000e24c: 01 00 00 00 nop
<== NOT EXECUTED
4000e250: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
4000e254: 80 a0 60 15 cmp %g1, 0x15
<== NOT EXECUTED
4000e258: 12 80 00 0f bne 4000e294 <rtems_mkdir+0x170>
<== NOT EXECUTED
4000e25c: 92 07 bf a0 add %fp, -96, %o1
<== NOT EXECUTED
if (stat(path, &sb) < 0) {
4000e260: 40 00 00 30 call 4000e320 <stat>
4000e264: 90 10 00 1c mov %i4, %o0
4000e268: 80 a2 20 00 cmp %o0, 0
4000e26c: 06 80 00 0a bl 4000e294 <rtems_mkdir+0x170>
<== NEVER TAKEN
4000e270: c2 07 bf ac ld [ %fp + -84 ], %g1
} else if (!S_ISDIR(sb.st_mode)) {
4000e274: 82 08 40 11 and %g1, %l1, %g1
4000e278: 80 a0 40 10 cmp %g1, %l0
4000e27c: 12 80 00 10 bne 4000e2bc <rtems_mkdir+0x198>
<== NEVER TAKEN
4000e280: 80 a6 a0 00 cmp %i2, 0
if (last)
4000e284: 32 bf ff e7 bne,a 4000e220 <rtems_mkdir+0xfc>
<== ALWAYS TAKEN
4000e288: b0 10 20 00 clr %i0
*p = '/';
4000e28c: 10 bf ff cd b 4000e1c0 <rtems_mkdir+0x9c>
<== NOT EXECUTED
4000e290: f0 2f 7f ff stb %i0, [ %i5 + -1 ]
<== NOT EXECUTED
if (!first && !last)
4000e294: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000e298: 32 80 00 17 bne,a 4000e2f4 <rtems_mkdir+0x1d0>
<== NOT EXECUTED
4000e29c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
(void)umask(oumask);
4000e2a0: 40 00 00 97 call 4000e4fc <umask>
<== NOT EXECUTED
4000e2a4: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4000e2a8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
free(dup_path);
4000e2ac: 7f ff d9 9e call 40004924 <free>
<== NOT EXECUTED
4000e2b0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000e2b4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e2b8: 81 e8 00 00 restore
<== NOT EXECUTED
if (last)
4000e2bc: 02 80 00 07 be 4000e2d8 <rtems_mkdir+0x1b4>
<== NOT EXECUTED
4000e2c0: 01 00 00 00 nop
<== NOT EXECUTED
errno = EEXIST;
4000e2c4: 40 00 08 99 call 40010528 <__errno>
<== NOT EXECUTED
4000e2c8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
4000e2cc: 82 10 20 11 mov 0x11, %g1
<== NOT EXECUTED
4000e2d0: 10 bf ff d4 b 4000e220 <rtems_mkdir+0xfc>
<== NOT EXECUTED
4000e2d4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
errno = ENOTDIR;
4000e2d8: 40 00 08 94 call 40010528 <__errno>
<== NOT EXECUTED
4000e2dc: 01 00 00 00 nop
<== NOT EXECUTED
4000e2e0: 82 10 20 14 mov 0x14, %g1 ! 14 <_TLS_Alignment+0x13>
<== NOT EXECUTED
4000e2e4: 10 bf ff ef b 4000e2a0 <rtems_mkdir+0x17c>
<== NOT EXECUTED
4000e2e8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
return success != 0 ? 0 : -1;
4000e2ec: 81 c7 e0 08 ret
4000e2f0: 91 e8 3f ff restore %g0, -1, %o0
free(dup_path);
4000e2f4: 7f ff d9 8c call 40004924 <free>
<== NOT EXECUTED
4000e2f8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
}
4000e2fc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e300: 81 e8 00 00 restore
<== NOT EXECUTED
oumask = umask(0);
4000e304: 40 00 00 7e call 4000e4fc <umask>
<== NOT EXECUTED
4000e308: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000e30c: b6 10 00 08 mov %o0, %i3
<== NOT EXECUTED
(void)umask(numask);
4000e310: 40 00 00 7b call 4000e4fc <umask>
<== NOT EXECUTED
4000e314: 90 0a 3f 3f and %o0, -193, %o0
<== NOT EXECUTED
if (last)
4000e318: 10 bf ff a2 b 4000e1a0 <rtems_mkdir+0x7c>
<== NOT EXECUTED
4000e31c: 80 8e a0 ff btst 0xff, %i2
<== NOT EXECUTED
4000df5c <rtems_printf>:
int rtems_printf(
const rtems_printer *printer,
const char *format,
...
)
{
4000df5c: 9d e3 bf 98 save %sp, -104, %sp
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
va_list ap;
va_start( ap, format );
4000df60: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
{
4000df64: 82 10 00 18 mov %i0, %g1
va_start( ap, format );
4000df68: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int len = 0;
4000df6c: b0 10 20 00 clr %i0
va_start( ap, format );
4000df70: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000df74: 80 a0 60 00 cmp %g1, 0
4000df78: 02 80 00 0b be 4000dfa4 <rtems_printf+0x48>
<== NEVER TAKEN
4000df7c: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
4000df80: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000df84: 80 a0 a0 00 cmp %g2, 0
4000df88: 02 80 00 07 be 4000dfa4 <rtems_printf+0x48>
<== NEVER TAKEN
4000df8c: 94 07 a0 4c add %fp, 0x4c, %o2
len = printer->printer( printer->context, format, ap );
4000df90: d0 00 40 00 ld [ %g1 ], %o0
4000df94: 92 10 00 19 mov %i1, %o1
4000df98: 9f c0 80 00 call %g2
4000df9c: d4 27 bf fc st %o2, [ %fp + -4 ]
4000dfa0: b0 10 00 08 mov %o0, %i0
va_end( ap );
}
return len;
}
4000dfa4: 81 c7 e0 08 ret
4000dfa8: 81 e8 00 00 restore
40012950 <rtems_termios_baud_table>:
40012950: 40 01 28 88 00 00 00 00 00 00 00 00 40 01 28 90 @.(.........@.(.
40012960: 00 00 00 32 00 00 00 32 40 01 28 98 00 00 00 4b ...2...2@.(....K
40012970: 00 00 00 4b 40 01 28 a0 00 00 00 6e 00 00 00 6e ...K@.(....n...n
40012980: 40 01 28 a8 00 00 00 86 00 00 00 86 40 01 28 b0 @.(.........@.(.
40012990: 00 00 00 96 00 00 00 96 40 01 28 b8 00 00 00 c8 ........@.(.....
400129a0: 00 00 00 c8 40 01 28 c0 00 00 01 2c 00 00 01 2c ....@.(....,...,
400129b0: 40 01 28 c8 00 00 02 58 00 00 02 58 40 01 28 d0 @.(....X...X@.(.
400129c0: 00 00 04 b0 00 00 04 b0 40 01 28 d8 00 00 07 08 ........@.(.....
400129d0: 00 00 07 08 40 01 28 e0 00 00 09 60 00 00 09 60 ....@.(....`...`
400129e0: 40 01 28 e8 00 00 12 c0 00 00 12 c0 40 01 28 f0 @.(.........@.(.
400129f0: 00 00 25 80 00 00 25 80 40 01 28 f8 00 00 4b 00 ..%...%.@.(...K.
40012a00: 00 00 4b 00 40 01 29 00 00 00 96 00 00 00 96 00 ..K.@.).........
40012a10: 40 01 29 08 00 00 1c 20 00 00 1c 20 40 01 29 10 @.).... ... @.).
40012a20: 00 00 38 40 00 00 38 40 40 01 29 18 00 00 70 80 ..8@..8@@.)...p.
40012a30: 00 00 70 80 40 01 29 20 00 00 e1 00 00 00 e1 00 ..p.@.) ........
40012a40: 40 01 29 28 00 01 2c 00 00 01 2c 00 40 01 29 30 @.)(..,...,.@.)0
40012a50: 00 01 c2 00 00 01 c2 00 40 01 29 38 00 03 84 00 ........@.)8....
40012a60: 00 03 84 00 40 01 29 40 00 07 08 00 00 07 08 00 ....@.)@........
40012a70: 40 01 29 48 00 0e 10 00 00 0e 10 00 00 00 00 00 @.)H............
...
40012a88: 74 65 72 6d 69 6f 73 20 69 6e 70 75 74 00 00 00 termios input...
40012a98: 74 65 72 6d 69 6f 73 20 6f 75 74 70 75 74 00 00 termios output..
40012aa8: 74 65 72 6d 69 6f 73 20 72 61 77 20 6f 75 74 70 termios raw outp
40012ab8: 75 74 00 00 00 00 00 00 74 65 72 6d 69 6f 73 20 ut......termios
40012ac8: 64 65 76 69 63 65 00 00 74 65 72 6d 69 6f 73 20 device..termios
40012ad8: 72 61 77 20 69 6e 70 75 74 00 00 00 00 00 00 00 raw input.......
40012ae8: 08 00 00 00 00 00 00 00 08 20 08 00 ......... ..
40005df4 <rtems_termios_baud_to_number>:
#include <rtems/termiostypes.h>
rtems_termios_baud_t rtems_termios_baud_to_number(speed_t spd)
{
return rtems_assoc_local_by_remote(rtems_termios_baud_table, spd);
40005df4: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
40005df8: 11 10 00 4a sethi %hi(0x40012800), %o0
<== NOT EXECUTED
40005dfc: 90 12 21 50 or %o0, 0x150, %o0 ! 40012950 <rtems_termios_baud_table>
<== NOT EXECUTED
40005e00: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40005e04: 40 00 26 a3 call 4000f890 <rtems_assoc_local_by_remote>
<== NOT EXECUTED
40005e08: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40007a90 <rtems_termios_device_install>:
{
40007a90: 9d e3 bf a0 save %sp, -96, %sp
new_device_node = calloc (1, sizeof(*new_device_node));
40007a94: 92 10 20 20 mov 0x20, %o1
40007a98: 7f ff f2 04 call 400042a8 <calloc>
40007a9c: 90 10 20 01 mov 1, %o0
return RTEMS_NO_MEMORY;
40007aa0: 82 10 20 1a mov 0x1a, %g1
if (new_device_node == NULL) {
40007aa4: 80 a2 20 00 cmp %o0, 0
40007aa8: 02 80 00 10 be 40007ae8 <rtems_termios_device_install+0x58>
<== NEVER TAKEN
40007aac: ba 10 00 08 mov %o0, %i5
new_device_node->handler = handler;
40007ab0: f2 22 20 10 st %i1, [ %o0 + 0x10 ]
rv = IMFS_make_generic_node(
40007ab4: 96 10 00 08 mov %o0, %o3
new_device_node->flow = flow;
40007ab8: f4 22 20 14 st %i2, [ %o0 + 0x14 ]
rv = IMFS_make_generic_node(
40007abc: 15 10 00 4a sethi %hi(0x40012800), %o2
new_device_node->context = context;
40007ac0: f6 22 20 18 st %i3, [ %o0 + 0x18 ]
rv = IMFS_make_generic_node(
40007ac4: 94 12 a3 34 or %o2, 0x334, %o2
new_device_node->tty = NULL;
40007ac8: c0 22 20 1c clr [ %o0 + 0x1c ]
rv = IMFS_make_generic_node(
40007acc: 13 00 00 08 sethi %hi(0x2000), %o1
40007ad0: 90 10 00 18 mov %i0, %o0
40007ad4: 40 00 1f 25 call 4000f768 <IMFS_make_generic_node>
40007ad8: 92 12 61 ff or %o1, 0x1ff, %o1
if (rv != 0) {
40007adc: 80 a2 20 00 cmp %o0, 0
40007ae0: 12 80 00 04 bne 40007af0 <rtems_termios_device_install+0x60>
<== NEVER TAKEN
40007ae4: 82 10 20 00 clr %g1
}
40007ae8: 81 c7 e0 08 ret
40007aec: 91 e8 00 01 restore %g0, %g1, %o0
free (new_device_node);
40007af0: 7f ff f2 13 call 4000433c <free>
<== NOT EXECUTED
40007af4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return RTEMS_UNSATISFIED;
40007af8: 82 10 20 0d mov 0xd, %g1
<== NOT EXECUTED
}
40007afc: 81 c7 e0 08 ret
<== NOT EXECUTED
40007b00: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
40005ed8 <rtems_termios_device_lock_acquire_default>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005ed8: 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);
40005edc: c2 22 40 00 st %g1, [ %o1 ]
<== NOT EXECUTED
}
40005ee0: 81 c3 e0 08 retl
<== NOT EXECUTED
40005ee4: 01 00 00 00 nop
<== NOT EXECUTED
40005ee8 <rtems_termios_device_lock_release_default>:
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40005ee8: c2 02 40 00 ld [ %o1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005eec: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ef0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_termios_device_context *ctx,
rtems_interrupt_lock_context *lock_context
)
{
rtems_interrupt_lock_release (&ctx->lock.interrupt, lock_context);
}
40005ef4: 81 c3 e0 08 retl
<== NOT EXECUTED
40005ef8: 01 00 00 00 nop
<== NOT EXECUTED
40008128 <rtems_termios_enqueue_raw_characters>:
{
40008128: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
4000812c: c2 06 21 5c ld [ %i0 + 0x15c ], %g1
<== NOT EXECUTED
40008130: 83 28 60 05 sll %g1, 5, %g1
<== NOT EXECUTED
40008134: 39 10 00 56 sethi %hi(0x40015800), %i4
<== NOT EXECUTED
40008138: b8 17 20 64 or %i4, 0x64, %i4 ! 40015864 <rtems_termios_linesw>
<== NOT EXECUTED
4000813c: 82 07 00 01 add %i4, %g1, %g1
<== NOT EXECUTED
40008140: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
<== NOT EXECUTED
40008144: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008148: 02 80 00 25 be 400081dc <rtems_termios_enqueue_raw_characters+0xb4>
<== NOT EXECUTED
4000814c: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
while (len--) {
40008150: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40008154: 22 80 00 0f be,a 40008190 <rtems_termios_enqueue_raw_characters+0x68>
<== NOT EXECUTED
40008158: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
<== NOT EXECUTED
4000815c: 10 80 00 05 b 40008170 <rtems_termios_enqueue_raw_characters+0x48>
<== NOT EXECUTED
40008160: b4 06 40 1a add %i1, %i2, %i2
<== NOT EXECUTED
40008164: 83 28 60 05 sll %g1, 5, %g1
<== NOT EXECUTED
40008168: 82 07 00 01 add %i4, %g1, %g1
<== NOT EXECUTED
4000816c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
<== NOT EXECUTED
c = *buf++;
40008170: b2 06 60 01 inc %i1
<== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
40008174: d0 4e 7f ff ldsb [ %i1 + -1 ], %o0
<== NOT EXECUTED
40008178: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000817c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
while (len--) {
40008180: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
40008184: 32 bf ff f8 bne,a 40008164 <rtems_termios_enqueue_raw_characters+0x3c>
<== NOT EXECUTED
40008188: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
<== NOT EXECUTED
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
4000818c: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
<== NOT EXECUTED
40008190: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008194: 02 80 00 0a be 400081bc <rtems_termios_enqueue_raw_characters+0x94>
<== NOT EXECUTED
40008198: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000819c: c4 0f 61 74 ldub [ %i5 + 0x174 ], %g2
<== NOT EXECUTED
400081a0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400081a4: 12 80 00 06 bne 400081bc <rtems_termios_enqueue_raw_characters+0x94>
<== NOT EXECUTED
400081a8: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
tty->tty_rcvwakeup = true;
400081ac: c4 2f 61 74 stb %g2, [ %i5 + 0x174 ]
<== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
400081b0: 90 07 60 50 add %i5, 0x50, %o0
<== NOT EXECUTED
400081b4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400081b8: d2 07 61 70 ld [ %i5 + 0x170 ], %o1
<== NOT EXECUTED
400081bc: 81 c7 e0 08 ret
<== NOT EXECUTED
400081c0: 81 e8 00 00 restore
<== NOT EXECUTED
tty->rawInBufDropped += dropped;
400081c4: 82 00 40 18 add %g1, %i0, %g1
<== NOT EXECUTED
400081c8: c2 27 60 b4 st %g1, [ %i5 + 0xb4 ]
<== NOT EXECUTED
_Semaphore_Post_binary( &binary_semaphore->Semaphore );
400081cc: 40 00 10 7e call 4000c3c4 <_Semaphore_Post_binary>
<== NOT EXECUTED
400081d0: 90 07 60 90 add %i5, 0x90, %o0
<== NOT EXECUTED
}
400081d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400081d8: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_termios_device_context *ctx = tty->device_context;
400081dc: f8 06 21 7c ld [ %i0 + 0x17c ], %i4
<== NOT EXECUTED
400081e0: b4 06 40 1a add %i1, %i2, %i2
<== NOT EXECUTED
bool flow_rcv = false; /* true, if flow control char received */
400081e4: a6 10 20 00 clr %l3
<== NOT EXECUTED
int dropped = 0;
400081e8: b0 10 20 00 clr %i0
<== NOT EXECUTED
400081ec: a2 10 20 01 mov 1, %l1
<== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
400081f0: a0 07 60 50 add %i5, 0x50, %l0
<== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
400081f4: a4 07 60 6d add %i5, 0x6d, %l2
<== NOT EXECUTED
while (len--) {
400081f8: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
400081fc: 22 bf ff f2 be,a 400081c4 <rtems_termios_enqueue_raw_characters+0x9c>
<== NOT EXECUTED
40008200: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
<== NOT EXECUTED
if (tty->flow_ctrl & FL_MDXON) {
40008204: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
c = *buf++;
40008208: b2 06 60 01 inc %i1
<== NOT EXECUTED
if (tty->flow_ctrl & FL_MDXON) {
4000820c: 80 88 62 00 btst 0x200, %g1
<== NOT EXECUTED
40008210: 02 80 00 0b be 4000823c <rtems_termios_enqueue_raw_characters+0x114>
<== NOT EXECUTED
40008214: d0 0e 7f ff ldub [ %i1 + -1 ], %o0
<== NOT EXECUTED
if (c == tty->termios.c_cc[VSTOP]) {
40008218: c4 0f 60 6d ldub [ %i5 + 0x6d ], %g2
<== NOT EXECUTED
4000821c: 83 2a 20 18 sll %o0, 0x18, %g1
<== NOT EXECUTED
40008220: 83 38 60 18 sra %g1, 0x18, %g1
<== NOT EXECUTED
40008224: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40008228: 02 80 00 60 be 400083a8 <rtems_termios_enqueue_raw_characters+0x280>
<== NOT EXECUTED
4000822c: c6 0f 60 6c ldub [ %i5 + 0x6c ], %g3
<== NOT EXECUTED
else if (c == tty->termios.c_cc[VSTART]) {
40008230: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40008234: 02 80 00 a6 be 400084cc <rtems_termios_enqueue_raw_characters+0x3a4>
<== NOT EXECUTED
40008238: 01 00 00 00 nop
<== NOT EXECUTED
if (flow_rcv) {
4000823c: 80 8c e0 ff btst 0xff, %l3
<== NOT EXECUTED
40008240: 32 80 00 61 bne,a 400083c4 <rtems_termios_enqueue_raw_characters+0x29c>
<== NOT EXECUTED
40008244: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
if (c == '\r' && (tty->termios.c_iflag & IGNCR) != 0) {
40008248: 82 0a 20 ff and %o0, 0xff, %g1
<== NOT EXECUTED
4000824c: 80 a0 60 0d cmp %g1, 0xd
<== NOT EXECUTED
40008250: 12 80 00 06 bne 40008268 <rtems_termios_enqueue_raw_characters+0x140>
<== NOT EXECUTED
40008254: 01 00 00 00 nop
<== NOT EXECUTED
40008258: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
4000825c: 80 88 60 80 btst 0x80, %g1
<== NOT EXECUTED
40008260: 12 bf ff e7 bne 400081fc <rtems_termios_enqueue_raw_characters+0xd4>
<== NOT EXECUTED
40008264: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
c = iprocEarly (c, tty);
40008268: 7f ff fb 4d call 40006f9c <iprocEarly>
<== NOT EXECUTED
4000826c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
( *context->lock_acquire )( context, lock_context );
40008270: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
<== NOT EXECUTED
40008274: a8 10 00 08 mov %o0, %l4
<== NOT EXECUTED
40008278: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
4000827c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008280: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
head = tty->rawInBuf.Head;
40008284: ea 07 60 84 ld [ %i5 + 0x84 ], %l5
<== NOT EXECUTED
oldTail = tty->rawInBuf.Tail;
40008288: f6 07 60 88 ld [ %i5 + 0x88 ], %i3
<== NOT EXECUTED
newTail = (oldTail + 1) % tty->rawInBuf.Size;
4000828c: c4 07 60 8c ld [ %i5 + 0x8c ], %g2
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
40008290: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
newTail = (oldTail + 1) % tty->rawInBuf.Size;
40008294: b6 06 e0 01 inc %i3
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
40008298: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
newTail = (oldTail + 1) % tty->rawInBuf.Size;
4000829c: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
400082a0: 01 00 00 00 nop
<== NOT EXECUTED
400082a4: 01 00 00 00 nop
<== NOT EXECUTED
400082a8: 01 00 00 00 nop
<== NOT EXECUTED
400082ac: 82 76 c0 02 udiv %i3, %g2, %g1
<== NOT EXECUTED
400082b0: 82 58 40 02 smul %g1, %g2, %g1
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
400082b4: 02 80 00 0f be 400082f0 <rtems_termios_enqueue_raw_characters+0x1c8>
<== NOT EXECUTED
400082b8: b6 26 c0 01 sub %i3, %g1, %i3
<== NOT EXECUTED
tty->rawInBuf.Size) > tty->highwater)) {
400082bc: c6 07 60 8c ld [ %i5 + 0x8c ], %g3
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
400082c0: c8 07 61 50 ld [ %i5 + 0x150 ], %g4
<== NOT EXECUTED
400082c4: 82 26 c0 15 sub %i3, %l5, %g1
<== NOT EXECUTED
400082c8: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
400082cc: 01 00 00 00 nop
<== NOT EXECUTED
400082d0: 01 00 00 00 nop
<== NOT EXECUTED
400082d4: 01 00 00 00 nop
<== NOT EXECUTED
400082d8: 84 70 40 03 udiv %g1, %g3, %g2
<== NOT EXECUTED
400082dc: 84 58 80 03 smul %g2, %g3, %g2
<== NOT EXECUTED
400082e0: 82 20 40 02 sub %g1, %g2, %g1
<== NOT EXECUTED
400082e4: 80 a0 40 04 cmp %g1, %g4
<== NOT EXECUTED
400082e8: 18 80 00 57 bgu 40008444 <rtems_termios_enqueue_raw_characters+0x31c>
<== NOT EXECUTED
400082ec: 01 00 00 00 nop
<== NOT EXECUTED
if (newTail != head) {
400082f0: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
400082f4: 22 80 00 20 be,a 40008374 <rtems_termios_enqueue_raw_characters+0x24c>
<== NOT EXECUTED
400082f8: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
<== NOT EXECUTED
tty->rawInBuf.theBuf[newTail] = c;
400082fc: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
<== NOT EXECUTED
40008300: e8 28 40 1b stb %l4, [ %g1 + %i3 ]
<== NOT EXECUTED
tty->rawInBuf.Tail = newTail;
40008304: f6 27 60 88 st %i3, [ %i5 + 0x88 ]
<== NOT EXECUTED
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
40008308: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
<== NOT EXECUTED
4000830c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008310: 22 80 00 74 be,a 400084e0 <rtems_termios_enqueue_raw_characters+0x3b8>
<== NOT EXECUTED
40008314: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
40008318: c2 0f 61 74 ldub [ %i5 + 0x174 ], %g1
<== NOT EXECUTED
4000831c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008320: 12 80 00 1d bne 40008394 <rtems_termios_enqueue_raw_characters+0x26c>
<== NOT EXECUTED
40008324: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
<== NOT EXECUTED
if ((tty->termios.c_lflag & ICANON) != 0) {
40008328: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
<== NOT EXECUTED
4000832c: 80 88 61 00 btst 0x100, %g1
<== NOT EXECUTED
40008330: 02 80 00 71 be 400084f4 <rtems_termios_enqueue_raw_characters+0x3cc>
<== NOT EXECUTED
40008334: 80 a5 20 0a cmp %l4, 0xa
<== NOT EXECUTED
c == tty->termios.c_cc[VEOL] || c == tty->termios.c_cc[VEOL2];
40008338: 22 80 00 5c be,a 400084a8 <rtems_termios_enqueue_raw_characters+0x380>
<== NOT EXECUTED
4000833c: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
<== NOT EXECUTED
return c == '\n' || c == tty->termios.c_cc[VEOF] ||
40008340: c2 0f 60 60 ldub [ %i5 + 0x60 ], %g1
<== NOT EXECUTED
40008344: 80 a5 00 01 cmp %l4, %g1
<== NOT EXECUTED
40008348: 22 80 00 58 be,a 400084a8 <rtems_termios_enqueue_raw_characters+0x380>
<== NOT EXECUTED
4000834c: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
<== NOT EXECUTED
40008350: c2 0f 60 61 ldub [ %i5 + 0x61 ], %g1
<== NOT EXECUTED
40008354: 80 a5 00 01 cmp %l4, %g1
<== NOT EXECUTED
40008358: 22 80 00 54 be,a 400084a8 <rtems_termios_enqueue_raw_characters+0x380>
<== NOT EXECUTED
4000835c: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
<== NOT EXECUTED
c == tty->termios.c_cc[VEOL] || c == tty->termios.c_cc[VEOL2];
40008360: c2 0f 60 62 ldub [ %i5 + 0x62 ], %g1
<== NOT EXECUTED
40008364: a8 18 40 14 xor %g1, %l4, %l4
<== NOT EXECUTED
40008368: 80 a0 00 14 cmp %g0, %l4
<== NOT EXECUTED
4000836c: 10 80 00 6e b 40008524 <rtems_termios_enqueue_raw_characters+0x3fc>
<== NOT EXECUTED
40008370: 82 60 3f ff subx %g0, -1, %g1
<== NOT EXECUTED
++dropped;
40008374: b0 06 20 01 inc %i0
<== NOT EXECUTED
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
40008378: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000837c: 02 80 00 06 be 40008394 <rtems_termios_enqueue_raw_characters+0x26c>
<== NOT EXECUTED
40008380: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
<== NOT EXECUTED
40008384: c2 0f 61 74 ldub [ %i5 + 0x174 ], %g1
<== NOT EXECUTED
40008388: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000838c: 22 80 00 47 be,a 400084a8 <rtems_termios_enqueue_raw_characters+0x380>
<== NOT EXECUTED
40008390: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
<== NOT EXECUTED
( *context->lock_release )( context, lock_context );
40008394: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40008398: 9f c0 80 00 call %g2
<== NOT EXECUTED
4000839c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
while (len--) {
400083a0: 10 bf ff 97 b 400081fc <rtems_termios_enqueue_raw_characters+0xd4>
<== NOT EXECUTED
400083a4: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
if (c == tty->termios.c_cc[VSTART]) {
400083a8: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
400083ac: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
if (c == tty->termios.c_cc[VSTART]) {
400083b0: 32 80 00 22 bne,a 40008438 <rtems_termios_enqueue_raw_characters+0x310>
<== NOT EXECUTED
400083b4: 82 10 60 10 or %g1, 0x10, %g1
<== NOT EXECUTED
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
400083b8: 82 18 60 10 xor %g1, 0x10, %g1
<== NOT EXECUTED
400083bc: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
400083c0: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
400083c4: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
400083c8: 82 08 60 30 and %g1, 0x30, %g1
<== NOT EXECUTED
400083cc: 80 a0 60 20 cmp %g1, 0x20
<== NOT EXECUTED
400083d0: 12 bf ff 8a bne 400081f8 <rtems_termios_enqueue_raw_characters+0xd0>
<== NOT EXECUTED
400083d4: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
( *context->lock_acquire )( context, lock_context );
400083d8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
<== NOT EXECUTED
400083dc: 9f c0 40 00 call %g1
<== NOT EXECUTED
400083e0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
400083e4: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
400083e8: 82 08 7f df and %g1, -33, %g1
<== NOT EXECUTED
400083ec: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->rawOutBufState != rob_idle) {
400083f0: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
<== NOT EXECUTED
400083f4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400083f8: 22 80 00 0a be,a 40008420 <rtems_termios_enqueue_raw_characters+0x2f8>
<== NOT EXECUTED
400083fc: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
40008400: c4 07 60 c0 ld [ %i5 + 0xc0 ], %g2
<== NOT EXECUTED
40008404: d2 07 60 b8 ld [ %i5 + 0xb8 ], %o1
<== NOT EXECUTED
(*tty->handler.write)(
40008408: c2 07 61 30 ld [ %i5 + 0x130 ], %g1
<== NOT EXECUTED
4000840c: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
40008410: 92 02 40 02 add %o1, %g2, %o1
<== NOT EXECUTED
40008414: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008418: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
( *context->lock_release )( context, lock_context );
4000841c: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
40008420: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40008424: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40008428: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000842c: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
while (len--) {
40008430: 10 bf ff 73 b 400081fc <rtems_termios_enqueue_raw_characters+0xd4>
<== NOT EXECUTED
40008434: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
tty->flow_ctrl |= FL_ORCVXOF;
40008438: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
4000843c: 10 bf ff e2 b 400083c4 <rtems_termios_enqueue_raw_characters+0x29c>
<== NOT EXECUTED
40008440: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
tty->flow_ctrl |= FL_IREQXOF;
40008444: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40008448: 82 10 60 01 or %g1, 1, %g1
<== NOT EXECUTED
4000844c: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
40008450: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40008454: 82 08 64 02 and %g1, 0x402, %g1
<== NOT EXECUTED
40008458: 80 a0 64 00 cmp %g1, 0x400
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
4000845c: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
40008460: 02 80 00 39 be 40008544 <rtems_termios_enqueue_raw_characters+0x41c>
<== NOT EXECUTED
40008464: 80 88 60 20 btst 0x20, %g1
<== NOT EXECUTED
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
40008468: 82 08 61 04 and %g1, 0x104, %g1
<== NOT EXECUTED
4000846c: 80 a0 61 00 cmp %g1, 0x100
<== NOT EXECUTED
40008470: 12 bf ff a1 bne 400082f4 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
40008474: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
40008478: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
4000847c: 82 10 60 04 or %g1, 4, %g1
<== NOT EXECUTED
40008480: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->flow.stop_remote_tx != NULL) {
40008484: c2 07 61 40 ld [ %i5 + 0x140 ], %g1
<== NOT EXECUTED
40008488: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000848c: 22 bf ff 9a be,a 400082f4 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
40008490: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
tty->flow.stop_remote_tx(ctx);
40008494: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008498: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if (newTail != head) {
4000849c: 10 bf ff 96 b 400082f4 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
400084a0: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
tty->tty_rcvwakeup = true;
400084a4: e2 2f 61 74 stb %l1, [ %i5 + 0x174 ]
<== NOT EXECUTED
400084a8: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
400084ac: 9f c0 80 00 call %g2
<== NOT EXECUTED
400084b0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
400084b4: c2 07 61 6c ld [ %i5 + 0x16c ], %g1
<== NOT EXECUTED
400084b8: d2 07 61 70 ld [ %i5 + 0x170 ], %o1
<== NOT EXECUTED
400084bc: 9f c0 40 00 call %g1
<== NOT EXECUTED
400084c0: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
while (len--) {
400084c4: 10 bf ff 4e b 400081fc <rtems_termios_enqueue_raw_characters+0xd4>
<== NOT EXECUTED
400084c8: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
tty->flow_ctrl &= ~FL_ORCVXOF;
400084cc: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
400084d0: 82 08 7f ef and %g1, -17, %g1
<== NOT EXECUTED
400084d4: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
400084d8: 10 bf ff bb b 400083c4 <rtems_termios_enqueue_raw_characters+0x29c>
<== NOT EXECUTED
400084dc: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
400084e0: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
400084e4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400084e8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
while (len--) {
400084ec: 10 bf ff 44 b 400081fc <rtems_termios_enqueue_raw_characters+0xd4>
<== NOT EXECUTED
400084f0: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
unsigned int rawContentSize = (newTail - head) % tty->rawInBuf.Size;
400084f4: c6 07 60 8c ld [ %i5 + 0x8c ], %g3
<== NOT EXECUTED
400084f8: b6 26 c0 15 sub %i3, %l5, %i3
<== NOT EXECUTED
return rawContentSize >= tty->termios.c_cc[VMIN];
400084fc: c8 0f 60 70 ldub [ %i5 + 0x70 ], %g4
<== NOT EXECUTED
unsigned int rawContentSize = (newTail - head) % tty->rawInBuf.Size;
40008500: 81 80 20 00 wr %g0, %y
<== NOT EXECUTED
40008504: 01 00 00 00 nop
<== NOT EXECUTED
40008508: 01 00 00 00 nop
<== NOT EXECUTED
4000850c: 01 00 00 00 nop
<== NOT EXECUTED
40008510: 82 76 c0 03 udiv %i3, %g3, %g1
<== NOT EXECUTED
40008514: 82 58 40 03 smul %g1, %g3, %g1
<== NOT EXECUTED
40008518: b6 26 c0 01 sub %i3, %g1, %i3
<== NOT EXECUTED
return rawContentSize >= tty->termios.c_cc[VMIN];
4000851c: 80 a6 c0 04 cmp %i3, %g4
<== NOT EXECUTED
40008520: 82 60 3f ff subx %g0, -1, %g1
<== NOT EXECUTED
if (mustCallReceiveCallback (tty, c, newTail, head)) {
40008524: 80 88 60 ff btst 0xff, %g1
<== NOT EXECUTED
40008528: 12 bf ff df bne 400084a4 <rtems_termios_enqueue_raw_characters+0x37c>
<== NOT EXECUTED
4000852c: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40008530: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40008534: 9f c0 80 00 call %g2
<== NOT EXECUTED
40008538: a6 10 00 01 mov %g1, %l3
<== NOT EXECUTED
while (len--) {
4000853c: 10 bf ff 30 b 400081fc <rtems_termios_enqueue_raw_characters+0xd4>
<== NOT EXECUTED
40008540: 80 a6 40 1a cmp %i1, %i2
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
40008544: 22 80 00 0c be,a 40008574 <rtems_termios_enqueue_raw_characters+0x44c>
<== NOT EXECUTED
40008548: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
<== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
4000854c: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40008550: 82 10 60 02 or %g1, 2, %g1
<== NOT EXECUTED
40008554: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
(*tty->handler.write)(ctx,
40008558: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
4000855c: c2 07 61 30 ld [ %i5 + 0x130 ], %g1
<== NOT EXECUTED
40008560: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
40008564: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008568: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if (newTail != head) {
4000856c: 10 bf ff 62 b 400082f4 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
40008570: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
40008574: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008578: 32 bf ff 5f bne,a 400082f4 <rtems_termios_enqueue_raw_characters+0x1cc>
<== NOT EXECUTED
4000857c: 80 a5 40 1b cmp %l5, %i3
<== NOT EXECUTED
40008580: 30 bf ff f3 b,a 4000854c <rtems_termios_enqueue_raw_characters+0x424>
<== NOT EXECUTED
40007b04 <rtems_termios_ioctl>:
{
40007b04: 9d e3 bf 98 save %sp, -104, %sp
struct rtems_termios_tty *tty = args->iop->data1;
40007b08: c2 06 00 00 ld [ %i0 ], %g1
40007b0c: fa 00 60 28 ld [ %g1 + 0x28 ], %i5
args->ioctl_return = 0;
40007b10: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_mutex_lock (&tty->osem);
40007b14: b4 07 60 28 add %i5, 0x28, %i2
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
40007b18: f2 06 20 08 ld [ %i0 + 8 ], %i1
_Mutex_Acquire( mutex );
40007b1c: 40 00 0b ab call 4000a9c8 <_Mutex_Acquire>
40007b20: 90 10 00 1a mov %i2, %o0
switch (args->command) {
40007b24: f6 06 20 04 ld [ %i0 + 4 ], %i3
40007b28: 03 20 01 1d sethi %hi(0x80047400), %g1
40007b2c: 84 10 60 10 or %g1, 0x10, %g2 ! 80047410 <RAM_END+0x3fc47410>
40007b30: 80 a6 c0 02 cmp %i3, %g2
40007b34: 02 80 00 f0 be 40007ef4 <rtems_termios_ioctl+0x3f0>
<== NEVER TAKEN
40007b38: b8 10 00 18 mov %i0, %i4
40007b3c: 28 80 00 17 bleu,a 40007b98 <rtems_termios_ioctl+0x94>
<== ALWAYS TAKEN
40007b40: 03 10 01 19 sethi %hi(0x40046400), %g1
40007b44: 05 20 02 1d sethi %hi(0x80087400), %g2
<== NOT EXECUTED
40007b48: 86 10 a0 0c or %g2, 0xc, %g3 ! 8008740c <RAM_END+0x3fc8740c>
<== NOT EXECUTED
40007b4c: 80 a6 c0 03 cmp %i3, %g3
<== NOT EXECUTED
40007b50: 22 80 00 d4 be,a 40007ea0 <rtems_termios_ioctl+0x39c>
<== NOT EXECUTED
40007b54: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
40007b58: 18 80 00 53 bgu 40007ca4 <rtems_termios_ioctl+0x1a0>
<== NOT EXECUTED
40007b5c: 82 10 60 1b or %g1, 0x1b, %g1
<== NOT EXECUTED
40007b60: 80 a6 c0 01 cmp %i3, %g1
<== NOT EXECUTED
40007b64: 02 80 00 2b be 40007c10 <rtems_termios_ioctl+0x10c>
<== NOT EXECUTED
40007b68: 84 10 a0 0b or %g2, 0xb, %g2
<== NOT EXECUTED
40007b6c: 80 a6 c0 02 cmp %i3, %g2
<== NOT EXECUTED
40007b70: 12 80 00 d4 bne 40007ec0 <rtems_termios_ioctl+0x3bc>
<== NOT EXECUTED
40007b74: b0 10 20 00 clr %i0
<== NOT EXECUTED
tty->tty_snd = *wakeup;
40007b78: c2 06 40 00 ld [ %i1 ], %g1
<== NOT EXECUTED
40007b7c: c2 27 61 64 st %g1, [ %i5 + 0x164 ]
<== NOT EXECUTED
40007b80: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
40007b84: c2 27 61 68 st %g1, [ %i5 + 0x168 ]
<== NOT EXECUTED
_Mutex_Release( mutex );
40007b88: 40 00 0b ac call 4000aa38 <_Mutex_Release>
40007b8c: 90 10 00 1a mov %i2, %o0
}
40007b90: 81 c7 e0 08 ret
40007b94: 81 e8 00 00 restore
switch (args->command) {
40007b98: 82 10 62 7f or %g1, 0x27f, %g1
40007b9c: 80 a6 c0 01 cmp %i3, %g1
40007ba0: 02 80 00 ae be 40007e58 <rtems_termios_ioctl+0x354>
<== NEVER TAKEN
40007ba4: 01 00 00 00 nop
40007ba8: 08 80 00 33 bleu 40007c74 <rtems_termios_ioctl+0x170>
<== NEVER TAKEN
40007bac: 03 10 01 1d sethi %hi(0x40047400), %g1
40007bb0: 82 10 60 1a or %g1, 0x1a, %g1 ! 4004741a <__end+0x30dca>
40007bb4: 80 a6 c0 01 cmp %i3, %g1
40007bb8: 02 80 00 0e be 40007bf0 <rtems_termios_ioctl+0xec>
<== NEVER TAKEN
40007bbc: 03 10 0b 1d sethi %hi(0x402c7400), %g1
40007bc0: 82 10 60 13 or %g1, 0x13, %g1 ! 402c7413 <__end+0x2b0dc3>
40007bc4: 80 a6 c0 01 cmp %i3, %g1
40007bc8: 12 80 00 be bne 40007ec0 <rtems_termios_ioctl+0x3bc>
<== ALWAYS TAKEN
40007bcc: 94 10 20 2c mov 0x2c, %o2
*(struct termios *)args->buffer = tty->termios;
40007bd0: d0 06 20 08 ld [ %i0 + 8 ], %o0
<== NOT EXECUTED
40007bd4: 40 00 24 b3 call 40010ea0 <memcpy>
<== NOT EXECUTED
40007bd8: 92 07 60 50 add %i5, 0x50, %o1
<== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40007bdc: b0 10 20 00 clr %i0
<== NOT EXECUTED
40007be0: 40 00 0b 96 call 4000aa38 <_Mutex_Release>
<== NOT EXECUTED
40007be4: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
}
40007be8: 81 c7 e0 08 ret
<== NOT EXECUTED
40007bec: 81 e8 00 00 restore
<== NOT EXECUTED
*(int*)(args->buffer)=tty->t_line;
40007bf0: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
40007bf4: c4 07 61 5c ld [ %i5 + 0x15c ], %g2
<== NOT EXECUTED
40007bf8: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40007bfc: b0 10 20 00 clr %i0
<== NOT EXECUTED
40007c00: 40 00 0b 8e call 4000aa38 <_Mutex_Release>
<== NOT EXECUTED
40007c04: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
}
40007c08: 81 c7 e0 08 ret
<== NOT EXECUTED
40007c0c: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
40007c10: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
<== NOT EXECUTED
40007c14: 83 28 60 05 sll %g1, 5, %g1
<== NOT EXECUTED
40007c18: 37 10 00 56 sethi %hi(0x40015800), %i3
<== NOT EXECUTED
40007c1c: b6 16 e0 64 or %i3, 0x64, %i3 ! 40015864 <rtems_termios_linesw>
<== NOT EXECUTED
40007c20: 82 06 c0 01 add %i3, %g1, %g1
<== NOT EXECUTED
40007c24: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
40007c28: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007c2c: 02 80 00 05 be 40007c40 <rtems_termios_ioctl+0x13c>
<== NOT EXECUTED
40007c30: b0 10 20 00 clr %i0
<== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
40007c34: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007c38: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40007c3c: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
tty->t_line=*(int*)(args->buffer);
40007c40: c2 07 20 08 ld [ %i4 + 8 ], %g1
<== NOT EXECUTED
40007c44: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
40007c48: c2 27 61 5c st %g1, [ %i5 + 0x15c ]
<== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
40007c4c: 83 28 60 05 sll %g1, 5, %g1
<== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
40007c50: c0 27 61 60 clr [ %i5 + 0x160 ]
<== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
40007c54: c2 06 c0 01 ld [ %i3 + %g1 ], %g1
<== NOT EXECUTED
40007c58: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007c5c: 02 bf ff cb be 40007b88 <rtems_termios_ioctl+0x84>
<== NOT EXECUTED
40007c60: 01 00 00 00 nop
<== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
40007c64: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007c68: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40007c6c: 10 bf ff c7 b 40007b88 <rtems_termios_ioctl+0x84>
<== NOT EXECUTED
40007c70: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
switch (args->command) {
40007c74: 03 08 00 1d sethi %hi(0x20007400), %g1
<== NOT EXECUTED
40007c78: 82 10 60 5e or %g1, 0x5e, %g1 ! 2000745e <RAM_SIZE+0x1fc0745e>
<== NOT EXECUTED
40007c7c: 80 a6 c0 01 cmp %i3, %g1
<== NOT EXECUTED
40007c80: 32 80 00 91 bne,a 40007ec4 <rtems_termios_ioctl+0x3c0>
<== NOT EXECUTED
40007c84: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
<== NOT EXECUTED
drainOutput (tty);
40007c88: 7f ff f8 b0 call 40005f48 <drainOutput>
<== NOT EXECUTED
40007c8c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40007c90: b0 10 20 00 clr %i0
<== NOT EXECUTED
40007c94: 40 00 0b 69 call 4000aa38 <_Mutex_Release>
<== NOT EXECUTED
40007c98: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
}
40007c9c: 81 c7 e0 08 ret
<== NOT EXECUTED
40007ca0: 81 e8 00 00 restore
<== NOT EXECUTED
switch (args->command) {
40007ca4: 33 1f f4 e2 sethi %hi(0x7fd38800), %i1
<== NOT EXECUTED
40007ca8: 82 16 63 ec or %i1, 0x3ec, %g1 ! 7fd38bec <RAM_END+0x3f938bec>
<== NOT EXECUTED
40007cac: 82 06 c0 01 add %i3, %g1, %g1
<== NOT EXECUTED
40007cb0: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
40007cb4: 18 80 00 83 bgu 40007ec0 <rtems_termios_ioctl+0x3bc>
<== NOT EXECUTED
40007cb8: 94 10 20 2c mov 0x2c, %o2
<== NOT EXECUTED
tty->termios = *(struct termios *)args->buffer;
40007cbc: d2 06 20 08 ld [ %i0 + 8 ], %o1
<== NOT EXECUTED
40007cc0: b0 07 60 50 add %i5, 0x50, %i0
<== NOT EXECUTED
40007cc4: 40 00 24 77 call 40010ea0 <memcpy>
<== NOT EXECUTED
40007cc8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (args->command == TIOCSETAW || args->command == TIOCSETAF) {
40007ccc: b2 16 63 eb or %i1, 0x3eb, %i1
<== NOT EXECUTED
40007cd0: b6 06 c0 19 add %i3, %i1, %i3
<== NOT EXECUTED
40007cd4: 80 a6 e0 01 cmp %i3, 1
<== NOT EXECUTED
40007cd8: 08 80 00 df bleu 40008054 <rtems_termios_ioctl+0x550>
<== NOT EXECUTED
40007cdc: 01 00 00 00 nop
<== NOT EXECUTED
if (( tty->flow_ctrl & FL_MDXON) &&
40007ce0: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40007ce4: 80 88 62 00 btst 0x200, %g1
<== NOT EXECUTED
40007ce8: 02 80 00 23 be 40007d74 <rtems_termios_ioctl+0x270>
<== NOT EXECUTED
40007cec: f8 07 61 7c ld [ %i5 + 0x17c ], %i4
<== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
40007cf0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
if (( tty->flow_ctrl & FL_MDXON) &&
40007cf4: 80 88 62 00 btst 0x200, %g1
<== NOT EXECUTED
40007cf8: 12 80 00 1f bne 40007d74 <rtems_termios_ioctl+0x270>
<== NOT EXECUTED
40007cfc: 01 00 00 00 nop
<== NOT EXECUTED
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
40007d00: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40007d04: 82 08 7d ef and %g1, -529, %g1
<== NOT EXECUTED
40007d08: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->flow_ctrl & FL_OSTOP) {
40007d0c: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40007d10: 80 88 60 20 btst 0x20, %g1
<== NOT EXECUTED
40007d14: 02 80 00 18 be 40007d74 <rtems_termios_ioctl+0x270>
<== NOT EXECUTED
40007d18: 01 00 00 00 nop
<== NOT EXECUTED
( *context->lock_acquire )( context, lock_context );
40007d1c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
<== NOT EXECUTED
40007d20: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40007d24: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007d28: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
40007d2c: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40007d30: 82 08 7f df and %g1, -33, %g1
<== NOT EXECUTED
40007d34: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->rawOutBufState != rob_idle) {
40007d38: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
<== NOT EXECUTED
40007d3c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007d40: 22 80 00 0a be,a 40007d68 <rtems_termios_ioctl+0x264>
<== NOT EXECUTED
40007d44: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
40007d48: c4 07 60 c0 ld [ %i5 + 0xc0 ], %g2
<== NOT EXECUTED
40007d4c: d2 07 60 b8 ld [ %i5 + 0xb8 ], %o1
<== NOT EXECUTED
(*tty->handler.write)(
40007d50: c2 07 61 30 ld [ %i5 + 0x130 ], %g1
<== NOT EXECUTED
40007d54: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
40007d58: 92 02 40 02 add %o1, %g2, %o1
<== NOT EXECUTED
40007d5c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007d60: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
( *context->lock_release )( context, lock_context );
40007d64: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
40007d68: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40007d6c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007d70: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
40007d74: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40007d78: 80 88 64 00 btst 0x400, %g1
<== NOT EXECUTED
40007d7c: 02 80 00 06 be 40007d94 <rtems_termios_ioctl+0x290>
<== NOT EXECUTED
40007d80: 01 00 00 00 nop
<== NOT EXECUTED
40007d84: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
40007d88: 80 88 64 00 btst 0x400, %g1
<== NOT EXECUTED
40007d8c: 02 80 00 ab be 40008038 <rtems_termios_ioctl+0x534>
<== NOT EXECUTED
40007d90: 01 00 00 00 nop
<== NOT EXECUTED
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
40007d94: c4 07 61 48 ld [ %i5 + 0x148 ], %g2
<== NOT EXECUTED
40007d98: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
<== NOT EXECUTED
40007d9c: 37 00 00 c0 sethi %hi(0x30000), %i3
<== NOT EXECUTED
40007da0: 80 88 a1 00 btst 0x100, %g2
<== NOT EXECUTED
40007da4: 02 80 00 9c be 40008014 <rtems_termios_ioctl+0x510>
<== NOT EXECUTED
40007da8: 82 08 40 1b and %g1, %i3, %g1
<== NOT EXECUTED
40007dac: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007db0: 02 80 00 87 be 40007fcc <rtems_termios_ioctl+0x4c8>
<== NOT EXECUTED
40007db4: 01 00 00 00 nop
<== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
40007db8: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40007dbc: 82 10 61 00 or %g1, 0x100, %g1
<== NOT EXECUTED
40007dc0: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->termios.c_iflag & IXOFF) {
40007dc4: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
40007dc8: 80 88 64 00 btst 0x400, %g1
<== NOT EXECUTED
40007dcc: 02 80 00 06 be 40007de4 <rtems_termios_ioctl+0x2e0>
<== NOT EXECUTED
40007dd0: 80 88 62 00 btst 0x200, %g1
<== NOT EXECUTED
tty->flow_ctrl |= FL_MDXOF;
40007dd4: c4 07 61 48 ld [ %i5 + 0x148 ], %g2
<== NOT EXECUTED
40007dd8: 84 10 a4 00 or %g2, 0x400, %g2
<== NOT EXECUTED
40007ddc: c4 27 61 48 st %g2, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->termios.c_iflag & IXON) {
40007de0: 80 88 62 00 btst 0x200, %g1
<== NOT EXECUTED
40007de4: 22 80 00 06 be,a 40007dfc <rtems_termios_ioctl+0x2f8>
<== NOT EXECUTED
40007de8: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
<== NOT EXECUTED
tty->flow_ctrl |= FL_MDXON;
40007dec: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40007df0: 82 10 62 00 or %g1, 0x200, %g1
<== NOT EXECUTED
40007df4: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
40007df8: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
<== NOT EXECUTED
40007dfc: 80 88 61 00 btst 0x100, %g1
<== NOT EXECUTED
40007e00: 12 80 00 64 bne 40007f90 <rtems_termios_ioctl+0x48c>
<== NOT EXECUTED
40007e04: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
40007e08: c6 0f 60 71 ldub [ %i5 + 0x71 ], %g3
<== NOT EXECUTED
40007e0c: 03 10 00 48 sethi %hi(0x40012000), %g1
<== NOT EXECUTED
40007e10: c2 00 62 9c ld [ %g1 + 0x29c ], %g1 ! 4001229c <_Watchdog_Ticks_per_second>
<== NOT EXECUTED
40007e14: 82 58 c0 01 smul %g3, %g1, %g1
<== NOT EXECUTED
rtems_clock_get_ticks_per_second() / 10;
40007e18: 05 33 33 33 sethi %hi(0xcccccc00), %g2
<== NOT EXECUTED
40007e1c: 84 10 a0 cd or %g2, 0xcd, %g2 ! cccccccd <RAM_END+0x8c8ccccd>
<== NOT EXECUTED
40007e20: 80 50 40 02 umul %g1, %g2, %g0
<== NOT EXECUTED
40007e24: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
40007e28: 83 30 60 03 srl %g1, 3, %g1
<== NOT EXECUTED
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
40007e2c: c2 27 60 7c st %g1, [ %i5 + 0x7c ]
<== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
40007e30: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40007e34: 02 80 00 7c be 40008024 <rtems_termios_ioctl+0x520>
<== NOT EXECUTED
40007e38: c4 0f 60 70 ldub [ %i5 + 0x70 ], %g2
<== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
40007e3c: 80 88 a0 ff btst 0xff, %g2
<== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
40007e40: c2 27 60 ac st %g1, [ %i5 + 0xac ]
<== NOT EXECUTED
tty->rawInBufSemaphoreWait = true;
40007e44: 84 10 20 01 mov 1, %g2
<== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
40007e48: 12 80 00 54 bne 40007f98 <rtems_termios_ioctl+0x494>
<== NOT EXECUTED
40007e4c: c4 2f 60 a8 stb %g2, [ %i5 + 0xa8 ]
<== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
40007e50: 10 80 00 53 b 40007f9c <rtems_termios_ioctl+0x498>
<== NOT EXECUTED
40007e54: c2 27 60 b0 st %g1, [ %i5 + 0xb0 ]
<== NOT EXECUTED
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
40007e58: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
<== NOT EXECUTED
40007e5c: c4 07 60 84 ld [ %i5 + 0x84 ], %g2
<== NOT EXECUTED
if ( rawnc < 0 )
40007e60: 84 a0 40 02 subcc %g1, %g2, %g2
<== NOT EXECUTED
40007e64: 3c 80 00 05 bpos,a 40007e78 <rtems_termios_ioctl+0x374>
<== NOT EXECUTED
40007e68: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
<== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
40007e6c: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
<== NOT EXECUTED
40007e70: 84 00 80 01 add %g2, %g1, %g2
<== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
40007e74: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
<== NOT EXECUTED
40007e78: c8 07 60 44 ld [ %i5 + 0x44 ], %g4
<== NOT EXECUTED
40007e7c: c6 07 20 08 ld [ %i4 + 8 ], %g3
<== NOT EXECUTED
40007e80: 82 20 40 04 sub %g1, %g4, %g1
<== NOT EXECUTED
40007e84: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
40007e88: c2 20 c0 00 st %g1, [ %g3 ]
<== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40007e8c: b0 10 20 00 clr %i0
<== NOT EXECUTED
40007e90: 40 00 0a ea call 4000aa38 <_Mutex_Release>
<== NOT EXECUTED
40007e94: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
}
40007e98: 81 c7 e0 08 ret
<== NOT EXECUTED
40007e9c: 81 e8 00 00 restore
<== NOT EXECUTED
tty->tty_rcv = *wakeup;
40007ea0: c2 27 61 6c st %g1, [ %i5 + 0x16c ]
<== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40007ea4: b0 10 20 00 clr %i0
<== NOT EXECUTED
tty->tty_rcv = *wakeup;
40007ea8: c2 06 60 04 ld [ %i1 + 4 ], %g1
<== NOT EXECUTED
40007eac: c2 27 61 70 st %g1, [ %i5 + 0x170 ]
<== NOT EXECUTED
40007eb0: 40 00 0a e2 call 4000aa38 <_Mutex_Release>
<== NOT EXECUTED
40007eb4: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
}
40007eb8: 81 c7 e0 08 ret
<== NOT EXECUTED
40007ebc: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
40007ec0: c2 07 61 5c ld [ %i5 + 0x15c ], %g1
40007ec4: 85 28 60 05 sll %g1, 5, %g2
40007ec8: 03 10 00 56 sethi %hi(0x40015800), %g1
40007ecc: 82 10 60 64 or %g1, 0x64, %g1 ! 40015864 <rtems_termios_linesw>
40007ed0: 82 00 40 02 add %g1, %g2, %g1
40007ed4: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40007ed8: 80 a0 60 00 cmp %g1, 0
40007edc: 02 80 00 77 be 400080b8 <rtems_termios_ioctl+0x5b4>
<== ALWAYS TAKEN
40007ee0: 92 10 00 1c mov %i4, %o1
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
40007ee4: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007ee8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40007eec: 10 bf ff 27 b 40007b88 <rtems_termios_ioctl+0x84>
<== NOT EXECUTED
40007ef0: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
flags = *((int *)args->buffer);
40007ef4: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
40007ef8: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
if (flags == 0) {
40007efc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007f00: 22 80 00 05 be,a 40007f14 <rtems_termios_ioctl+0x410>
<== NOT EXECUTED
40007f04: b6 10 20 01 mov 1, %i3
<== NOT EXECUTED
if (flags & FWRITE) {
40007f08: 80 88 60 02 btst 2, %g1
<== NOT EXECUTED
40007f0c: 02 80 00 0e be 40007f44 <rtems_termios_ioctl+0x440>
<== NOT EXECUTED
40007f10: b6 08 60 01 and %g1, 1, %i3
<== NOT EXECUTED
rtems_termios_device_context *ctx = tty->device_context;
40007f14: f8 07 61 7c ld [ %i5 + 0x17c ], %i4
<== NOT EXECUTED
( *context->lock_acquire )( context, lock_context );
40007f18: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
<== NOT EXECUTED
40007f1c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40007f20: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007f24: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
tty->rawOutBuf.Tail = 0;
40007f28: c0 27 60 c0 clr [ %i5 + 0xc0 ]
<== NOT EXECUTED
( *context->lock_release )( context, lock_context );
40007f2c: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
tty->rawOutBuf.Head = 0;
40007f30: c0 27 60 bc clr [ %i5 + 0xbc ]
<== NOT EXECUTED
tty->rawOutBufState = rob_idle;
40007f34: c0 27 60 e4 clr [ %i5 + 0xe4 ]
<== NOT EXECUTED
40007f38: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
40007f3c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007f40: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if (flags & FREAD) {
40007f44: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
40007f48: 22 80 00 0e be,a 40007f80 <rtems_termios_ioctl+0x47c>
<== NOT EXECUTED
40007f4c: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_termios_device_context *ctx = tty->device_context;
40007f50: f8 07 61 7c ld [ %i5 + 0x17c ], %i4
<== NOT EXECUTED
( *context->lock_acquire )( context, lock_context );
40007f54: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
<== NOT EXECUTED
40007f58: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40007f5c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007f60: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
tty->rawInBuf.Tail = 0;
40007f64: c0 27 60 88 clr [ %i5 + 0x88 ]
<== NOT EXECUTED
( *context->lock_release )( context, lock_context );
40007f68: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
tty->rawInBuf.Head = 0;
40007f6c: c0 27 60 84 clr [ %i5 + 0x84 ]
<== NOT EXECUTED
40007f70: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
40007f74: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007f78: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40007f7c: b0 10 20 00 clr %i0
<== NOT EXECUTED
40007f80: 40 00 0a ae call 4000aa38 <_Mutex_Release>
<== NOT EXECUTED
40007f84: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
}
40007f88: 81 c7 e0 08 ret
<== NOT EXECUTED
40007f8c: 81 e8 00 00 restore
<== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = 0;
40007f90: c0 27 60 ac clr [ %i5 + 0xac ]
<== NOT EXECUTED
tty->rawInBufSemaphoreWait = true;
40007f94: c2 2f 60 a8 stb %g1, [ %i5 + 0xa8 ]
<== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = 0;
40007f98: c0 27 60 b0 clr [ %i5 + 0xb0 ]
<== NOT EXECUTED
if (tty->handler.set_attributes) {
40007f9c: c2 07 61 34 ld [ %i5 + 0x134 ], %g1
<== NOT EXECUTED
40007fa0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007fa4: 02 bf ff f6 be 40007f7c <rtems_termios_ioctl+0x478>
<== NOT EXECUTED
40007fa8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
sc = (*tty->handler.set_attributes)(tty->device_context, &tty->termios) ?
40007fac: d0 07 61 7c ld [ %i5 + 0x17c ], %o0
<== NOT EXECUTED
40007fb0: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007fb4: b0 10 20 1b mov 0x1b, %i0
<== NOT EXECUTED
RTEMS_SUCCESSFUL : RTEMS_IO_ERROR;
40007fb8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40007fbc: 02 bf fe f3 be 40007b88 <rtems_termios_ioctl+0x84>
<== NOT EXECUTED
40007fc0: 01 00 00 00 nop
<== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
40007fc4: 10 bf ff ef b 40007f80 <rtems_termios_ioctl+0x47c>
<== NOT EXECUTED
40007fc8: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
tty->flow_ctrl &= ~(FL_MDRTS);
40007fcc: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40007fd0: 82 08 7e ff and %g1, -257, %g1
<== NOT EXECUTED
40007fd4: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_IRTSOFF) &&
40007fd8: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40007fdc: 80 88 60 04 btst 4, %g1
<== NOT EXECUTED
40007fe0: 02 80 00 31 be 400080a4 <rtems_termios_ioctl+0x5a0>
<== NOT EXECUTED
40007fe4: 01 00 00 00 nop
<== NOT EXECUTED
(tty->flow.start_remote_tx != NULL)) {
40007fe8: c2 07 61 44 ld [ %i5 + 0x144 ], %g1
<== NOT EXECUTED
if ((tty->flow_ctrl & FL_IRTSOFF) &&
40007fec: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40007ff0: 02 80 00 2d be 400080a4 <rtems_termios_ioctl+0x5a0>
<== NOT EXECUTED
40007ff4: 01 00 00 00 nop
<== NOT EXECUTED
tty->flow.start_remote_tx(ctx);
40007ff8: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007ffc: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
tty->flow_ctrl &= ~(FL_IRTSOFF);
40008000: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40008004: 82 08 7f fb and %g1, -5, %g1
<== NOT EXECUTED
40008008: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
4000800c: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
<== NOT EXECUTED
40008010: 82 08 40 1b and %g1, %i3, %g1
<== NOT EXECUTED
if (tty->termios.c_cflag & CRTSCTS) {
40008014: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40008018: 22 bf ff 6c be,a 40007dc8 <rtems_termios_ioctl+0x2c4>
<== NOT EXECUTED
4000801c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
40008020: 30 bf ff 66 b,a 40007db8 <rtems_termios_ioctl+0x2b4>
<== NOT EXECUTED
if (tty->termios.c_cc[VMIN]) {
40008024: 80 88 a0 ff btst 0xff, %g2
<== NOT EXECUTED
40008028: 12 bf ff da bne 40007f90 <rtems_termios_ioctl+0x48c>
<== NOT EXECUTED
4000802c: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
tty->rawInBufSemaphoreWait = false;
40008030: 10 bf ff db b 40007f9c <rtems_termios_ioctl+0x498>
<== NOT EXECUTED
40008034: c0 2f 60 a8 clrb [ %i5 + 0xa8 ]
<== NOT EXECUTED
tty->flow_ctrl &= ~(FL_MDXOF);
40008038: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
4000803c: 82 08 7b ff and %g1, -1025, %g1
<== NOT EXECUTED
40008040: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
tty->flow_ctrl &= ~(FL_ISNTXOF);
40008044: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
40008048: 82 08 7f fd and %g1, -3, %g1
<== NOT EXECUTED
4000804c: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
40008050: 30 bf ff 51 b,a 40007d94 <rtems_termios_ioctl+0x290>
<== NOT EXECUTED
drainOutput (tty);
40008054: 7f ff f7 bd call 40005f48 <drainOutput>
<== NOT EXECUTED
40008058: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if (args->command == TIOCSETAF) {
4000805c: c4 07 20 04 ld [ %i4 + 4 ], %g2
<== NOT EXECUTED
40008060: 03 20 0b 1d sethi %hi(0x802c7400), %g1
<== NOT EXECUTED
40008064: 82 10 60 16 or %g1, 0x16, %g1 ! 802c7416 <RAM_END+0x3fec7416>
<== NOT EXECUTED
40008068: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4000806c: 12 bf ff 1d bne 40007ce0 <rtems_termios_ioctl+0x1dc>
<== NOT EXECUTED
40008070: 01 00 00 00 nop
<== NOT EXECUTED
rtems_termios_device_context *ctx = tty->device_context;
40008074: f8 07 61 7c ld [ %i5 + 0x17c ], %i4
<== NOT EXECUTED
( *context->lock_acquire )( context, lock_context );
40008078: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
<== NOT EXECUTED
4000807c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40008080: 9f c0 40 00 call %g1
<== NOT EXECUTED
40008084: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
tty->rawInBuf.Tail = 0;
40008088: c0 27 60 88 clr [ %i5 + 0x88 ]
<== NOT EXECUTED
( *context->lock_release )( context, lock_context );
4000808c: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
tty->rawInBuf.Head = 0;
40008090: c0 27 60 84 clr [ %i5 + 0x84 ]
<== NOT EXECUTED
40008094: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
<== NOT EXECUTED
40008098: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000809c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
400080a0: 30 bf ff 10 b,a 40007ce0 <rtems_termios_ioctl+0x1dc>
<== NOT EXECUTED
tty->flow_ctrl &= ~(FL_IRTSOFF);
400080a4: c2 07 61 48 ld [ %i5 + 0x148 ], %g1
<== NOT EXECUTED
400080a8: 82 08 7f fb and %g1, -5, %g1
<== NOT EXECUTED
400080ac: c2 27 61 48 st %g1, [ %i5 + 0x148 ]
<== NOT EXECUTED
if (tty->termios.c_iflag & IXOFF) {
400080b0: 10 bf ff 46 b 40007dc8 <rtems_termios_ioctl+0x2c4>
<== NOT EXECUTED
400080b4: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
<== NOT EXECUTED
} else if (tty->handler.ioctl) {
400080b8: c2 07 61 38 ld [ %i5 + 0x138 ], %g1
400080bc: 80 a0 60 00 cmp %g1, 0
400080c0: 02 80 00 08 be 400080e0 <rtems_termios_ioctl+0x5dc>
<== ALWAYS TAKEN
400080c4: 92 10 00 1b mov %i3, %o1
args->ioctl_return = (*tty->handler.ioctl) (tty->device_context,
400080c8: d4 07 20 08 ld [ %i4 + 8 ], %o2
<== NOT EXECUTED
400080cc: d0 07 61 7c ld [ %i5 + 0x17c ], %o0
<== NOT EXECUTED
400080d0: 9f c0 40 00 call %g1
<== NOT EXECUTED
400080d4: b0 10 20 00 clr %i0
<== NOT EXECUTED
400080d8: 10 bf fe ac b 40007b88 <rtems_termios_ioctl+0x84>
<== NOT EXECUTED
400080dc: d0 27 20 0c st %o0, [ %i4 + 0xc ]
<== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
400080e0: 10 bf fe aa b 40007b88 <rtems_termios_ioctl+0x84>
400080e4: b0 10 20 0a mov 0xa, %i0
40008608 <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 ) {
40008608: 03 10 00 4a sethi %hi(0x40012800), %g1
4000860c: c6 00 61 50 ld [ %g1 + 0x150 ], %g3 ! 40012950 <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;
40008610: 05 00 01 c2 sethi %hi(0x70800), %g2
while ( current->name != NULL && current->local_value < baud ) {
40008614: 80 a0 e0 00 cmp %g3, 0
40008618: 02 80 00 12 be 40008660 <rtems_termios_set_best_baud+0x58>
<== NEVER TAKEN
4000861c: 82 10 61 50 or %g1, 0x150, %g1
40008620: c8 00 60 04 ld [ %g1 + 4 ], %g4
40008624: 80 a2 40 04 cmp %o1, %g4
40008628: 38 80 00 0a bgu,a 40008650 <rtems_termios_set_best_baud+0x48>
<== ALWAYS TAKEN
4000862c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40008630: 10 80 00 1b b 4000869c <rtems_termios_set_best_baud+0x94>
<== NOT EXECUTED
40008634: 86 10 00 04 mov %g4, %g3
<== NOT EXECUTED
40008638: c6 00 a0 04 ld [ %g2 + 4 ], %g3
4000863c: 80 a0 c0 09 cmp %g3, %o1
40008640: 3a 80 00 0b bcc,a 4000866c <rtems_termios_set_best_baud+0x64>
<== NEVER TAKEN
40008644: c8 00 60 04 ld [ %g1 + 4 ], %g4
<== NOT EXECUTED
40008648: 82 10 00 02 mov %g2, %g1
4000864c: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
40008650: 80 a0 e0 00 cmp %g3, 0
40008654: 12 bf ff f9 bne 40008638 <rtems_termios_set_best_baud+0x30>
40008658: 84 00 60 0c add %g1, 0xc, %g2
spd = B460800;
4000865c: 05 00 01 c2 sethi %hi(0x70800), %g2
}
term->c_ispeed = spd;
40008660: c4 22 20 24 st %g2, [ %o0 + 0x24 ]
term->c_ospeed = spd;
}
40008664: 81 c3 e0 08 retl
40008668: c4 22 20 28 st %g2, [ %o0 + 0x28 ]
uint32_t mid = (last->local_value + current->local_value) / UINT32_C( 2 );
4000866c: 86 00 c0 04 add %g3, %g4, %g3
<== NOT EXECUTED
40008670: 87 30 e0 01 srl %g3, 1, %g3
<== NOT EXECUTED
spd = baud <= mid ? last->remote_value : current->remote_value;
40008674: 80 a2 40 03 cmp %o1, %g3
<== NOT EXECUTED
40008678: 28 80 00 06 bleu,a 40008690 <rtems_termios_set_best_baud+0x88>
<== NOT EXECUTED
4000867c: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
40008680: c4 00 a0 08 ld [ %g2 + 8 ], %g2
<== NOT EXECUTED
term->c_ispeed = spd;
40008684: c4 22 20 24 st %g2, [ %o0 + 0x24 ]
<== NOT EXECUTED
}
40008688: 81 c3 e0 08 retl
<== NOT EXECUTED
4000868c: c4 22 20 28 st %g2, [ %o0 + 0x28 ]
<== NOT EXECUTED
term->c_ispeed = spd;
40008690: c4 22 20 24 st %g2, [ %o0 + 0x24 ]
<== NOT EXECUTED
}
40008694: 81 c3 e0 08 retl
<== NOT EXECUTED
40008698: c4 22 20 28 st %g2, [ %o0 + 0x28 ]
<== NOT EXECUTED
const rtems_assoc_t *current = &rtems_termios_baud_table[ 0 ];
4000869c: 10 bf ff f4 b 4000866c <rtems_termios_set_best_baud+0x64>
<== NOT EXECUTED
400086a0: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
4000df20 <rtems_vprintf>:
int rtems_vprintf(
const rtems_printer *printer,
const char *format,
va_list ap
)
{
4000df20: 9d e3 bf a0 save %sp, -96, %sp
4000df24: 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;
4000df28: 80 a0 60 00 cmp %g1, 0
4000df2c: 02 80 00 0a be 4000df54 <rtems_vprintf+0x34>
<== NEVER TAKEN
4000df30: b0 10 20 00 clr %i0
4000df34: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000df38: 80 a0 a0 00 cmp %g2, 0
4000df3c: 02 80 00 06 be 4000df54 <rtems_vprintf+0x34>
<== NEVER TAKEN
4000df40: 94 10 00 1a mov %i2, %o2
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
len = printer->printer( printer->context, format, ap );
4000df44: d0 00 40 00 ld [ %g1 ], %o0
4000df48: 9f c0 80 00 call %g2
4000df4c: 92 10 00 19 mov %i1, %o1
4000df50: b0 10 00 08 mov %o0, %i0
}
return len;
}
4000df54: 81 c7 e0 08 ret
4000df58: 81 e8 00 00 restore
400049b0 <setgrent>:
void setgrent(void)
{
400049b0: 9d e3 bf a0 save %sp, -96, %sp
grp_context *ctx = grp_get_context();
400049b4: 7f ff ff d8 call 40004914 <grp_get_context>
400049b8: 01 00 00 00 nop
if (ctx == NULL) {
400049bc: ba 92 20 00 orcc %o0, 0, %i5
400049c0: 02 80 00 12 be 40004a08 <setgrent+0x58>
400049c4: 92 10 21 14 mov 0x114, %o1
return;
}
}
_libcsupport_pwdgrp_init();
400049c8: 40 00 04 26 call 40005a60 <_libcsupport_pwdgrp_init>
400049cc: 01 00 00 00 nop
if (ctx->fp != NULL)
400049d0: d0 07 40 00 ld [ %i5 ], %o0
400049d4: 80 a2 20 00 cmp %o0, 0
400049d8: 02 80 00 05 be 400049ec <setgrent+0x3c>
400049dc: 13 10 00 4b sethi %hi(0x40012c00), %o1
fclose(ctx->fp);
400049e0: 40 00 2a 6c call 4000f390 <fclose>
400049e4: 01 00 00 00 nop
ctx->fp = fopen("/etc/group", "r");
400049e8: 13 10 00 4b sethi %hi(0x40012c00), %o1
400049ec: 11 10 00 4b sethi %hi(0x40012c00), %o0
400049f0: 92 12 62 b0 or %o1, 0x2b0, %o1
400049f4: 40 00 2c 9c call 4000fc64 <fopen>
400049f8: 90 12 22 b8 or %o0, 0x2b8, %o0
400049fc: d0 27 40 00 st %o0, [ %i5 ]
}
40004a00: 81 c7 e0 08 ret
40004a04: 81 e8 00 00 restore
ctx = calloc(1, sizeof(*ctx));
40004a08: 7f ff ff 4a call 40004730 <calloc>
40004a0c: 90 10 20 01 mov 1, %o0
if (ctx == NULL)
40004a10: ba 92 20 00 orcc %o0, 0, %i5
40004a14: 02 bf ff fb be 40004a00 <setgrent+0x50>
<== NEVER TAKEN
40004a18: b0 10 00 08 mov %o0, %i0
eno = pthread_setspecific(grp_key, ctx);
40004a1c: 03 10 00 56 sethi %hi(0x40015800), %g1
40004a20: d0 00 63 20 ld [ %g1 + 0x320 ], %o0 ! 40015b20 <grp_key>
40004a24: 40 00 09 f1 call 400071e8 <pthread_setspecific>
40004a28: 92 10 00 18 mov %i0, %o1
if (eno != 0) {
40004a2c: 80 a2 20 00 cmp %o0, 0
40004a30: 02 bf ff e6 be 400049c8 <setgrent+0x18>
<== ALWAYS TAKEN
40004a34: 01 00 00 00 nop
free(ctx);
40004a38: 7f ff ff 89 call 4000485c <free>
<== NOT EXECUTED
40004a3c: 81 e8 00 00 restore
<== NOT EXECUTED
40006e9c <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 )
{
40006e9c: 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 =
40006ea0: 94 10 20 18 mov 0x18, %o2
40006ea4: 92 10 00 18 mov %i0, %o1
40006ea8: 7f ff fd 8d call 400064dc <rtems_filesystem_eval_path_start>
40006eac: 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;
40006eb0: fa 02 20 14 ld [ %o0 + 0x14 ], %i5
return (*mt_entry->ops->are_nodes_equal_h)(
40006eb4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40006eb8: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40006ebc: 9f c0 40 00 call %g1
40006ec0: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
40006ec4: 80 a2 20 00 cmp %o0, 0
40006ec8: 02 80 00 34 be 40006f98 <unmount+0xfc>
40006ecc: 01 00 00 00 nop
&rtems_filesystem_root->location;
40006ed0: 7f ff fb 53 call 40005c1c <rtems_current_user_env_get>
40006ed4: 01 00 00 00 nop
&rtems_filesystem_current->location;
40006ed8: 7f ff fb 51 call 40005c1c <rtems_current_user_env_get>
40006edc: f8 02 20 04 ld [ %o0 + 4 ], %i4
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
40006ee0: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40006ee4: 80 a7 40 01 cmp %i5, %g1
40006ee8: 02 80 00 14 be 40006f38 <unmount+0x9c>
40006eec: 01 00 00 00 nop
40006ef0: c2 02 00 00 ld [ %o0 ], %g1
40006ef4: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40006ef8: 80 a7 40 01 cmp %i5, %g1
40006efc: 02 80 00 0f be 40006f38 <unmount+0x9c>
40006f00: 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;
40006f04: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
const rtems_filesystem_operations_table *mt_point_ops =
40006f08: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
40006f0c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40006f10: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
40006f14: 9f c0 40 00 call %g1
40006f18: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40006f1c: b0 92 20 00 orcc %o0, 0, %i0
40006f20: 02 80 00 0b be 40006f4c <unmount+0xb0>
40006f24: 01 00 00 00 nop
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40006f28: 7f ff fd b7 call 40006604 <rtems_filesystem_eval_path_cleanup>
40006f2c: 90 07 bf c8 add %fp, -56, %o0
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
40006f30: 81 c7 e0 08 ret
40006f34: 81 e8 00 00 restore
errno = EBUSY;
40006f38: 40 00 1f b6 call 4000ee10 <__errno>
40006f3c: b0 10 3f ff mov -1, %i0
40006f40: 82 10 20 10 mov 0x10, %g1
40006f44: 10 bf ff f9 b 40006f28 <unmount+0x8c>
40006f48: c2 22 00 00 st %g1, [ %o0 ]
rtems_id self_task_id = rtems_task_self();
40006f4c: 40 00 01 d6 call 400076a4 <rtems_task_self>
40006f50: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006f54: 91 d0 20 09 ta 9
<== NOT EXECUTED
mt_entry->unmount_task = self_task_id;
40006f58: d0 27 60 3c st %o0, [ %i5 + 0x3c ]
<== NOT EXECUTED
mt_entry->mounted = false;
40006f5c: c0 2f 60 28 clrb [ %i5 + 0x28 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006f60: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006f64: 01 00 00 00 nop
rtems_filesystem_eval_path_cleanup( &ctx );
40006f68: 7f ff fd a7 call 40006604 <rtems_filesystem_eval_path_cleanup>
40006f6c: 90 07 bf c8 add %fp, -56, %o0
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
40006f70: 96 07 bf c4 add %fp, -60, %o3
40006f74: 94 10 20 00 clr %o2
40006f78: 92 10 20 00 clr %o1
40006f7c: 40 00 01 6c call 4000752c <rtems_event_system_receive>
40006f80: 11 20 00 00 sethi %hi(0x80000000), %o0
if ( sc != RTEMS_SUCCESSFUL ) {
40006f84: 80 a2 20 00 cmp %o0, 0
40006f88: 02 bf ff ea be 40006f30 <unmount+0x94>
<== ALWAYS TAKEN
40006f8c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
40006f90: 40 00 01 fb call 4000777c <rtems_fatal_error_occurred>
<== NOT EXECUTED
40006f94: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0x9e6dbeef>
<== NOT EXECUTED
errno = EACCES;
40006f98: 40 00 1f 9e call 4000ee10 <__errno>
40006f9c: b0 10 3f ff mov -1, %i0
40006fa0: 82 10 20 0d mov 0xd, %g1
40006fa4: c2 22 00 00 st %g1, [ %o0 ]
rtems_filesystem_eval_path_cleanup( &ctx );
40006fa8: 7f ff fd 97 call 40006604 <rtems_filesystem_eval_path_cleanup>
40006fac: 90 07 bf c8 add %fp, -56, %o0
40006fb0: 81 c7 e0 08 ret
40006fb4: 81 e8 00 00 restore
40018d68 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
40018d68: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
40018d6c: 80 a6 60 00 cmp %i1, 0
40018d70: 02 80 00 32 be 40018e38 <write+0xd0>
<== NEVER TAKEN
40018d74: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
40018d78: 02 80 00 22 be 40018e00 <write+0x98>
40018d7c: 84 10 20 00 clr %g2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40018d80: 03 10 00 64 sethi %hi(0x40019000), %g1
40018d84: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 400192e8 <rtems_libio_number_iops>
40018d88: 80 a6 00 01 cmp %i0, %g1
40018d8c: 1a 80 00 25 bcc 40018e20 <write+0xb8>
40018d90: bb 2e 20 01 sll %i0, 1, %i5
40018d94: ba 07 40 18 add %i5, %i0, %i5
40018d98: 31 10 00 72 sethi %hi(0x4001c800), %i0
<== NOT EXECUTED
40018d9c: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40018da0: b0 16 22 28 or %i0, 0x228, %i0
<== NOT EXECUTED
40018da4: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018da8: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40018dac: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40018db0: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40018db4: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018db8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018dbc: 01 00 00 00 nop
40018dc0: 84 08 a1 04 and %g2, 0x104, %g2
40018dc4: 80 a0 a1 04 cmp %g2, 0x104
40018dc8: 12 80 00 10 bne 40018e08 <write+0xa0>
40018dcc: 94 10 00 1a mov %i2, %o2
/*
* Now process the write() request.
*/
n = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
40018dd0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40018dd4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40018dd8: 92 10 00 19 mov %i1, %o1
40018ddc: 9f c0 40 00 call %g1
40018de0: 90 10 00 1d mov %i5, %o0
40018de4: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018de8: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40018dec: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
40018df0: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
40018df4: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018df8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018dfc: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return n;
}
40018e00: 81 c7 e0 08 ret
40018e04: 91 e8 00 02 restore %g0, %g2, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40018e08: 91 d0 20 09 ta 9
<== NOT EXECUTED
40018e0c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40018e10: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40018e14: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40018e18: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40018e1c: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40018e20: 7f ff dc da call 40010188 <__errno>
40018e24: 01 00 00 00 nop
40018e28: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
40018e2c: 84 10 3f ff mov -1, %g2
40018e30: 10 bf ff f4 b 40018e00 <write+0x98>
40018e34: c2 22 00 00 st %g1, [ %o0 ]
rtems_libio_check_buffer( buffer );
40018e38: 7f ff dc d4 call 40010188 <__errno>
<== NOT EXECUTED
40018e3c: 01 00 00 00 nop
<== NOT EXECUTED
40018e40: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40018e44: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40018e48: 10 bf ff ee b 40018e00 <write+0x98>
<== NOT EXECUTED
40018e4c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40007304 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
40007304: 9d e3 bf a0 save %sp, -96, %sp
if ( iov == NULL )
40007308: 80 a6 60 00 cmp %i1, 0
4000730c: 02 80 00 3f be 40007408 <writev+0x104>
40007310: 80 a6 a0 00 cmp %i2, 0
if ( iovcnt <= 0 )
40007314: 04 80 00 3d ble 40007408 <writev+0x104>
40007318: 80 a6 a4 00 cmp %i2, 0x400
if ( iovcnt > IOV_MAX )
4000731c: 14 80 00 3b bg 40007408 <writev+0x104>
40007320: bb 2e a0 03 sll %i2, 3, %i5
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
40007324: 09 1f ff ff sethi %hi(0x7ffffc00), %g4
40007328: 82 10 00 19 mov %i1, %g1
4000732c: ba 07 40 19 add %i5, %i1, %i5
total = 0;
40007330: 96 10 20 00 clr %o3
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
40007334: 88 11 23 ff or %g4, 0x3ff, %g4
size_t len = iov[ v ].iov_len;
40007338: c4 00 60 04 ld [ %g1 + 4 ], %g2
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
4000733c: 86 21 00 0b sub %g4, %o3, %g3
40007340: 80 a0 80 03 cmp %g2, %g3
40007344: 18 80 00 31 bgu 40007408 <writev+0x104>
40007348: 01 00 00 00 nop
if ( iov[ v ].iov_base == NULL && len != 0 ) {
4000734c: c6 00 40 00 ld [ %g1 ], %g3
40007350: 80 a0 e0 00 cmp %g3, 0
40007354: 12 80 00 05 bne 40007368 <writev+0x64>
40007358: 96 02 c0 02 add %o3, %g2, %o3
4000735c: 80 a0 a0 00 cmp %g2, 0
40007360: 12 80 00 2a bne 40007408 <writev+0x104>
40007364: 01 00 00 00 nop
40007368: 82 00 60 08 add %g1, 8, %g1
for ( v = 0 ; v < iovcnt ; ++v ) {
4000736c: 80 a7 40 01 cmp %i5, %g1
40007370: 32 bf ff f3 bne,a 4000733c <writev+0x38>
40007374: c4 00 60 04 ld [ %g1 + 4 ], %g2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
40007378: 03 10 00 43 sethi %hi(0x40010c00), %g1
4000737c: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1 ! 40010ef8 <rtems_libio_number_iops>
40007380: 80 a6 00 01 cmp %i0, %g1
40007384: 1a 80 00 2e bcc 4000743c <writev+0x138>
40007388: bb 2e 20 01 sll %i0, 1, %i5
return &rtems_libio_iops[ fd ];
4000738c: 03 10 00 50 sethi %hi(0x40014000), %g1
<== NOT EXECUTED
40007390: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40007394: 82 10 63 c8 or %g1, 0x3c8, %g1
<== NOT EXECUTED
40007398: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
4000739c: ba 07 40 01 add %i5, %g1, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400073a0: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400073a4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400073a8: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400073ac: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400073b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400073b4: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
400073b8: 84 08 a1 04 and %g2, 0x104, %g2
400073bc: 80 a0 a1 04 cmp %g2, 0x104
400073c0: 12 80 00 19 bne 40007424 <writev+0x120>
400073c4: 80 a2 e0 00 cmp %o3, 0
if ( total > 0 ) {
400073c8: 04 80 00 08 ble 400073e8 <writev+0xe4>
400073cc: 94 10 00 1a mov %i2, %o2
return ( *iop->pathinfo.handlers->writev_h )( iop, iov, iovcnt, total );
400073d0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400073d4: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
400073d8: 92 10 00 19 mov %i1, %o1
400073dc: 9f c0 40 00 call %g1
400073e0: 90 10 00 1d mov %i5, %o0
400073e4: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400073e8: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
400073ec: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400073f0: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400073f4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400073f8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400073fc: 01 00 00 00 nop
iov,
iovcnt,
LIBIO_FLAGS_WRITE,
writev_adapter
);
}
40007400: 81 c7 e0 08 ret
40007404: 91 e8 00 0b restore %g0, %o3, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
40007408: 40 00 1f 4c call 4000f138 <__errno>
4000740c: 01 00 00 00 nop
40007410: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
40007414: c2 22 00 00 st %g1, [ %o0 ]
40007418: 96 10 3f ff mov -1, %o3
4000741c: 81 c7 e0 08 ret
40007420: 91 e8 00 0b restore %g0, %o3, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007424: 91 d0 20 09 ta 9
<== NOT EXECUTED
40007428: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000742c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40007430: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007434: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007438: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
4000743c: 40 00 1f 3f call 4000f138 <__errno>
40007440: 01 00 00 00 nop
40007444: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
40007448: 96 10 3f ff mov -1, %o3
4000744c: 10 bf ff f4 b 4000741c <writev+0x118>
40007450: c2 22 00 00 st %g1, [ %o0 ]