22 __asm__
volatile(
"fnclex");
42 uint16_t saved_control, truncating_control;
49 "movw %[saved], %%ax\n\t"
50 "orw $0x0c00, %%ax\n\t"
51 "movw %%ax, %[truncating]\n\t"
52 "fldcw %[truncating]\n\t"
53 "fistpq %[result]\n\t"
55 : [result]
"=m"(result), [saved]
"=m"(saved_control),
56 [truncating]
"=m"(truncating_control)
73 static const double divisor = 3145727.0;
74 static const double dividend = 4195835.0;
75 static const double threshold = 1.0;
76 double test_divisor, test_dividend, residual;
77 uint16_t comparison_status;
82 "fstpl %[test_divisor]\n\t"
83 "fldl %[dividend]\n\t"
84 "fstpl %[test_dividend]\n\t"
85 "fldl %[test_dividend]\n\t"
86 "fdivl %[test_divisor]\n\t"
87 "fmull %[test_divisor]\n\t"
88 "fsubrl %[test_dividend]\n\t"
89 "fstpl %[residual]\n\t"
90 "fldl %[residual]\n\t"
91 "fcompl %[threshold]\n\t"
93 :
"=a"(comparison_status), [test_divisor]
"=m"(test_divisor),
94 [test_dividend]
"=m"(test_dividend), [residual]
"=m"(residual)
95 : [divisor]
"m"(divisor), [dividend]
"m"(dividend),
96 [threshold]
"m"(threshold)
111 BOOL(WINAPI * is_processor_feature_present)(DWORD) = (
void *)GetProcAddress(h_module,
"IsProcessorFeaturePresent");
113 if (is_processor_feature_present)
114 return is_processor_feature_present(0);
124 char *decimal_position = buffer;
126 if (
CRT_tolower((int32_t)*(uint8_t *)decimal_position) !=
'e')
132 decimal_position = &decimal_position[1];
136 uint32_t digit_class_bits = (int32_t)*(uint8_t *)decimal_position;
145 char displaced_character = *(uint8_t *)decimal_position;
149 char *shift_cursor = &decimal_position[1];
150 char shifted_character;
154 shifted_character = *(uint8_t *)shift_cursor;
155 *(uint8_t *)shift_cursor = displaced_character;
156 displaced_character = shifted_character;
157 shifted_character = *(uint8_t *)shift_cursor;
158 shift_cursor = &shift_cursor[1];
159 }
while (shifted_character);
166 char *decimal_cursor = formatted_string;
168 char character = *(uint8_t *)decimal_cursor;
172 while (character != decimal_or_suffix_character)
174 character = decimal_cursor[1];
175 decimal_cursor = &decimal_cursor[1];
182 char *trim_cursor = &decimal_cursor[1];
184 if (!*(uint8_t *)decimal_cursor)
189 character = *(uint8_t *)trim_cursor;
194 if (character ==
'e')
197 if (character ==
'E')
200 trim_cursor = &trim_cursor[1];
203 char *exponent_cursor = trim_cursor;
208 while (*(uint8_t *)trim_cursor ==
'0');
210 if (*(uint8_t *)trim_cursor == (uint8_t)decimal_or_suffix_character)
215 decimal_or_suffix_character = *(uint8_t *)exponent_cursor;
216 trim_cursor = &trim_cursor[1];
217 exponent_cursor = &exponent_cursor[1];
218 *(uint8_t *)trim_cursor = decimal_or_suffix_character;
219 }
while (decimal_or_suffix_character);
226 return !isnan(*value) && *value >= 0.0;
231void __fassign(int32_t flag,
void *destination,
char const *number)
234 __atodbl((
double *)destination, number);
236 __atoflt((
float *)destination, number);
241char *
_cftoe(
double const *value,
char *buffer, int32_t precision, int32_t uppercase_exponent)
243 int32_t effective_precision;
244 int32_t *conversion_record;
249 effective_precision = precision;
253 uintptr_t decimal_point_bytes = effective_precision > 0;
260 effective_precision = precision;
263 int32_t insert_count = effective_precision > 0;
265 conversion_record = existing_conversion_record;
267 int32_t existing_sign_bytes = *(uint32_t *)existing_conversion_record ==
'-';
272 char *mantissa_cursor = buffer;
274 if (*(uint32_t *)conversion_record ==
'-')
276 *(uint8_t *)mantissa_cursor =
'-';
277 mantissa_cursor = &mantissa_cursor[1];
280 if (effective_precision > 0)
282 *(uint8_t *)mantissa_cursor = mantissa_cursor[1];
283 mantissa_cursor = &mantissa_cursor[1];
288 char *exponent_text =
CRT_strcpy((uintptr_t)leading_digit_bytes + mantissa_cursor + effective_precision,
"e+000");
290 if (uppercase_exponent)
291 *(uint8_t *)exponent_text =
'E';
293 if (*(uint8_t *)conversion_record[3] ==
'0')
296 int32_t decimal_point_position = conversion_record[1];
297 int32_t exponent_magnitude = decimal_point_position - 1;
299 if (decimal_point_position - 1 < 0)
301 exponent_magnitude = -(exponent_magnitude);
302 exponent_text[1] =
'-';
305 if (exponent_magnitude >= 0x64)
307 exponent_text[2] += (char)((int64_t)exponent_magnitude / 0x64);
308 exponent_magnitude = (int64_t)exponent_magnitude % 0x64;
311 if (exponent_magnitude >= 0xa)
313 exponent_text[3] += (char)((int64_t)exponent_magnitude / 0xa);
314 exponent_magnitude = (int64_t)exponent_magnitude % 0xa;
317 exponent_text[4] += (uint8_t)exponent_magnitude;
324char *
_cftof(
double const *value,
char *buffer, int32_t precision)
326 int32_t effective_precision;
327 int32_t *conversion_record;
332 effective_precision = precision;
344 effective_precision = precision;
347 if (stored_precision == effective_precision)
349 int32_t existing_sign_bytes = *(uint32_t *)conversion_record ==
'-';
350 char *trailing_zero_slot = (uintptr_t)existing_sign_bytes + stored_precision + buffer;
352 *(uint8_t *)trailing_zero_slot =
'0';
353 trailing_zero_slot[1] = 0;
357 char *mantissa_start = buffer;
359 if (*(uint32_t *)conversion_record ==
'-')
361 *(uint8_t *)buffer =
'-';
362 mantissa_start = &buffer[1];
365 int32_t decimal_point_position = conversion_record[1];
366 char *decimal_point_slot;
368 if (decimal_point_position > 0)
369 decimal_point_slot = &mantissa_start[decimal_point_position];
373 *(uint8_t *)mantissa_start =
'0';
374 decimal_point_slot = &mantissa_start[1];
377 if (effective_precision <= 0)
383 int32_t negative_point_position = conversion_record[1];
385 if (negative_point_position < 0)
389 int32_t leading_fraction_zeros = -(negative_point_position);
391 if (effective_precision >= leading_fraction_zeros)
392 effective_precision = leading_fraction_zeros;
395 effective_precision = -(negative_point_position);
398 _memset(&decimal_point_slot[1],
'0', effective_precision);
406char *
_cftog(
double const *value,
char *buffer, int32_t precision, int32_t uppercase_exponent)
413 char *output = (uintptr_t)sign_bytes + buffer;
426 if (decimal_exponent < -4 || decimal_exponent >= precision)
429 if (rounding_expanded_exponent)
431 char trailing_character;
435 trailing_character = *(uint8_t *)output;
437 }
while (trailing_character);
439 output[-2] &= trailing_character;
451 char *result =
_cftoe(value, buffer, precision, uppercase_exponent);
464 char *result =
_cftof(value, buffer, precision);
473char *
__cfltcvt(
double const *value,
char *buffer, int32_t format, int32_t precision, int32_t uppercase_exponent)
475 if (format ==
'e' || format ==
'E')
476 return _cftoe(value, buffer, precision, uppercase_exponent);
479 return _cftog(value, buffer, precision, uppercase_exponent);
481 return _cftof(value, buffer, precision);
490 __asm__
volatile(
"fstcw %0" :
"=m"(cw));
495 __asm__
volatile(
"fldcw %0" : :
"m"(cw));
519 return exception_masks | rounding_mode | precision_mode | infinity_mode;
534 return exception_masks | rounding_mode | precision_mode | infinity_mode;
541 int32_t start_word_index = (int64_t)start_bit /
CRT_WORD_BITS;
546 int32_t word_index = start_word_index + 1;
551 const uint32_t *word_cursor = &value[word_index];
555 if (*(uint32_t *)word_cursor)
559 word_cursor = &word_cursor[1];
571 uint32_t *sum = &value[bit_word_index];
574 int32_t carry_word_index = bit_word_index - 1;
576 if (bit_word_index - 1 >= 0)
578 uint32_t *carry_word = &value[carry_word_index];
583 carry_word_index -= 1;
586 if (carry_word_index < 0)
598 int32_t round_bit_index = bit_index - 1;
599 int32_t carry_out = 0;
600 int32_t guard_word_index = (int64_t)(round_bit_index + 1) /
CRT_WORD_BITS;
602 uint32_t *guard_word = &value[guard_word_index];
607 *guard_word &= UINT32_MAX << guard_shift;
609 if (guard_word_index + 1 < 3)
610 __builtin_memset(&value[guard_word_index + 1], 0, (3 - (guard_word_index + 1)) << 2);
619 for (
unsigned i = 0; i < 3; ++i)
636 uint32_t
const *word_cursor = value;
637 int32_t words_checked = 0;
639 while (!*(uint32_t *)word_cursor)
642 word_cursor = &word_cursor[1];
644 if (words_checked >= 3)
655 unsigned word_shift = (unsigned)bit_count / 32, bit_shift = (
unsigned)bit_count % 32;
657 uint32_t original_words[3] = {value[0], value[1], value[2]};
659 for (
int i = 2; i >= 0; --i)
661 value[i] = (unsigned)i < word_shift ? 0 : original_words[i - word_shift] >> bit_shift;
663 if (bit_shift && (
unsigned)i > word_shift)
664 value[i] |= original_words[i - word_shift - 1] << (32 - bit_shift);
673 uint32_t working_mantissa[0x3];
681 working_mantissa[2] = extra_mantissa << 0x10;
684 int32_t output_exponent;
688 uint32_t original_mantissa[0x3];
693 unbiased_exponent += 1;
697 if (unbiased_exponent >= subnormal_exponent - format->
precision_bits)
699 if (unbiased_exponent <= subnormal_exponent)
702 __ld12_shr(working_mantissa, subnormal_exponent - unbiased_exponent);
709 else if (unbiased_exponent < format->overflow_exponent)
715 output_exponent = exponent_bias + unbiased_exponent;
716 __ld12_shr(working_mantissa, normal_exponent_bits);
755 if (storage_bits == 0x40)
757 uint32_t *output_words = output;
758 uint32_t output_low_word = working_mantissa[1];
760 output_words[1] = output_high_word;
761 *(uint32_t *)output_words = output_low_word;
763 else if (storage_bits == 0x20)
764 *(uint32_t *)output = output_high_word;
813 for (
int i = 0; i < digit_count; ++i)
814 *output++ = *digits ? *digits++ :
'0';
818 if (digit_count >= 0 && *digits >=
'5')
862 __builtin_memcpy(&bits, source, 8);
864 uint32_t high_word = (uint32_t)(bits >> 32);
870 int extended_exponent;
879 __builtin_memset(destination, 0, 10);
887 while (!(mantissa >> 63))
894 __builtin_memcpy(destination, &mantissa, 8);
895 destination[4] = sign | (uint16_t)extended_exponent;
910 uint32_t wrapped_sum = left + right;
914 return wrapped_sum < left;
919void ___add_12(uint32_t *accumulator, uint32_t
const *addend)
934 uint32_t lo = value[0], mid = value[1], hi = value[2];
937 value[1] = (mid << 1) | (lo >> 31);
938 value[2] = (hi << 1) | (mid >> 31);
945 uint32_t high_word = value[2];
946 uint32_t middle_word = value[1];
952 value[2] = high_word >> 1;
953 *(uint32_t *)value = shifted_low_word;
960 uint32_t mantissa_words[3] = {0, 0, 0};
963 for (uint32_t i = 0; i < digit_count; ++i)
965 uint64_t carry = digits[i];
967 for (
int j = 0; j < 3; ++j)
969 carry += (uint64_t)mantissa_words[j] * 10;
970 mantissa_words[j] = (uint32_t)carry;
975 while (!(mantissa_words[2] & UINT16_MAX))
977 mantissa_words[2] = (mantissa_words[2] << 16) | (mantissa_words[1] >> 16);
978 mantissa_words[1] = (mantissa_words[1] << 16) | (mantissa_words[0] >> 16);
979 mantissa_words[0] <<= 16;
989 memcpy(output, mantissa_words, 12);
998 uint16_t left_sign_exponent = left_and_result->
sign_exponent;
999 int32_t discarded_one_count = 0;
1000 uint32_t product_words[0x3];
1002 product_words[0] = 0;
1003 product_words[1] = 0;
1004 product_words[2] = 0;
1009 uint32_t exponent_sum = right_exponent + left_exponent;
1010 int32_t result_exponent = exponent_sum;
1019 (((uint16_t)result_sign) ? 4294934528U : 2147450880U);
1037 if (!(uint16_t)left_exponent)
1039 result_exponent += 1;
1049 if (!(uint16_t)right_exponent)
1050 result_exponent += 1;
1064 int32_t diagonal_index = 0;
1065 uint16_t *carry_word_cursor = (uint16_t *)(&product_words[1]);
1067 for (int32_t diagonal_product_count = 5; diagonal_product_count > 0; diagonal_product_count -= 1)
1069 if (diagonal_product_count > 0)
1071 uint16_t
const *left_limb_cursor = (
const uint16_t *)(diagonal_index * 2 + (int32_t)left_and_result);
1072 uint16_t
const *right_limb_cursor = (
const uint16_t *)((int32_t)&right->
mantissa_high + 2);
1073 int32_t inner_product_count = diagonal_product_count;
1078 (uint32_t)*(uint16_t *)left_limb_cursor * (uint32_t)*(uint16_t *)right_limb_cursor,
1079 (uint32_t *)(&carry_word_cursor[-2])))
1080 *(uint16_t *)carry_word_cursor += 1;
1082 left_limb_cursor = &left_limb_cursor[1];
1083 right_limb_cursor = (
const uint16_t *)((int32_t)right_limb_cursor - 2);
1084 }
while (--inner_product_count);
1087 carry_word_cursor = &carry_word_cursor[1];
1088 diagonal_index += 1;
1093 if ((int16_t)result_exponent > 0)
1098 result_exponent += UINT16_MAX;
1100 if ((int16_t)result_exponent <= 0)
1105 if ((int16_t)result_exponent <= 0)
1107 result_exponent += UINT16_MAX;
1109 if ((int16_t)result_exponent < 0)
1111 int32_t denormal_shift_count = -((int32_t)(int16_t)result_exponent);
1113 result_exponent += denormal_shift_count;
1115 int32_t shifts_remaining = denormal_shift_count;
1120 discarded_one_count += 1;
1123 }
while (--shifts_remaining);
1125 if (discarded_one_count)
1132 if (*(uint32_t *)((
char *)&product_words[0] + 2) != 0xffffffff)
1133 *(uint32_t *)((
char *)&product_words[0] + 2) += 1;
1136 *(uint32_t *)((
char *)&product_words[0] + 2) = 0;
1138 if (*(uint32_t *)((
char *)&product_words[1] + 2) != 0xffffffff)
1139 *(uint32_t *)((
char *)&product_words[1] + 2) += 1;
1142 *(uint32_t *)((
char *)&product_words[1] + 2) = 0;
1144 if (*(uint16_t *)((
char *)&product_words[2] + 2) != 0xffff)
1145 *(uint16_t *)((
char *)&product_words[2] + 2) += 1;
1148 result_exponent += 1;
1155 int16_t packed_result_exponent = (uint16_t)result_exponent;
1164 (((uint16_t)result_sign) ? 4294934528U : 2147450880U);
1170 left_and_result->
extra_mantissa = *(uint16_t *)((
char *)&product_words[0] + 2);
1173 left_and_result->
sign_exponent = packed_result_exponent | (uint16_t)result_sign;
1181 uint32_t power_group_index = 0;
1202 const struct CRT_LD12Fields *right = &table[power_group_index + digit - 1];
1215 power_group_index += 7;
void String_MakeInsertionGap(char *buffer, int32_t insert_count)
void __shl_12byte(uint32_t *value)
void _cropzeros(char *formatted_string)
int32_t __ld12_is_zero_upper(uint32_t const *value, int32_t start_bit)
void ___add_12(uint32_t *accumulator, uint32_t const *addend)
char * _cftog(double const *value, char *buffer, int32_t precision, int32_t uppercase_exponent)
char * String_FormatScientificFloat(double const *value, char *buffer, int32_t precision, int32_t uppercase_exponent)
char * _cftoe(double const *value, char *buffer, int32_t precision, int32_t uppercase_exponent)
void __ld12_copy(uint32_t *dest, uint32_t const *src)
int32_t __ld12_is_zero(uint32_t const *value)
int32_t __ld12_round_and_clear(uint32_t *value, int32_t bit_index)
char * String_RoundAndCopyDigitsFloat(char *output, int32_t digit_count, struct CRT_FloatConversionRecord *conversion_state)
char * _cftof(double const *value, char *buffer, int32_t precision)
int32_t __atoflt(float *output, char const *text)
int32_t __ld12_to_ieee(struct CRT_LD12Fields const *value, void *output, struct CRT_IEEEFormatDescriptor const *format)
void __flt_mul(struct CRT_LD12Fields *left_and_result, struct CRT_LD12Fields const *right)
int32_t _positive(double const *value)
int32_t __add_with_overflow_check(uint32_t left, uint32_t right, uint32_t *sum)
uint32_t _cw_to_abstract_cw(uint32_t control_word)
int32_t __ld12_to_double(struct CRT_LD12Fields const *value, double *output)
char * __cfltcvt(double const *value, char *buffer, int32_t format, int32_t precision, int32_t uppercase_exponent)
void __fassign(int32_t flag, void *destination, char const *number)
int32_t __ld12_increment(uint32_t *value, int32_t bit_index)
void __double_to_long_double80(uint16_t *destination, double const *source)
void __ld12_shr(uint32_t *value, int32_t bit_count)
void CRT_AbortFloatSupportNotLoaded()
void __shr_12byte(uint32_t *value)
char * String_FormatFixedUsingCachedDigits(double const *value, char *buffer, int32_t precision)
void _forcdecpt(char *buffer)
struct CRT_FloatConversionRecord * __fpmath(double value)
void CRT_InitializeFloatingPoint()
int32_t CRT_TestFdivBugFallback()
int32_t CRT_TestPentiumFdivBug()
int64_t __ftol_msvc(long double value)
uint32_t _abstract_cw_to_cw(uint32_t abstract_control_word)
void __mtold12(uint8_t const *digits, uint32_t digit_count, struct CRT_LD12Fields *output)
uint32_t CRT_control87(uint32_t new_control, uint32_t mask)
uint32_t CRT_controlfp(uint32_t new_value, uint32_t mask)
void __flt_power10(struct CRT_LD12Fields *value, int32_t power, int32_t mult12)
int32_t __ld12_to_float(struct CRT_LD12Fields const *value, float *output)
void _setdefaultprecision()
void CRT_InitFloatFormatDispatch()
void __ld12_clear(uint32_t *value)
int32_t __atodbl(double *output, char const *text)
#define g_pFloatOutputFunction
#define g_pFloatConvertFunction
#define g_pFloatCropFunction
#define g_crtGetModuleHandleAPtr
#define CRT_MANTISSA_ROUND_BIT
#define CRT_DOUBLE_EXPONENT_BIAS
#define X87_CONTROL_PRECISION_MASK
#define CRT_EXTENDED_INTEGER_BIT
#define CRT_FLOAT_USE_CACHED_DIGITS
#define CRT_EXTENDED_MANTISSA_INTEGER_BIT
#define CRT_MANTISSA_STICKY_BIT
#define CRT_POWER10_TABLE_RADIX
#define CRT_DOUBLE_MANTISSA_MASK
#define CRT_DOUBLE_EXPONENT_MASK
#define CRT_CONTROL_OVERFLOW_MASK
#define CRT_FLOAT_SIGN_MASK
#define CRT_MANTISSA_ROUND_EVEN_BIT
#define CRT_CONTROL_UNDERFLOW_MASK
#define X87_CONTROL_INEXACT_MASK
#define CRT_EXTENDED_EXPONENT_BIAS
#define X87_CONTROL_UNDERFLOW_MASK
#define X87_CONTROL_ZERO_DIVIDE_MASK
#define X87_CONTROL_ROUNDING_MASK
#define CRT_CONTROL_ZERO_DIVIDE_MASK
#define CRT_EXTENDED_EXPONENT_MASK
#define CRT_CONTROL_INFINITY_AFFINE
#define CRT_CONTROL_INVALID_MASK
#define X87_CONTROL_INVALID_MASK
#define CRT_EXTENDED_PRODUCT_UNDERFLOW_SUM
#define CRT_EXTENDED_PRODUCT_OVERFLOW_SUM
#define CRT_WORD_SHIFT_MASK
#define CRT_CONTROL_ROUNDING_MASK
#define CRT_EXTENDED_SIGN_MASK
#define CRT_CONTROL_PRECISION_MASK
@ CRT_RUNTIME_FLOAT_UNAVAILABLE
#define CRT_CONTROL_DENORMAL_MASK
#define X87_CONTROL_INFINITY_AFFINE
#define CRT_CONTROL_INEXACT_MASK
#define X87_CONTROL_OVERFLOW_MASK
#define X87_CONTROL_DENORMAL_MASK
void _cropzeros(char *formatted_string)
int32_t __strgtold12(struct CRT_LD12Fields *output, const char **end_pointer, char const *text, int32_t mult12, int32_t scale, int32_t decimal_point, int32_t implicit_exponent)
void __amsg_exit(int32_t runtime_error)
int32_t CRT_tolower(int32_t ch)
BOOL String_ConvertToDecimalStringFloat(struct CRT_Extended80Argument value, int32_t digit_count, uint32_t format_flags, struct CRT_DecimalFloatOutput *output)
int32_t _positive(double const *value)
char * __cfltcvt(double const *value, char *buffer, int32_t format, int32_t precision, int32_t uppercase_exponent)
void * CRT_MoveBytesOverlapSafeDuplicate(void *dest, void const *src, uint32_t count)
void __fassign(int32_t flag, void *destination, char const *number)
void _forcdecpt(char *buffer)
void * _memset(void *dest, int32_t value, uint32_t count)
uint32_t _strlen(char const *str)
int32_t CRT_isctype(int32_t ch, int32_t char_type_mask)
char * CRT_strcpy(char *dest, char const *src)
#define g_crtFloatPrecision
#define g_crtDecimalPoint
#define g_pCRT_FloatHandler2
#define g_crtFloatingPointMode
#define g_crtFPMathState0
int32_t global_type_g_crtFPMathState1
#define g_ieeeDoubleFormatDescriptor
#define g_crtNegativePowersOfTen
#define g_crtPositivePowersOfTen
#define g_pCRT_FloatHandler1
#define g_crtFPMathState1
#define g_pCRT_FloatHandler0
#define g_ieeeFloatFormatDescriptor
#define g_crtHeapInitialized
uint8_t classification_flags
int32_t decimalPointPosition
uint32_t encoding_words[3]
uint16_t mantissa_high_upper_word
uint16_t mantissa_low_upper_word
int32_t global_type_g_floatFormatPrecision
#define g_floatFormatFlags
#define g_floatFormatPrecision
#define g_decimalPointChar