YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replacing 96-bit integer with 128-bit integer in ecma_number_to_zt_string and ecma_zt_string_to_number conversion routines.

Browse Source
This commit is contained in:
Ruben Ayrapetyan
2014-10-24 23:06:02 +04:00
parent b773ef074c
commit f0ab69b01a
1 changed files with 219 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libecmaobjects/ecma-helpers-conversion.c
+219 -168
View File
@@ -25,246 +25,294 @@
#include "jerry-libc.h" #include "jerry-libc.h"
/* /*
* \addtogroup ecmahelpersbigintegers Helpers for operations intermediate 96-bit integers * \addtogroup ecmahelpersbigintegers Helpers for operations intermediate 128-bit integers
* @{ * @{
*/ */
/** /**
* Check that parts of 96-bit integer are 32-bit. * Check that parts of 128-bit integer are 32-bit.
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT(name) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT(name) \
{ \ { \
JERRY_ASSERT (name[0] == (uint32_t) name[0]); \ JERRY_ASSERT (name[0] == (uint32_t) name[0]); \
JERRY_ASSERT (name[1] == (uint32_t) name[1]); \ JERRY_ASSERT (name[1] == (uint32_t) name[1]); \
JERRY_ASSERT (name[2] == (uint32_t) name[2]); \ JERRY_ASSERT (name[2] == (uint32_t) name[2]); \
JERRY_ASSERT (name[3] == (uint32_t) name[3]); \
} }
/** /**
* Declare 96-bit integer. * Declare 128-bit integer.
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER(name) uint64_t name[3] = { 0, 0, 0 } #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER(name) uint64_t name[4] = { 0, 0, 0, 0 }
/** /**
* Initialize 96-bit integer with given 32-bit parts * Initialize 128-bit integer with given 32-bit parts
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_INIT(name, high, mid, low) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_INIT(name, high, mid_high, mid_low, low) \
{ \ { \
name[2] = high; \ name[3] = high; \
name[1] = mid; \ name[2] = mid_high; \
name[1] = mid_low; \
name[0] = low; \ name[0] = low; \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
} }
/** /**
* Copy specified 96-bit integer * Copy specified 128-bit integer
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_COPY(name_copy_to, name_copy_from) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_COPY(name_copy_to, name_copy_from) \
{ \ { \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_copy_to); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_copy_to); \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_copy_from); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_copy_from); \
\ \
name_copy_to[0] = name_copy_from [0]; \ name_copy_to[0] = name_copy_from [0]; \
name_copy_to[1] = name_copy_from [1]; \ name_copy_to[1] = name_copy_from [1]; \
name_copy_to[2] = name_copy_from [2]; \ name_copy_to[2] = name_copy_from [2]; \
name_copy_to[3] = name_copy_from [3]; \
} }
/** /**
* Copy high and middle parts of 96-bit integer to specified uint64_t variable * Copy high and middle parts of 128-bit integer to specified uint64_t variable
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_ROUND_HIGH_AND_MIDDLE_TO_UINT64(name, uint64_var) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ROUND_HIGH_AND_MIDDLE_TO_UINT64(name, uint64_var) \
{ \ { \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
uint64_var = (name[2] << 32u) | (name[1] + ((name[0] >> 31u) != 0 ? 1 : 0)); \ uint64_var = (name[3] << 32u) | (name[2] + ((name[1] >> 31u) != 0 ? 1 : 0)); \
} }
/** /**
* Copy middle and low parts of 96-bit integer to specified uint64_t variable * Copy middle and low parts of 128-bit integer to specified uint64_t variable
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_ROUND_MIDDLE_AND_LOW_TO_UINT64(name, uint64_var) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ROUND_MIDDLE_AND_LOW_TO_UINT64(name, uint64_var) \
{ \ { \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
uint64_var = (name[1] << 32u) | (name[0]); \ uint64_var = (name[1] << 32u) | (name[0]); \
} }
/** /**
* Check if specified 96-bit integers are equal * Check if specified 128-bit integers are equal
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_ARE_EQUAL(name1, name2) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ARE_EQUAL(name1, name2) \
((name1)[0] == (name2[0]) \ ((name1)[0] == (name2[0]) \
&& (name1)[1] == (name2[1]) \ && (name1)[1] == (name2[1]) \
&& (name1)[2] == (name2[2])) && (name1)[2] == (name2[2]) \
&& (name1)[3] == (name2[3]))
/** /**
* Check if bits [lowest_bit, 96) are zero * Check if bits [lowest_bit, 128) are zero
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO(name, lowest_bit) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO(name, lowest_bit) \
((lowest_bit) >= 64 ? ((name[2] >> ((lowest_bit) - 64)) == 0) : \ ((lowest_bit) >= 96 ? ((name[3] >> ((lowest_bit) - 96)) == 0) : \
((lowest_bit) >= 32 ? (name[2] == 0 && ((name[1] >> ((lowest_bit) - 32)) == 0)) : \ ((lowest_bit) >= 64 ? (name[3] == 0 \
(name[2] == 0 && name[1] == 0 && ((name[0] >> (lowest_bit)) == 0)))) && ((name[2] >> ((lowest_bit) - 64)) == 0)) : \
((lowest_bit) >= 32 ? (name[3] == 0 \
&& name[2] == 0 && ((name[1] >> ((lowest_bit) - 32)) == 0)) : \
(name[3] == 0 && name[2] == 0 && name[1] == 0 && ((name[0] >> (lowest_bit)) == 0)))))
/** /**
* Check if bits [0, highest_bit] are zero * Check if bits [0, highest_bit] are zero
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_LOW_BIT_MASK_ZERO(name, highest_bit) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_LOW_BIT_MASK_ZERO(name, highest_bit) \
((highest_bit >= 64) ? (name[1] == 0 && name[0] == 0 && (((uint32_t) name[2] << (95 - (highest_bit))) == 0)) : \ ((highest_bit >= 96) ? (name[2] == 0 && name[1] == 0 && name[0] == 0 \
((highest_bit >= 32) ? (name[0] == 0 && (((uint32_t) name[1] << (63 - (highest_bit))) == 0)) : \ && (((uint32_t) name[3] << (127 - (highest_bit))) == 0)) : \
(((uint32_t) name[0] << (31 - (highest_bit))) == 0))) ((highest_bit >= 64) ? (name[1] == 0 && name[0] == 0 \
&& (((uint32_t) name[2] << (95 - (highest_bit))) == 0)) : \
((highest_bit >= 32) ? (name[0] == 0 \
&& (((uint32_t) name[1] << (63 - (highest_bit))) == 0)) : \
(((uint32_t) name[0] << (31 - (highest_bit))) == 0))))
/** /**
* Check if 96-bit integer is zero * Check if 128-bit integer is zero
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_ZERO(name) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_ZERO(name) \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (name, 0) ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (name, 0)
/** /**
* Shift 96-bit integer one bit left * Shift 128-bit integer one bit left
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT(name) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT(name) \
{ \ { \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
\ \
name[3] = (uint32_t) (name[3] << 1u); \
name[3] |= name[2] >> 31u; \
name[2] = (uint32_t) (name[2] << 1u); \ name[2] = (uint32_t) (name[2] << 1u); \
name[2] |= name[1] >> 31u; \ name[2] |= name[1] >> 31u; \
name[1] = (uint32_t) (name[1] << 1u); \ name[1] = (uint32_t) (name[1] << 1u); \
name[1] |= name[0] >> 31u; \ name[1] |= name[0] >> 31u; \
name[0] = (uint32_t) (name[0] << 1u); \ name[0] = (uint32_t) (name[0] << 1u); \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
} }
/** /**
* Shift 96-bit integer one bit right * Shift 128-bit integer one bit right
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_RIGHT_SHIFT(name) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_RIGHT_SHIFT(name) \
{ \ { \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
\ \
name[0] >>= 1u; \ name[0] >>= 1u; \
name[0] |= (uint32_t) (name[1] << 31u); \ name[0] |= (uint32_t) (name[1] << 31u); \
name[1] >>= 1u; \ name[1] >>= 1u; \
name[1] |= (uint32_t) (name[2] << 31u); \ name[1] |= (uint32_t) (name[2] << 31u); \
name[2] >>= 1u; \ name[2] >>= 1u; \
name[2] |= (uint32_t) (name[3] << 31u); \
name[3] >>= 1u; \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
} }
/** /**
* Increment 96-bit integer * Increment 128-bit integer
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_INC(name) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_INC(name) \
{ \ { \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
\ \
name [0] += 1ull; \ name [0] += 1ull; \
name [1] += (name [0] >> 32u); \ name [1] += (name [0] >> 32u); \
name [0] = (uint32_t) name [0]; \ name [0] = (uint32_t) name [0]; \
name [2] += (name [1] >> 32u); \ name [2] += (name [1] >> 32u); \
name [1] = (uint32_t) name [1]; \ name [1] = (uint32_t) name [1]; \
name [3] += (name [2] >> 32u); \
name [2] = (uint32_t) name [2]; \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
} }
/** /**
* Add 96-bit integer * Add 128-bit integer
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_ADD(name_add_to, name_to_add) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ADD(name_add_to, name_to_add) \
{ \ { \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_add_to); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_add_to); \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_to_add); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_to_add); \
\ \
name_add_to [0] += name_to_add [0]; \ name_add_to [0] += name_to_add [0]; \
name_add_to [1] += name_to_add [1]; \ name_add_to [1] += name_to_add [1]; \
name_add_to [2] += name_to_add [2]; \ name_add_to [2] += name_to_add [2]; \
name_add_to [3] += name_to_add [3]; \
\
name_add_to [1] += (name_add_to [0] >> 32u); \ name_add_to [1] += (name_add_to [0] >> 32u); \
name_add_to [0] = (uint32_t) name_add_to [0]; \ name_add_to [0] = (uint32_t) name_add_to [0]; \
name_add_to [2] += (name_add_to [1] >> 32u); \ name_add_to [2] += (name_add_to [1] >> 32u); \
name_add_to [1] = (uint32_t) name_add_to [1]; \ name_add_to [1] = (uint32_t) name_add_to [1]; \
name_add_to [3] += (name_add_to [2] >> 32u); \
name_add_to [2] = (uint32_t) name_add_to [2]; \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_add_to); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_add_to); \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_to_add); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name_to_add); \
} }
/** /**
* Multiply 96-bit integer by 10 * Multiply 128-bit integer by 10
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_MUL_10(name) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_MUL_10(name) \
{ \ { \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
\ \
/* fraction_uint96 = (fraction_uint96 << 3) + (fraction_uint96 << 1) or fraction_uint96 *= 10 */ \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT (name); \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT (name); \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER (name ## _tmp); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER (name ## _tmp); \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_COPY (name ## _tmp, name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_COPY (name ## _tmp, name); \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT (name ## _tmp); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT (name ## _tmp); \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT (name ## _tmp); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT (name ## _tmp); \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_ADD (name, name ## _tmp); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ADD (name, name ## _tmp); \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
} }
/** /**
* Divide 96-bit integer by 10 * Divide 128-bit integer by 10
*/ */
#define ECMA_NUMBER_CONVERSION_96BIT_INTEGER_DIV_10(name) \ #define ECMA_NUMBER_CONVERSION_128BIT_INTEGER_DIV_10(name) \
{ \ { \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
\ \
/* estimation of reciprocal of 10 */ \ /* estimation of reciprocal of 10 */ \
const uint64_t div10_p_low = 0x9999999aul; \ const uint64_t div10_p_low = 0x9999999aul; \
const uint64_t div10_p_mid = 0x99999999ul; \ const uint64_t div10_p_mid = 0x99999999ul; \
const uint64_t div10_p_high = 0x19999999ul; \ const uint64_t div10_p_high = 0x19999999ul; \
\ \
uint64_t intermediate [6] = { 0, 0, 0, 0, 0, 0 }; \ uint64_t intermediate [8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; \
uint64_t tmp; \ uint64_t l0, l1, l2, l3, m0, m1, m2, m3, h0, h1, h2, h3; \
tmp = div10_p_low * name[0]; \ l0 = name[0] * div10_p_low; \
intermediate [0] += (uint32_t) tmp; \ l1 = name[1] * div10_p_low; \
intermediate [1] += tmp >> 32u; \ l2 = name[2] * div10_p_low; \
tmp = div10_p_low * name[1]; \ l3 = name[3] * div10_p_low; \
intermediate [1] += (uint32_t) tmp; \ m0 = name[0] * div10_p_mid; \
intermediate [2] += tmp >> 32u; \ m1 = name[1] * div10_p_mid; \
tmp = div10_p_mid * name[0]; \ m2 = name[2] * div10_p_mid; \
intermediate [1] += (uint32_t) tmp; \ m3 = name[3] * div10_p_mid; \
intermediate [2] += tmp >> 32u; \ h0 = name[0] * div10_p_high; \
tmp = div10_p_low * name[2]; \ h1 = name[1] * div10_p_high; \
intermediate [2] += (uint32_t) tmp; \ h2 = name[2] * div10_p_high; \
intermediate [3] += tmp >> 32u; \ h3 = name[3] * div10_p_high; \
tmp = div10_p_mid * name[1]; \ intermediate[0] += (uint32_t) l0; \
intermediate [2] += (uint32_t) tmp; \ intermediate[1] += l0 >> 32u; \
intermediate [3] += tmp >> 32u; \
tmp = div10_p_high * name[0]; \
intermediate [2] += (uint32_t) tmp; \
intermediate [3] += tmp >> 32u; \
tmp = div10_p_mid * name[2]; \
intermediate [3] += (uint32_t) tmp; \
intermediate [4] += tmp >> 32u; \
tmp = div10_p_high * name[1]; \
intermediate [3] += (uint32_t) tmp; \
intermediate [4] += tmp >> 32u; \
tmp = div10_p_high * name[2]; \
intermediate [4] += (uint32_t) tmp; \
intermediate [5] += tmp >> 32u; \
\ \
intermediate[1] += intermediate[0] >> 32u; \ intermediate[1] += (uint32_t) l1; \
intermediate[0] = (uint32_t) intermediate [0]; \ intermediate[2] += l1 >> 32u; \
intermediate[2] += intermediate[1] >> 32u; \ intermediate[1] += (uint32_t) m0; \
intermediate[1] = (uint32_t) intermediate [1]; \ intermediate[2] += m0 >> 32u; \
intermediate[3] += intermediate[2] >> 32u; \
intermediate[2] = (uint32_t) intermediate [2]; \
intermediate[4] += intermediate[3] >> 32u; \
intermediate[3] = (uint32_t) intermediate [3]; \
intermediate[5] += intermediate[4] >> 32u; \
intermediate[4] = (uint32_t) intermediate [4]; \
\ \
name[0] = intermediate [3]; \ intermediate[2] += (uint32_t) l2; \
name[1] = intermediate [4]; \ intermediate[3] += l2 >> 32u; \
name[2] = intermediate [5]; \ intermediate[2] += (uint32_t) m1; \
intermediate[3] += m1 >> 32u; \
intermediate[2] += (uint32_t) m0; \
intermediate[3] += m0 >> 32u; \
\ \
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \ intermediate[3] += (uint32_t) l3; \
intermediate[4] += l3 >> 32u; \
intermediate[3] += (uint32_t) m2; \
intermediate[4] += m2 >> 32u; \
intermediate[3] += (uint32_t) m1; \
intermediate[4] += m1 >> 32u; \
intermediate[3] += (uint32_t) h0; \
intermediate[4] += h0 >> 32u; \
\
intermediate[4] += (uint32_t) m3; \
intermediate[5] += m3 >> 32u; \
intermediate[4] += (uint32_t) m2; \
intermediate[5] += m2 >> 32u; \
intermediate[4] += (uint32_t) h1; \
intermediate[5] += h1 >> 32u; \
\
intermediate[5] += (uint32_t) m3; \
intermediate[6] += m3 >> 32u; \
intermediate[5] += (uint32_t) h2; \
intermediate[6] += h2 >> 32u; \
\
intermediate[6] += (uint32_t) h3; \
intermediate[7] += h3 >> 32u; \
\
intermediate [1] += intermediate[0] >> 32u; \
intermediate [0] = (uint32_t) intermediate[0]; \
intermediate [2] += intermediate[1] >> 32u; \
intermediate [1] = (uint32_t) intermediate[1]; \
intermediate [3] += intermediate[2] >> 32u; \
intermediate [2] = (uint32_t) intermediate[2]; \
intermediate [4] += intermediate[3] >> 32u; \
intermediate [3] = (uint32_t) intermediate[3]; \
intermediate [5] += intermediate[4] >> 32u; \
intermediate [4] = (uint32_t) intermediate[4]; \
intermediate [6] += intermediate[5] >> 32u; \
intermediate [5] = (uint32_t) intermediate[5]; \
intermediate [7] += intermediate[6] >> 32u; \
intermediate [6] = (uint32_t) intermediate[6]; \
\
name[0] = intermediate [4]; \
name[1] = intermediate [5]; \
name[2] = intermediate [6]; \
name[3] = intermediate [7]; \
\
ECMA_NUMBER_CONVERSION_128BIT_INTEGER_CHECK_PARTS_ARE_32BIT (name); \
} }
/** /**
@@ -559,25 +607,26 @@ ecma_zt_string_to_number (const ecma_char_t *str_p) /**< zero-terminated string
int32_t binary_exponent = 1; int32_t binary_exponent = 1;
/* /*
* 96-bit mantissa storage * 128-bit mantissa storage
* *
* Normalized: |4 bits zero|92-bit mantissa with highest bit set to 1 if mantissa is non-zero| * Normalized: |4 bits zero|124-bit mantissa with highest bit set to 1 if mantissa is non-zero|
*/ */
ECMA_NUMBER_CONVERSION_96BIT_INTEGER (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER (fraction_uint128);
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_INIT (fraction_uint96, ECMA_NUMBER_CONVERSION_128BIT_INTEGER_INIT (fraction_uint128,
fraction_uint64 >> 32u, fraction_uint64 >> 32u,
(uint32_t) fraction_uint64, (uint32_t) fraction_uint64,
0ull,
0ull); 0ull);
/* Normalizing mantissa */ /* Normalizing mantissa */
JERRY_ASSERT (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 92)); JERRY_ASSERT (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 124));
while (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 91)) while (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 123))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT (fraction_uint128);
binary_exponent--; binary_exponent--;
JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_ZERO (fraction_uint96)); JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_ZERO (fraction_uint128));
} }
if (!e_sign) if (!e_sign)
@@ -587,26 +636,26 @@ ecma_zt_string_to_number (const ecma_char_t *str_p) /**< zero-terminated string
while (e > 0) while (e > 0)
{ {
JERRY_ASSERT (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 92)); JERRY_ASSERT (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 124));
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_MUL_10 (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_MUL_10 (fraction_uint128);
e--; e--;
/* Normalizing mantissa */ /* Normalizing mantissa */
while (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 92)) while (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 124))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_RIGHT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_RIGHT_SHIFT (fraction_uint128);
binary_exponent++; binary_exponent++;
} }
while (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 91)) while (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 123))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT (fraction_uint128);
binary_exponent--; binary_exponent--;
JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_ZERO (fraction_uint96)); JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_ZERO (fraction_uint128));
} }
} }
} }
@@ -618,63 +667,63 @@ ecma_zt_string_to_number (const ecma_char_t *str_p) /**< zero-terminated string
while (e > 0) while (e > 0)
{ {
/* Denormalizing mantissa, moving highest 1 to 95-bit */ /* Denormalizing mantissa, moving highest 1 to 95-bit */
while (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 95)) while (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 127))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT (fraction_uint128);
binary_exponent--; binary_exponent--;
JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_ZERO (fraction_uint96)); JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_ZERO (fraction_uint128));
} }
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_DIV_10 (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_DIV_10 (fraction_uint128);
e--; e--;
} }
/* Normalizing mantissa */ /* Normalizing mantissa */
while (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 92)) while (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 124))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_RIGHT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_RIGHT_SHIFT (fraction_uint128);
binary_exponent++; binary_exponent++;
} }
while (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 91)) while (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 123))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT (fraction_uint128);
binary_exponent--; binary_exponent--;
JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_ZERO (fraction_uint96)); JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_ZERO (fraction_uint128));
} }
} }
JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_ZERO (fraction_uint96)); JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_ZERO (fraction_uint128));
JERRY_ASSERT (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 92)); JERRY_ASSERT (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 124));
/* /*
* Preparing mantissa for conversion to 52-bit representation, converting it to: * Preparing mantissa for conversion to 52-bit representation, converting it to:
* *
* |12 zero bits|84 mantissa bits| * |12 zero bits|116 mantissa bits|
*/ */
while (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 84 + 1)) while (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 116 + 1))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_RIGHT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_RIGHT_SHIFT (fraction_uint128);
binary_exponent++; binary_exponent++;
} }
while (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 84)) while (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 116))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT (fraction_uint128);
binary_exponent--; binary_exponent--;
JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_ZERO (fraction_uint96)); JERRY_ASSERT (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_ZERO (fraction_uint128));
} }
JERRY_ASSERT (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 84 + 1)); JERRY_ASSERT (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 116 + 1));
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_ROUND_HIGH_AND_MIDDLE_TO_UINT64 (fraction_uint96, fraction_uint64); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ROUND_HIGH_AND_MIDDLE_TO_UINT64 (fraction_uint128, fraction_uint64);
return ecma_number_make_from_sign_mantissa_and_exponent (sign, return ecma_number_make_from_sign_mantissa_and_exponent (sign,
fraction_uint64, fraction_uint64,
@@ -802,7 +851,7 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
int32_t *out_digits_num_p, /**< out: number of digits */ int32_t *out_digits_num_p, /**< out: number of digits */
int32_t *out_decimal_exp_p) /**< out: decimal exponent */ int32_t *out_decimal_exp_p) /**< out: decimal exponent */
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER (fraction_uint128);
#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 #if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
uint32_t s[2]; uint32_t s[2];
@@ -830,7 +879,8 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
if (i == 0) if (i == 0)
{ {
/* Lowest binary fraction that should round to fraction_uint64 */ /* Lowest binary fraction that should round to fraction_uint64 */
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_INIT (fraction_uint96, ECMA_NUMBER_CONVERSION_128BIT_INTEGER_INIT (fraction_uint128,
0ull,
(fraction_uint64 - 1ull) >> 48u, (fraction_uint64 - 1ull) >> 48u,
((fraction_uint64 - 1ull) << 16u) >> 32u, ((fraction_uint64 - 1ull) << 16u) >> 32u,
((fraction_uint64 - 1ull) << 48u) >> 32u | 0x8000u); ((fraction_uint64 - 1ull) << 48u) >> 32u | 0x8000u);
@@ -838,7 +888,8 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
else else
{ {
/* Highest binary fraction that should round to fraction_uint64 */ /* Highest binary fraction that should round to fraction_uint64 */
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_INIT (fraction_uint96, ECMA_NUMBER_CONVERSION_128BIT_INTEGER_INIT (fraction_uint128,
0ull,
(fraction_uint64) >> 48u, (fraction_uint64) >> 48u,
((fraction_uint64) << 16u) >> 32u, ((fraction_uint64) << 16u) >> 32u,
((fraction_uint64) << 48u) >> 32u | 0x7fffu); ((fraction_uint64) << 48u) >> 32u | 0x7fffu);
@@ -851,28 +902,28 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
{ {
while (binary_exponent > 0) while (binary_exponent > 0)
{ {
if (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 92)) if (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 124))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_INC (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_INC (fraction_uint128);
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_RIGHT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_RIGHT_SHIFT (fraction_uint128);
binary_exponent++; binary_exponent++;
} }
else else
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER (fraction_uint96_tmp); ECMA_NUMBER_CONVERSION_128BIT_INTEGER (fraction_uint128_tmp);
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_COPY (fraction_uint96_tmp, fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_COPY (fraction_uint128_tmp, fraction_uint128);
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_DIV_10 (fraction_uint96_tmp); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_DIV_10 (fraction_uint128_tmp);
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_MUL_10 (fraction_uint96_tmp); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_MUL_10 (fraction_uint128_tmp);
if (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_ARE_EQUAL (fraction_uint96, fraction_uint96_tmp) if (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ARE_EQUAL (fraction_uint128, fraction_uint128_tmp)
&& ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 91)) && ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 123))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_LEFT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_LEFT_SHIFT (fraction_uint128);
binary_exponent--; binary_exponent--;
} }
else else
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_DIV_10 (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_DIV_10 (fraction_uint128);
decimal_exp++; decimal_exp++;
} }
} }
@@ -882,16 +933,16 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
{ {
while (binary_exponent < 0) while (binary_exponent < 0)
{ {
if (ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_LOW_BIT_MASK_ZERO (fraction_uint96, 0) if (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_LOW_BIT_MASK_ZERO (fraction_uint128, 0)
|| !ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 92)) || !ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 124))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_RIGHT_SHIFT (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_RIGHT_SHIFT (fraction_uint128);
binary_exponent++; binary_exponent++;
} }
else else
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_MUL_10 (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_MUL_10 (fraction_uint128);
decimal_exp--; decimal_exp--;
} }
@@ -903,17 +954,17 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
/* While fraction doesn't fit to 64-bit integer, divide it by 10 /* While fraction doesn't fit to 64-bit integer, divide it by 10
and simultaneously increment decimal exponent */ and simultaneously increment decimal exponent */
while (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 64)) while (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 64))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_DIV_10 (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_DIV_10 (fraction_uint128);
decimal_exp++; decimal_exp++;
} }
#elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 #elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
uint32_t digits, t; uint32_t digits, t;
while (!ECMA_NUMBER_CONVERSION_96BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint96, 32)) while (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 32))
{ {
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_DIV_10 (fraction_uint96); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_DIV_10 (fraction_uint128);
decimal_exp++; decimal_exp++;
} }
#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */ #endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
@@ -921,7 +972,7 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
uint64_t digits_uint64; uint64_t digits_uint64;
int32_t digits_num = 0; int32_t digits_num = 0;
ECMA_NUMBER_CONVERSION_96BIT_INTEGER_ROUND_MIDDLE_AND_LOW_TO_UINT64 (fraction_uint96, digits_uint64); ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ROUND_MIDDLE_AND_LOW_TO_UINT64 (fraction_uint128, digits_uint64);
#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64 #if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64
digits = digits_uint64; digits = digits_uint64;