4000c804 <rtems_string_to_double>: rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) {
4000c804: 9d e3 bf 90 save %sp, -112, %sp
double result;
char *end;
if ( !n )
4000c808: 80 a6 60 00 cmp %i1, 0
4000c80c: 02 80 00 1a be 4000c874 <rtems_string_to_double+0x70>
4000c810: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000c814: 40 00 0b 22 call 4000f49c <__errno>
4000c818: 01 00 00 00 nop
4000c81c: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtod( s, &end );
4000c820: 92 07 bf fc add %fp, -4, %o1
*n = 0;
4000c824: c0 26 40 00 clr [ %i1 ]
result = strtod( s, &end );
4000c828: 90 10 00 18 mov %i0, %o0
4000c82c: 40 00 12 33 call 400110f8 <strtod>
4000c830: c0 26 60 04 clr [ %i1 + 4 ]
if ( endptr )
4000c834: 80 a6 a0 00 cmp %i2, 0
4000c838: 02 80 00 03 be 4000c844 <rtems_string_to_double+0x40>
4000c83c: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000c840: c4 26 80 00 st %g2, [ %i2 ]
4000c844: c1 3f bf f0 std %f0, [ %fp + -16 ]
if ( end == s )
4000c848: 80 a6 00 02 cmp %i0, %g2
4000c84c: 02 80 00 0a be 4000c874 <rtems_string_to_double+0x70>
4000c850: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000c854: 40 00 0b 12 call 4000f49c <__errno>
4000c858: 01 00 00 00 nop
4000c85c: c2 02 00 00 ld [ %o0 ], %g1
4000c860: 80 a0 60 22 cmp %g1, 0x22
4000c864: 02 80 00 06 be 4000c87c <rtems_string_to_double+0x78>
4000c868: c1 1f bf f0 ldd [ %fp + -16 ], %f0
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000c86c: c1 3e 40 00 std %f0, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000c870: 82 10 20 00 clr %g1
}
4000c874: 81 c7 e0 08 ret
4000c878: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
4000c87c: 03 10 00 58 sethi %hi(0x40016000), %g1
4000c880: d1 18 62 70 ldd [ %g1 + 0x270 ], %f8 ! 40016270 <_rodata_start+0x17c0>
4000c884: 81 a8 0a 48 fcmpd %f0, %f8
4000c888: 01 00 00 00 nop
4000c88c: 13 bf ff fa fbe 4000c874 <rtems_string_to_double+0x70>
4000c890: 82 10 20 0a mov 0xa, %g1 ! a <_TLS_Alignment+0x9>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4000c894: 05 10 00 5a sethi %hi(0x40016800), %g2
4000c898: d1 18 a3 a8 ldd [ %g2 + 0x3a8 ], %f8 ! 40016ba8 <_Thread_queue_Operations_default+0x18>
4000c89c: 81 a8 0a c8 fcmped %f0, %f8
4000c8a0: 01 00 00 00 nop
4000c8a4: 0d bf ff f4 fbg 4000c874 <rtems_string_to_double+0x70>
4000c8a8: 05 10 00 5a sethi %hi(0x40016800), %g2
4000c8ac: d1 18 a3 b0 ldd [ %g2 + 0x3b0 ], %f8 ! 40016bb0 <_Thread_queue_Operations_default+0x20>
4000c8b0: 81 a8 0a c8 fcmped %f0, %f8
4000c8b4: 01 00 00 00 nop
4000c8b8: 09 bf ff ef fbl 4000c874 <rtems_string_to_double+0x70>
4000c8bc: 01 00 00 00 nop
*n = result;
4000c8c0: c1 3e 40 00 std %f0, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000c8c4: 10 bf ff ec b 4000c874 <rtems_string_to_double+0x70>
<== NOT EXECUTED
4000c8c8: 82 10 20 00 clr %g1
<== NOT EXECUTED
4000c8cc <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
4000c8cc: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
float result;
char *end;
if ( !n )
4000c8d0: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000c8d4: 02 80 00 19 be 4000c938 <rtems_string_to_float+0x6c>
<== NOT EXECUTED
4000c8d8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000c8dc: 40 00 0a f0 call 4000f49c <__errno>
4000c8e0: 01 00 00 00 nop
4000c8e4: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtof( s, &end );
4000c8e8: 92 07 bf fc add %fp, -4, %o1
*n = 0;
4000c8ec: c0 26 40 00 clr [ %i1 ]
result = strtof( s, &end );
4000c8f0: 40 00 12 34 call 400111c0 <strtof>
4000c8f4: 90 10 00 18 mov %i0, %o0
if ( endptr )
4000c8f8: 80 a6 a0 00 cmp %i2, 0
4000c8fc: 02 80 00 03 be 4000c908 <rtems_string_to_float+0x3c>
4000c900: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
4000c904: c4 26 80 00 st %g2, [ %i2 ]
4000c908: c1 27 bf f4 st %f0, [ %fp + -12 ]
if ( end == s )
4000c90c: 80 a6 00 02 cmp %i0, %g2
4000c910: 02 80 00 0a be 4000c938 <rtems_string_to_float+0x6c>
4000c914: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000c918: 40 00 0a e1 call 4000f49c <__errno>
4000c91c: 01 00 00 00 nop
4000c920: c2 02 00 00 ld [ %o0 ], %g1
4000c924: 80 a0 60 22 cmp %g1, 0x22
4000c928: 02 80 00 06 be 4000c940 <rtems_string_to_float+0x74>
4000c92c: c1 07 bf f4 ld [ %fp + -12 ], %f0
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000c930: c1 26 40 00 st %f0, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000c934: 82 10 20 00 clr %g1
}
4000c938: 81 c7 e0 08 ret
4000c93c: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
4000c940: 03 10 00 58 sethi %hi(0x40016000), %g1
4000c944: d1 00 60 50 ld [ %g1 + 0x50 ], %f8 ! 40016050 <_rodata_start+0x15a0>
4000c948: 81 a8 0a 28 fcmps %f0, %f8
4000c94c: 01 00 00 00 nop
4000c950: 13 bf ff fa fbe 4000c938 <rtems_string_to_float+0x6c>
4000c954: 82 10 20 0a mov 0xa, %g1 ! a <_TLS_Alignment+0x9>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4000c958: 05 10 00 5a sethi %hi(0x40016800), %g2
4000c95c: d1 00 a3 b8 ld [ %g2 + 0x3b8 ], %f8 ! 40016bb8 <_Thread_queue_Operations_default+0x28>
4000c960: 81 a8 0a a8 fcmpes %f0, %f8
4000c964: 01 00 00 00 nop
4000c968: 0d bf ff f4 fbg 4000c938 <rtems_string_to_float+0x6c>
4000c96c: 05 10 00 5a sethi %hi(0x40016800), %g2
4000c970: d1 00 a3 bc ld [ %g2 + 0x3bc ], %f8 ! 40016bbc <_Thread_queue_Operations_default+0x2c>
4000c974: 81 a8 0a a8 fcmpes %f0, %f8
4000c978: 01 00 00 00 nop
4000c97c: 09 bf ff ef fbl 4000c938 <rtems_string_to_float+0x6c>
4000c980: 01 00 00 00 nop
*n = result;
4000c984: c1 26 40 00 st %f0, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000c988: 10 bf ff ec b 4000c938 <rtems_string_to_float+0x6c>
<== NOT EXECUTED
4000c98c: 82 10 20 00 clr %g1
<== NOT EXECUTED
4000c990 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
4000c990: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
long result;
char *end;
if ( !n )
4000c994: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000c998: 02 80 00 1a be 4000ca00 <rtems_string_to_int+0x70>
<== NOT EXECUTED
4000c99c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000c9a0: 40 00 0a bf call 4000f49c <__errno>
4000c9a4: 01 00 00 00 nop
4000c9a8: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtol( s, &end, base );
4000c9ac: 94 10 00 1b mov %i3, %o2
*n = 0;
4000c9b0: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4000c9b4: 92 07 bf fc add %fp, -4, %o1
4000c9b8: 40 00 12 de call 40011530 <strtol>
4000c9bc: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
4000c9c0: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
4000c9c4: 80 a6 a0 00 cmp %i2, 0
4000c9c8: 02 80 00 03 be 4000c9d4 <rtems_string_to_int+0x44>
4000c9cc: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000c9d0: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000c9d4: 80 a6 00 02 cmp %i0, %g2
4000c9d8: 02 80 00 0a be 4000ca00 <rtems_string_to_int+0x70>
4000c9dc: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000c9e0: 40 00 0a af call 4000f49c <__errno>
4000c9e4: 01 00 00 00 nop
4000c9e8: c2 02 00 00 ld [ %o0 ], %g1
4000c9ec: 80 a0 60 22 cmp %g1, 0x22
4000c9f0: 02 80 00 06 be 4000ca08 <rtems_string_to_int+0x78>
4000c9f4: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000c9f8: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000c9fc: 82 10 20 00 clr %g1
}
4000ca00: 81 c7 e0 08 ret
4000ca04: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000ca08: 82 10 63 ff or %g1, 0x3ff, %g1
4000ca0c: 80 8f 40 01 btst %i5, %g1
4000ca10: 02 80 00 04 be 4000ca20 <rtems_string_to_int+0x90>
4000ca14: 80 a7 40 01 cmp %i5, %g1
4000ca18: 32 bf ff f9 bne,a 4000c9fc <rtems_string_to_int+0x6c> <== NEVER TAKEN
4000ca1c: fa 26 40 00 st %i5, [ %i1 ]
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
4000ca20: 10 bf ff f8 b 4000ca00 <rtems_string_to_int+0x70>
4000ca24: 82 10 20 0a mov 0xa, %g1
4000cad8 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
4000cad8: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
long result;
char *end;
if ( !n )
4000cadc: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000cae0: 02 80 00 1a be 4000cb48 <rtems_string_to_long+0x70>
<== NOT EXECUTED
4000cae4: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000cae8: 40 00 0a 6d call 4000f49c <__errno>
4000caec: 01 00 00 00 nop
4000caf0: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtol( s, &end, base );
4000caf4: 94 10 00 1b mov %i3, %o2
*n = 0;
4000caf8: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
4000cafc: 92 07 bf fc add %fp, -4, %o1
4000cb00: 40 00 12 8c call 40011530 <strtol>
4000cb04: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
4000cb08: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
4000cb0c: 80 a6 a0 00 cmp %i2, 0
4000cb10: 02 80 00 03 be 4000cb1c <rtems_string_to_long+0x44>
4000cb14: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000cb18: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000cb1c: 80 a6 00 02 cmp %i0, %g2
4000cb20: 02 80 00 0a be 4000cb48 <rtems_string_to_long+0x70>
4000cb24: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000cb28: 40 00 0a 5d call 4000f49c <__errno>
4000cb2c: 01 00 00 00 nop
4000cb30: c2 02 00 00 ld [ %o0 ], %g1
4000cb34: 80 a0 60 22 cmp %g1, 0x22
4000cb38: 02 80 00 06 be 4000cb50 <rtems_string_to_long+0x78>
4000cb3c: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000cb40: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000cb44: 82 10 20 00 clr %g1
}
4000cb48: 81 c7 e0 08 ret
4000cb4c: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000cb50: 82 10 63 ff or %g1, 0x3ff, %g1
4000cb54: 80 8f 40 01 btst %i5, %g1
4000cb58: 02 80 00 04 be 4000cb68 <rtems_string_to_long+0x90>
4000cb5c: 80 a7 40 01 cmp %i5, %g1
4000cb60: 32 bf ff f9 bne,a 4000cb44 <rtems_string_to_long+0x6c> <== NEVER TAKEN
4000cb64: fa 26 40 00 st %i5, [ %i1 ]
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
4000cb68: 10 bf ff f8 b 4000cb48 <rtems_string_to_long+0x70>
4000cb6c: 82 10 20 0a mov 0xa, %g1
4000ca28 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
4000ca28: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
long long result;
char *end;
if ( !n )
4000ca2c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000ca30: 02 80 00 1d be 4000caa4 <rtems_string_to_long_long+0x7c>
<== NOT EXECUTED
4000ca34: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000ca38: 40 00 0a 99 call 4000f49c <__errno>
4000ca3c: 01 00 00 00 nop
4000ca40: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoll( s, &end, base );
4000ca44: 94 10 00 1b mov %i3, %o2
*n = 0;
4000ca48: c0 26 40 00 clr [ %i1 ]
result = strtoll( s, &end, base );
4000ca4c: 92 07 bf fc add %fp, -4, %o1
*n = 0;
4000ca50: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
4000ca54: 40 00 13 83 call 40011860 <strtoll>
4000ca58: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
4000ca5c: c4 07 bf fc ld [ %fp + -4 ], %g2
result = strtoll( s, &end, base );
4000ca60: b8 10 00 08 mov %o0, %i4
if ( endptr )
4000ca64: 80 a6 a0 00 cmp %i2, 0
4000ca68: 02 80 00 03 be 4000ca74 <rtems_string_to_long_long+0x4c>
4000ca6c: ba 10 00 09 mov %o1, %i5
*endptr = end;
4000ca70: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000ca74: 80 a6 00 02 cmp %i0, %g2
4000ca78: 02 80 00 0b be 4000caa4 <rtems_string_to_long_long+0x7c>
4000ca7c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000ca80: 40 00 0a 87 call 4000f49c <__errno>
4000ca84: 01 00 00 00 nop
4000ca88: c2 02 00 00 ld [ %o0 ], %g1
4000ca8c: 80 a0 60 22 cmp %g1, 0x22
4000ca90: 02 80 00 07 be 4000caac <rtems_string_to_long_long+0x84>
4000ca94: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000ca98: f8 26 40 00 st %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000ca9c: 82 10 20 00 clr %g1
*n = result;
4000caa0: fa 26 60 04 st %i5, [ %i1 + 4 ]
}
4000caa4: 81 c7 e0 08 ret
4000caa8: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000caac: 82 10 63 ff or %g1, 0x3ff, %g1
4000cab0: 84 0f 00 01 and %i4, %g1, %g2
4000cab4: 80 90 80 1d orcc %g2, %i5, %g0
4000cab8: 22 bf ff fb be,a 4000caa4 <rtems_string_to_long_long+0x7c>
4000cabc: 82 10 20 0a mov 0xa, %g1
4000cac0: 82 1f 00 01 xor %i4, %g1, %g1
4000cac4: 80 b0 40 1d orncc %g1, %i5, %g0
4000cac8: 32 bf ff f5 bne,a 4000ca9c <rtems_string_to_long_long+0x74> <== NEVER TAKEN
4000cacc: f8 26 40 00 st %i4, [ %i1 ]
<== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
4000cad0: 10 bf ff f5 b 4000caa4 <rtems_string_to_long_long+0x7c>
4000cad4: 82 10 20 0a mov 0xa, %g1
4000cb70 <rtems_string_to_pointer>:
const char *s,
void **n,
char **endptr
)
{
return STRTOFUNC( s, n, endptr );
4000cb70: 96 10 20 00 clr %o3
<== NOT EXECUTED
4000cb74: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000cb78: 40 00 00 7b call 4000cd64 <rtems_string_to_unsigned_long>
<== NOT EXECUTED
4000cb7c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000cb80 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
4000cb80: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
unsigned long result;
char *end;
if ( !n )
4000cb84: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000cb88: 02 80 00 1d be 4000cbfc <rtems_string_to_unsigned_char+0x7c>
<== NOT EXECUTED
4000cb8c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000cb90: 40 00 0a 43 call 4000f49c <__errno>
4000cb94: 01 00 00 00 nop
4000cb98: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoul( s, &end, base );
4000cb9c: 94 10 00 1b mov %i3, %o2
*n = 0;
4000cba0: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
4000cba4: 92 07 bf fc add %fp, -4, %o1
4000cba8: 40 00 13 d6 call 40011b00 <strtoul>
4000cbac: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
4000cbb0: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
4000cbb4: 80 a6 a0 00 cmp %i2, 0
4000cbb8: 02 80 00 03 be 4000cbc4 <rtems_string_to_unsigned_char+0x44>
4000cbbc: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000cbc0: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000cbc4: 80 a6 00 02 cmp %i0, %g2
4000cbc8: 02 80 00 0d be 4000cbfc <rtems_string_to_unsigned_char+0x7c>
4000cbcc: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000cbd0: 40 00 0a 33 call 4000f49c <__errno>
4000cbd4: 01 00 00 00 nop
4000cbd8: c2 02 00 00 ld [ %o0 ], %g1
4000cbdc: 80 a0 60 22 cmp %g1, 0x22
4000cbe0: 02 80 00 09 be 4000cc04 <rtems_string_to_unsigned_char+0x84>
4000cbe4: 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 ) {
4000cbe8: 80 a7 60 ff cmp %i5, 0xff
4000cbec: 18 80 00 0a bgu 4000cc14 <rtems_string_to_unsigned_char+0x94>
4000cbf0: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000cbf4: fa 2e 40 00 stb %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000cbf8: 82 10 20 00 clr %g1
}
4000cbfc: 81 c7 e0 08 ret
4000cc00: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
4000cc04: 80 a0 bf fd cmp %g2, -3
4000cc08: 08 bf ff f8 bleu 4000cbe8 <rtems_string_to_unsigned_char+0x68> <== NEVER TAKEN
4000cc0c: 82 10 20 0a mov 0xa, %g1
4000cc10: 30 bf ff fb b,a 4000cbfc <rtems_string_to_unsigned_char+0x7c>
errno = ERANGE;
4000cc14: 40 00 0a 22 call 4000f49c <__errno>
4000cc18: 01 00 00 00 nop
4000cc1c: 84 10 20 22 mov 0x22, %g2 ! 22 <_TLS_Alignment+0x21>
return RTEMS_INVALID_NUMBER;
4000cc20: 82 10 20 0a mov 0xa, %g1
4000cc24: 10 bf ff f6 b 4000cbfc <rtems_string_to_unsigned_char+0x7c>
4000cc28: c4 22 00 00 st %g2, [ %o0 ]
4000cc2c <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
4000cc2c: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
unsigned long result;
char *end;
if ( !n )
4000cc30: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000cc34: 02 80 00 1a be 4000cc9c <rtems_string_to_unsigned_int+0x70>
<== NOT EXECUTED
4000cc38: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000cc3c: 40 00 0a 18 call 4000f49c <__errno>
4000cc40: 01 00 00 00 nop
4000cc44: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoul( s, &end, base );
4000cc48: 94 10 00 1b mov %i3, %o2
*n = 0;
4000cc4c: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000cc50: 92 07 bf fc add %fp, -4, %o1
4000cc54: 40 00 13 ab call 40011b00 <strtoul>
4000cc58: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
4000cc5c: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
4000cc60: 80 a6 a0 00 cmp %i2, 0
4000cc64: 02 80 00 03 be 4000cc70 <rtems_string_to_unsigned_int+0x44>
4000cc68: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000cc6c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000cc70: 80 a6 00 02 cmp %i0, %g2
4000cc74: 02 80 00 0a be 4000cc9c <rtems_string_to_unsigned_int+0x70>
4000cc78: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000cc7c: 40 00 0a 08 call 4000f49c <__errno>
4000cc80: 01 00 00 00 nop
4000cc84: c2 02 00 00 ld [ %o0 ], %g1
4000cc88: 80 a0 60 22 cmp %g1, 0x22
4000cc8c: 02 80 00 06 be 4000cca4 <rtems_string_to_unsigned_int+0x78>
4000cc90: 84 07 7f ff add %i5, -1, %g2
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
4000cc94: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000cc98: 82 10 20 00 clr %g1
}
4000cc9c: 81 c7 e0 08 ret
4000cca0: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
4000cca4: 80 a0 bf fd cmp %g2, -3
4000cca8: 18 bf ff fd bgu 4000cc9c <rtems_string_to_unsigned_int+0x70> <== ALWAYS TAKEN
4000ccac: 82 10 20 0a mov 0xa, %g1
*n = result;
4000ccb0: fa 26 40 00 st %i5, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000ccb4: 10 bf ff fa b 4000cc9c <rtems_string_to_unsigned_int+0x70>
<== NOT EXECUTED
4000ccb8: 82 10 20 00 clr %g1
<== NOT EXECUTED
4000cd64 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
4000cd64: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
unsigned long result;
char *end;
if ( !n )
4000cd68: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000cd6c: 02 80 00 1a be 4000cdd4 <rtems_string_to_unsigned_long+0x70>
<== NOT EXECUTED
4000cd70: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000cd74: 40 00 09 ca call 4000f49c <__errno>
4000cd78: 01 00 00 00 nop
4000cd7c: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoul( s, &end, base );
4000cd80: 94 10 00 1b mov %i3, %o2
*n = 0;
4000cd84: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
4000cd88: 92 07 bf fc add %fp, -4, %o1
4000cd8c: 40 00 13 5d call 40011b00 <strtoul>
4000cd90: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
4000cd94: c4 07 bf fc ld [ %fp + -4 ], %g2
if ( endptr )
4000cd98: 80 a6 a0 00 cmp %i2, 0
4000cd9c: 02 80 00 03 be 4000cda8 <rtems_string_to_unsigned_long+0x44>
4000cda0: ba 10 00 08 mov %o0, %i5
*endptr = end;
4000cda4: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000cda8: 80 a6 00 02 cmp %i0, %g2
4000cdac: 02 80 00 0a be 4000cdd4 <rtems_string_to_unsigned_long+0x70>
4000cdb0: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000cdb4: 40 00 09 ba call 4000f49c <__errno>
4000cdb8: 01 00 00 00 nop
4000cdbc: c2 02 00 00 ld [ %o0 ], %g1
4000cdc0: 80 a0 60 22 cmp %g1, 0x22
4000cdc4: 02 80 00 06 be 4000cddc <rtems_string_to_unsigned_long+0x78>
4000cdc8: 84 07 7f ff add %i5, -1, %g2
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000cdcc: fa 26 40 00 st %i5, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000cdd0: 82 10 20 00 clr %g1
}
4000cdd4: 81 c7 e0 08 ret
4000cdd8: 91 e8 00 01 restore %g0, %g1, %o0
if ( ( errno == ERANGE ) &&
4000cddc: 80 a0 bf fd cmp %g2, -3
4000cde0: 18 bf ff fd bgu 4000cdd4 <rtems_string_to_unsigned_long+0x70> <== ALWAYS TAKEN
4000cde4: 82 10 20 0a mov 0xa, %g1
*n = result;
4000cde8: fa 26 40 00 st %i5, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000cdec: 10 bf ff fa b 4000cdd4 <rtems_string_to_unsigned_long+0x70>
<== NOT EXECUTED
4000cdf0: 82 10 20 00 clr %g1
<== NOT EXECUTED
...
4000ccbc <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
4000ccbc: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
unsigned long long result;
char *end;
if ( !n )
4000ccc0: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000ccc4: 02 80 00 1c be 4000cd34 <rtems_string_to_unsigned_long_long+0x78>
<== NOT EXECUTED
4000ccc8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
4000cccc: 40 00 09 f4 call 4000f49c <__errno>
4000ccd0: 01 00 00 00 nop
4000ccd4: c0 22 00 00 clr [ %o0 ]
*n = 0;
result = strtoull( s, &end, base );
4000ccd8: 94 10 00 1b mov %i3, %o2
*n = 0;
4000ccdc: c0 26 40 00 clr [ %i1 ]
result = strtoull( s, &end, base );
4000cce0: 92 07 bf fc add %fp, -4, %o1
*n = 0;
4000cce4: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
4000cce8: 40 00 14 53 call 40011e34 <strtoull>
4000ccec: 90 10 00 18 mov %i0, %o0
if ( endptr )
*endptr = end;
4000ccf0: c4 07 bf fc ld [ %fp + -4 ], %g2
result = strtoull( s, &end, base );
4000ccf4: b8 10 00 08 mov %o0, %i4
if ( endptr )
4000ccf8: 80 a6 a0 00 cmp %i2, 0
4000ccfc: 02 80 00 03 be 4000cd08 <rtems_string_to_unsigned_long_long+0x4c>
4000cd00: ba 10 00 09 mov %o1, %i5
*endptr = end;
4000cd04: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
4000cd08: 80 a6 00 02 cmp %i0, %g2
4000cd0c: 02 80 00 0a be 4000cd34 <rtems_string_to_unsigned_long_long+0x78>
4000cd10: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
4000cd14: 40 00 09 e2 call 4000f49c <__errno>
4000cd18: 01 00 00 00 nop
4000cd1c: c2 02 00 00 ld [ %o0 ], %g1
4000cd20: 80 a0 60 22 cmp %g1, 0x22
4000cd24: 02 80 00 06 be 4000cd3c <rtems_string_to_unsigned_long_long+0x80>
4000cd28: 86 87 7f ff addcc %i5, -1, %g3
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
4000cd2c: f8 3e 40 00 std %i4, [ %i1 ]
return RTEMS_SUCCESSFUL;
4000cd30: 82 10 20 00 clr %g1
}
4000cd34: 81 c7 e0 08 ret
4000cd38: 91 e8 00 01 restore %g0, %g1, %o0
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
4000cd3c: 84 47 3f ff addx %i4, -1, %g2
if ( ( errno == ERANGE ) &&
4000cd40: 80 a0 bf ff cmp %g2, -1
4000cd44: 32 bf ff fb bne,a 4000cd30 <rtems_string_to_unsigned_long_long+0x74> <== NEVER TAKEN
4000cd48: f8 3e 40 00 std %i4, [ %i1 ]
<== NOT EXECUTED
4000cd4c: 80 a0 ff fd cmp %g3, -3
4000cd50: 18 bf ff f9 bgu 4000cd34 <rtems_string_to_unsigned_long_long+0x78> <== ALWAYS TAKEN
4000cd54: 82 10 20 0a mov 0xa, %g1
*n = result;
4000cd58: f8 3e 40 00 std %i4, [ %i1 ]
<== NOT EXECUTED
return RTEMS_SUCCESSFUL;
4000cd5c: 10 bf ff f6 b 4000cd34 <rtems_string_to_unsigned_long_long+0x78>
<== NOT EXECUTED
4000cd60: 82 10 20 00 clr %g1
<== NOT EXECUTED