4000548c <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
4000548c: 9d e3 bf 90 save %sp, -112, %sp
double result;
char *end;
if ( !n )
40005490: 80 a6 60 00 cmp %i1, 0
40005494: 02 80 00 1a be 400054fc <rtems_string_to_double+0x70>
40005498: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000549c: 40 00 29 37 call 4000f978 <__errno>
400054a0: 01 00 00 00 nop
400054a4: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtod( s, &end );
400054a8: 92 07 bf fc add %fp, -4, %o1
*n = 0;
400054ac: c0 26 40 00 clr [ %i1 ]
result = strtod( s, &end );
400054b0: 90 10 00 18 mov %i0, %o0
400054b4: 40 00 30 53 call 40011600 <strtod>
400054b8: c0 26 60 04 clr [ %i1 + 4 ]
if ( endptr )
400054bc: 80 a6 a0 00 cmp %i2, 0
400054c0: 02 80 00 03 be 400054cc <rtems_string_to_double+0x40>
400054c4: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
400054c8: c4 26 80 00 st %g2, [ %i2 ]
400054cc: c1 3f bf f0 std %f0, [ %fp + -16 ]
if ( end == s )
400054d0: 80 a6 00 02 cmp %i0, %g2
400054d4: 02 80 00 0a be 400054fc <rtems_string_to_double+0x70>
400054d8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
400054dc: 40 00 29 27 call 4000f978 <__errno>
400054e0: 01 00 00 00 nop
400054e4: c2 02 00 00 ld [ %o0 ], %g1
400054e8: 80 a0 60 22 cmp %g1, 0x22
400054ec: 02 80 00 06 be 40005504 <rtems_string_to_double+0x78>
400054f0: c1 1f bf f0 ldd [ %fp + -16 ], %f0
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
400054f4: c1 3e 40 00 std %f0, [ %i1 ]
return RTEMS_SUCCESSFUL;
400054f8: 82 10 20 00 clr %g1
}
400054fc: 81 c7 e0 08 ret
40005500: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
40005504: 03 10 00 56 sethi %hi(0x40015800), %g1
40005508: d1 18 63 48 ldd [ %g1 + 0x348 ], %f8 ! 40015b48 <_rodata_start+0x17a8>
4000550c: 81 a8 0a 48 fcmpd %f0, %f8
40005510: 01 00 00 00 nop
40005514: 13 bf ff fa fbe 400054fc <rtems_string_to_double+0x70>
40005518: 82 10 20 0a mov 0xa, %g1 ! a <_TLS_Alignment+0x9>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4000551c: 05 10 00 57 sethi %hi(0x40015c00), %g2
40005520: d1 18 a3 28 ldd [ %g2 + 0x328 ], %f8 ! 40015f28 <rtems_filesystem_null_handlers+0x40>
40005524: 81 a8 0a c8 fcmped %f0, %f8
40005528: 01 00 00 00 nop
4000552c: 0d bf ff f4 fbg 400054fc <rtems_string_to_double+0x70>
40005530: 05 10 00 57 sethi %hi(0x40015c00), %g2
40005534: d1 18 a3 30 ldd [ %g2 + 0x330 ], %f8 ! 40015f30 <rtems_filesystem_null_handlers+0x48>
40005538: 81 a8 0a c8 fcmped %f0, %f8
4000553c: 01 00 00 00 nop
40005540: 09 bf ff ef fbl 400054fc <rtems_string_to_double+0x70>
40005544: 01 00 00 00 nop
*n = result;
40005548: c1 3e 40 00 std %f0, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000554c: 10 bf ff ec b 400054fc <rtems_string_to_double+0x70>
<== NOT EXECUTED
40005550: 82 10 20 00 clr %g1
<== NOT EXECUTED
40005554 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
40005554: 9d e3 bf 90 save %sp, -112, %sp
float result;
char *end;
if ( !n )
40005558: 80 a6 60 00 cmp %i1, 0
4000555c: 02 80 00 19 be 400055c0 <rtems_string_to_float+0x6c>
40005560: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
40005564: 40 00 29 05 call 4000f978 <__errno>
40005568: 01 00 00 00 nop
4000556c: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtof( s, &end );
40005570: 92 07 bf fc add %fp, -4, %o1
*n = 0;
40005574: c0 26 40 00 clr [ %i1 ]
result = strtof( s, &end );
40005578: 40 00 30 2a call 40011620 <strtof>
4000557c: 90 10 00 18 mov %i0, %o0
if ( endptr )
40005580: 80 a6 a0 00 cmp %i2, 0
40005584: 02 80 00 03 be 40005590 <rtems_string_to_float+0x3c>
40005588: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000558c: c4 26 80 00 st %g2, [ %i2 ]
40005590: c1 27 bf f4 st %f0, [ %fp + -12 ]
if ( end == s )
40005594: 80 a6 00 02 cmp %i0, %g2
40005598: 02 80 00 0a be 400055c0 <rtems_string_to_float+0x6c>
4000559c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
400055a0: 40 00 28 f6 call 4000f978 <__errno>
400055a4: 01 00 00 00 nop
400055a8: c2 02 00 00 ld [ %o0 ], %g1
400055ac: 80 a0 60 22 cmp %g1, 0x22
400055b0: 02 80 00 06 be 400055c8 <rtems_string_to_float+0x74>
400055b4: c1 07 bf f4 ld [ %fp + -12 ], %f0
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
400055b8: c1 26 40 00 st %f0, [ %i1 ]
return RTEMS_SUCCESSFUL;
400055bc: 82 10 20 00 clr %g1
}
400055c0: 81 c7 e0 08 ret
400055c4: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
400055c8: 03 10 00 56 sethi %hi(0x40015800), %g1
400055cc: d1 00 61 28 ld [ %g1 + 0x128 ], %f8 ! 40015928 <_rodata_start+0x1588>
400055d0: 81 a8 0a 28 fcmps %f0, %f8
400055d4: 01 00 00 00 nop
400055d8: 13 bf ff fa fbe 400055c0 <rtems_string_to_float+0x6c>
400055dc: 82 10 20 0a mov 0xa, %g1 ! a <_TLS_Alignment+0x9>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
400055e0: 05 10 00 57 sethi %hi(0x40015c00), %g2
400055e4: d1 00 a3 38 ld [ %g2 + 0x338 ], %f8 ! 40015f38 <rtems_filesystem_null_handlers+0x50>
400055e8: 81 a8 0a a8 fcmpes %f0, %f8
400055ec: 01 00 00 00 nop
400055f0: 0d bf ff f4 fbg 400055c0 <rtems_string_to_float+0x6c>
400055f4: 05 10 00 57 sethi %hi(0x40015c00), %g2
400055f8: d1 00 a3 3c ld [ %g2 + 0x33c ], %f8 ! 40015f3c <rtems_filesystem_null_handlers+0x54>
400055fc: 81 a8 0a a8 fcmpes %f0, %f8
40005600: 01 00 00 00 nop
40005604: 09 bf ff ef fbl 400055c0 <rtems_string_to_float+0x6c>
40005608: 01 00 00 00 nop
*n = result;
4000560c: c1 26 40 00 st %f0, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
40005610: 10 bf ff ec b 400055c0 <rtems_string_to_float+0x6c>
<== NOT EXECUTED
40005614: 82 10 20 00 clr %g1
<== NOT EXECUTED
40005618 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
40005618: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
4000561c: 80 a6 60 00 cmp %i1, 0
40005620: 02 80 00 1a be 40005688 <rtems_string_to_int+0x70>
40005624: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
40005628: 40 00 28 d4 call 4000f978 <__errno>
4000562c: 01 00 00 00 nop
40005630: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtol( s, &end, base );
40005634: 94 10 00 1b mov %i3, %o2
*n = 0;
40005638: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4000563c: 92 07 bf fc add %fp, -4, %o1
40005640: 40 00 30 c1 call 40011944 <strtol>
40005644: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
40005648: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
4000564c: 80 a6 a0 00 cmp %i2, 0
40005650: 02 80 00 03 be 4000565c <rtems_string_to_int+0x44>
40005654: ba 10 00 08 mov %o0, %i5
*endptr = end;
40005658: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000565c: 80 a6 00 02 cmp %i0, %g2
40005660: 02 80 00 0a be 40005688 <rtems_string_to_int+0x70>
40005664: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
40005668: 40 00 28 c4 call 4000f978 <__errno>
4000566c: 01 00 00 00 nop
40005670: c2 02 00 00 ld [ %o0 ], %g1
40005674: 80 a0 60 22 cmp %g1, 0x22
40005678: 02 80 00 06 be 40005690 <rtems_string_to_int+0x78>
4000567c: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
40005680: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
40005684: 82 10 20 00 clr %g1
}
40005688: 81 c7 e0 08 ret
4000568c: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
40005690: 82 10 63 ff or %g1, 0x3ff, %g1
40005694: 80 8f 40 01 btst %i5, %g1
40005698: 02 80 00 04 be 400056a8 <rtems_string_to_int+0x90>
4000569c: 80 a7 40 01 cmp %i5, %g1
400056a0: 32 bf ff f9 bne,a 40005684 <rtems_string_to_int+0x6c> <== NEVER TAKEN
400056a4: fa 26 40 00 st %i5, [ %i1 ]
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
400056a8: 10 bf ff f8 b 40005688 <rtems_string_to_int+0x70>
400056ac: 82 10 20 0a mov 0xa, %g1
400056b0 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
400056b0: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
400056b4: 80 a6 60 00 cmp %i1, 0
400056b8: 02 80 00 1a be 40005720 <rtems_string_to_long+0x70>
400056bc: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
400056c0: 40 00 28 ae call 4000f978 <__errno>
400056c4: 01 00 00 00 nop
400056c8: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtol( s, &end, base );
400056cc: 94 10 00 1b mov %i3, %o2
*n = 0;
400056d0: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
400056d4: 92 07 bf fc add %fp, -4, %o1
400056d8: 40 00 30 9b call 40011944 <strtol>
400056dc: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
400056e0: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
400056e4: 80 a6 a0 00 cmp %i2, 0
400056e8: 02 80 00 03 be 400056f4 <rtems_string_to_long+0x44>
400056ec: ba 10 00 08 mov %o0, %i5
*endptr = end;
400056f0: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
400056f4: 80 a6 00 02 cmp %i0, %g2
400056f8: 02 80 00 0a be 40005720 <rtems_string_to_long+0x70>
400056fc: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
40005700: 40 00 28 9e call 4000f978 <__errno>
40005704: 01 00 00 00 nop
40005708: c2 02 00 00 ld [ %o0 ], %g1
4000570c: 80 a0 60 22 cmp %g1, 0x22
40005710: 02 80 00 06 be 40005728 <rtems_string_to_long+0x78>
40005714: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
40005718: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000571c: 82 10 20 00 clr %g1
}
40005720: 81 c7 e0 08 ret
40005724: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
40005728: 82 10 63 ff or %g1, 0x3ff, %g1
4000572c: 80 8f 40 01 btst %i5, %g1
40005730: 02 80 00 04 be 40005740 <rtems_string_to_long+0x90>
40005734: 80 a7 40 01 cmp %i5, %g1
40005738: 32 bf ff f9 bne,a 4000571c <rtems_string_to_long+0x6c> <== NEVER TAKEN
4000573c: fa 26 40 00 st %i5, [ %i1 ]
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
40005740: 10 bf ff f8 b 40005720 <rtems_string_to_long+0x70>
40005744: 82 10 20 0a mov 0xa, %g1
40005748 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
40005748: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
4000574c: 80 a6 60 00 cmp %i1, 0
40005750: 02 80 00 1d be 400057c4 <rtems_string_to_long_long+0x7c>
40005754: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
40005758: 40 00 28 88 call 4000f978 <__errno>
4000575c: 01 00 00 00 nop
40005760: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoll( s, &end, base );
40005764: 94 10 00 1b mov %i3, %o2
*n = 0;
40005768: c0 26 40 00 clr [ %i1 ]
result = strtoll( s, &end, base );
4000576c: 92 07 bf fc add %fp, -4, %o1
*n = 0;
40005770: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
40005774: 40 00 31 24 call 40011c04 <strtoll>
40005778: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
4000577c: c4 07 bf fc ld [ %fp + -4 ], %g2
result = strtoll( s, &end, base );
40005780: b8 10 00 08 mov %o0, %i4
if ( endptr )
40005784: 80 a6 a0 00 cmp %i2, 0
40005788: 02 80 00 03 be 40005794 <rtems_string_to_long_long+0x4c>
4000578c: ba 10 00 09 mov %o1, %i5
*endptr = end;
40005790: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
40005794: 80 a6 00 02 cmp %i0, %g2
40005798: 02 80 00 0b be 400057c4 <rtems_string_to_long_long+0x7c>
4000579c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
400057a0: 40 00 28 76 call 4000f978 <__errno>
400057a4: 01 00 00 00 nop
400057a8: c2 02 00 00 ld [ %o0 ], %g1
400057ac: 80 a0 60 22 cmp %g1, 0x22
400057b0: 02 80 00 07 be 400057cc <rtems_string_to_long_long+0x84>
400057b4: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
400057b8: f8 26 40 00 st %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
400057bc: 82 10 20 00 clr %g1
*n = result;
400057c0: fa 26 60 04 st %i5, [ %i1 + 4 ]
}
400057c4: 81 c7 e0 08 ret
400057c8: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
400057cc: 82 10 63 ff or %g1, 0x3ff, %g1
400057d0: 84 0f 00 01 and %i4, %g1, %g2
400057d4: 80 90 80 1d orcc %g2, %i5, %g0
400057d8: 22 bf ff fb be,a 400057c4 <rtems_string_to_long_long+0x7c>
400057dc: 82 10 20 0a mov 0xa, %g1
400057e0: 82 1f 00 01 xor %i4, %g1, %g1
400057e4: 80 b0 40 1d orncc %g1, %i5, %g0
400057e8: 32 bf ff f5 bne,a 400057bc <rtems_string_to_long_long+0x74> <== NEVER TAKEN
400057ec: f8 26 40 00 st %i4, [ %i1 ]
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
400057f0: 10 bf ff f5 b 400057c4 <rtems_string_to_long_long+0x7c>
400057f4: 82 10 20 0a mov 0xa, %g1
40005808 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
40005808: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
4000580c: 80 a6 60 00 cmp %i1, 0
40005810: 02 80 00 1d be 40005884 <rtems_string_to_unsigned_char+0x7c>
40005814: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
40005818: 40 00 28 58 call 4000f978 <__errno>
4000581c: 01 00 00 00 nop
40005820: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoul( s, &end, base );
40005824: 94 10 00 1b mov %i3, %o2
*n = 0;
40005828: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
4000582c: 92 07 bf fc add %fp, -4, %o1
40005830: 40 00 31 81 call 40011e34 <strtoul>
40005834: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
40005838: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
4000583c: 80 a6 a0 00 cmp %i2, 0
40005840: 02 80 00 03 be 4000584c <rtems_string_to_unsigned_char+0x44>
40005844: ba 10 00 08 mov %o0, %i5
*endptr = end;
40005848: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000584c: 80 a6 00 02 cmp %i0, %g2
40005850: 02 80 00 0d be 40005884 <rtems_string_to_unsigned_char+0x7c>
40005854: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
40005858: 40 00 28 48 call 4000f978 <__errno>
4000585c: 01 00 00 00 nop
40005860: c2 02 00 00 ld [ %o0 ], %g1
40005864: 80 a0 60 22 cmp %g1, 0x22
40005868: 02 80 00 09 be 4000588c <rtems_string_to_unsigned_char+0x84>
4000586c: 84 07 7f ff add %i5, -1, %g2
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
40005870: 80 a7 60 ff cmp %i5, 0xff
40005874: 18 80 00 0a bgu 4000589c <rtems_string_to_unsigned_char+0x94>
40005878: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000587c: fa 2e 40 00 stb %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
40005880: 82 10 20 00 clr %g1
}
40005884: 81 c7 e0 08 ret
40005888: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
4000588c: 80 a0 bf fd cmp %g2, -3
40005890: 08 bf ff f8 bleu 40005870 <rtems_string_to_unsigned_char+0x68> <== NEVER TAKEN
40005894: 82 10 20 0a mov 0xa, %g1
40005898: 30 bf ff fb b,a 40005884 <rtems_string_to_unsigned_char+0x7c>
errno = ERANGE;
4000589c: 40 00 28 37 call 4000f978 <__errno>
400058a0: 01 00 00 00 nop
400058a4: 84 10 20 22 mov 0x22, %g2 ! 22 <_TLS_Alignment+0x21>
return RTEMS_INVALID_NUMBER;
400058a8: 82 10 20 0a mov 0xa, %g1
400058ac: 10 bf ff f6 b 40005884 <rtems_string_to_unsigned_char+0x7c>
400058b0: c4 22 00 00 st %g2, [ %o0 ]
400058b4 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
400058b4: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
400058b8: 80 a6 60 00 cmp %i1, 0
400058bc: 02 80 00 1a be 40005924 <rtems_string_to_unsigned_int+0x70>
400058c0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
400058c4: 40 00 28 2d call 4000f978 <__errno>
400058c8: 01 00 00 00 nop
400058cc: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoul( s, &end, base );
400058d0: 94 10 00 1b mov %i3, %o2
*n = 0;
400058d4: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
400058d8: 92 07 bf fc add %fp, -4, %o1
400058dc: 40 00 31 56 call 40011e34 <strtoul>
400058e0: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
400058e4: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
400058e8: 80 a6 a0 00 cmp %i2, 0
400058ec: 02 80 00 03 be 400058f8 <rtems_string_to_unsigned_int+0x44>
400058f0: ba 10 00 08 mov %o0, %i5
*endptr = end;
400058f4: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
400058f8: 80 a6 00 02 cmp %i0, %g2
400058fc: 02 80 00 0a be 40005924 <rtems_string_to_unsigned_int+0x70>
40005900: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
40005904: 40 00 28 1d call 4000f978 <__errno>
40005908: 01 00 00 00 nop
4000590c: c2 02 00 00 ld [ %o0 ], %g1
40005910: 80 a0 60 22 cmp %g1, 0x22
40005914: 02 80 00 06 be 4000592c <rtems_string_to_unsigned_int+0x78>
40005918: 84 07 7f ff add %i5, -1, %g2
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000591c: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
40005920: 82 10 20 00 clr %g1
}
40005924: 81 c7 e0 08 ret
40005928: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
4000592c: 80 a0 bf fd cmp %g2, -3
40005930: 18 bf ff fd bgu 40005924 <rtems_string_to_unsigned_int+0x70> <== ALWAYS TAKEN
40005934: 82 10 20 0a mov 0xa, %g1
*n = result;
40005938: fa 26 40 00 st %i5, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000593c: 10 bf ff fa b 40005924 <rtems_string_to_unsigned_int+0x70>
<== NOT EXECUTED
40005940: 82 10 20 00 clr %g1
<== NOT EXECUTED
40005944 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
40005944: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
40005948: 80 a6 60 00 cmp %i1, 0
4000594c: 02 80 00 1a be 400059b4 <rtems_string_to_unsigned_long+0x70>
40005950: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
40005954: 40 00 28 09 call 4000f978 <__errno>
40005958: 01 00 00 00 nop
4000595c: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoul( s, &end, base );
40005960: 94 10 00 1b mov %i3, %o2
*n = 0;
40005964: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
40005968: 92 07 bf fc add %fp, -4, %o1
4000596c: 40 00 31 32 call 40011e34 <strtoul>
40005970: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
40005974: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
40005978: 80 a6 a0 00 cmp %i2, 0
4000597c: 02 80 00 03 be 40005988 <rtems_string_to_unsigned_long+0x44>
40005980: ba 10 00 08 mov %o0, %i5
*endptr = end;
40005984: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
40005988: 80 a6 00 02 cmp %i0, %g2
4000598c: 02 80 00 0a be 400059b4 <rtems_string_to_unsigned_long+0x70>
40005990: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
40005994: 40 00 27 f9 call 4000f978 <__errno>
40005998: 01 00 00 00 nop
4000599c: c2 02 00 00 ld [ %o0 ], %g1
400059a0: 80 a0 60 22 cmp %g1, 0x22
400059a4: 02 80 00 06 be 400059bc <rtems_string_to_unsigned_long+0x78>
400059a8: 84 07 7f ff add %i5, -1, %g2
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
400059ac: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
400059b0: 82 10 20 00 clr %g1
}
400059b4: 81 c7 e0 08 ret
400059b8: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
400059bc: 80 a0 bf fd cmp %g2, -3
400059c0: 18 bf ff fd bgu 400059b4 <rtems_string_to_unsigned_long+0x70> <== ALWAYS TAKEN
400059c4: 82 10 20 0a mov 0xa, %g1
*n = result;
400059c8: fa 26 40 00 st %i5, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
400059cc: 10 bf ff fa b 400059b4 <rtems_string_to_unsigned_long+0x70>
<== NOT EXECUTED
400059d0: 82 10 20 00 clr %g1
<== NOT EXECUTED
400059d4 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
400059d4: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
400059d8: 80 a6 60 00 cmp %i1, 0
400059dc: 02 80 00 1c be 40005a4c <rtems_string_to_unsigned_long_long+0x78>
400059e0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
400059e4: 40 00 27 e5 call 4000f978 <__errno>
400059e8: 01 00 00 00 nop
400059ec: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoull( s, &end, base );
400059f0: 94 10 00 1b mov %i3, %o2
*n = 0;
400059f4: c0 26 40 00 clr [ %i1 ]
result = strtoull( s, &end, base );
400059f8: 92 07 bf fc add %fp, -4, %o1
*n = 0;
400059fc: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
40005a00: 40 00 31 be call 400120f8 <strtoull>
40005a04: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
40005a08: c4 07 bf fc ld [ %fp + -4 ], %g2
result = strtoull( s, &end, base );
40005a0c: b8 10 00 08 mov %o0, %i4
if ( endptr )
40005a10: 80 a6 a0 00 cmp %i2, 0
40005a14: 02 80 00 03 be 40005a20 <rtems_string_to_unsigned_long_long+0x4c>
40005a18: ba 10 00 09 mov %o1, %i5
*endptr = end;
40005a1c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
40005a20: 80 a6 00 02 cmp %i0, %g2
40005a24: 02 80 00 0a be 40005a4c <rtems_string_to_unsigned_long_long+0x78>
40005a28: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
40005a2c: 40 00 27 d3 call 4000f978 <__errno>
40005a30: 01 00 00 00 nop
40005a34: c2 02 00 00 ld [ %o0 ], %g1
40005a38: 80 a0 60 22 cmp %g1, 0x22
40005a3c: 02 80 00 06 be 40005a54 <rtems_string_to_unsigned_long_long+0x80>
40005a40: 86 87 7f ff addcc %i5, -1, %g3
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
40005a44: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
40005a48: 82 10 20 00 clr %g1
}
40005a4c: 81 c7 e0 08 ret
40005a50: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
40005a54: 84 47 3f ff addx %i4, -1, %g2
if ( ( errno == ERANGE ) &&
40005a58: 80 a0 bf ff cmp %g2, -1
40005a5c: 32 bf ff fb bne,a 40005a48 <rtems_string_to_unsigned_long_long+0x74> <== NEVER TAKEN
40005a60: f8 3e 40 00 std %i4, [ %i1 ]
<== NOT EXECUTED
40005a64: 80 a0 ff fd cmp %g3, -3
40005a68: 18 bf ff f9 bgu 40005a4c <rtems_string_to_unsigned_long_long+0x78> <== ALWAYS TAKEN
40005a6c: 82 10 20 0a mov 0xa, %g1
*n = result;
40005a70: f8 3e 40 00 std %i4, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
40005a74: 10 bf ff f6 b 40005a4c <rtems_string_to_unsigned_long_long+0x78>
<== NOT EXECUTED
40005a78: 82 10 20 00 clr %g1
<== NOT EXECUTED