[gnome-sdk-images/wip/tvb/aarch64: 4/8] mozjs24: Update of double-conversion library
- From: Tristan Van Berkom <tvb src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-sdk-images/wip/tvb/aarch64: 4/8] mozjs24: Update of double-conversion library
- Date: Mon, 9 May 2016 17:13:51 +0000 (UTC)
commit 0c517c4c09da65c252fe5d929f4c2f4153a12af2
Author: Tristan Van Berkom <tristan vanberkom codethink co uk>
Date: Wed Apr 20 15:46:12 2016 +0100
mozjs24: Update of double-conversion library
Update to the latest sources in the upstream double-conversion
library (https://github.com/google/double-conversion). This is required
to build on aarch64 hardware, otherwise you get the following build errors:
"Target architecture was not detected as supported by Double-Conversion."
This was fixed in upstream mozilla some time after mozjs24 with a patch
on this bug report:
https://bugzilla.mozilla.org/show_bug.cgi?id=962488
That patch does not apply against the mozjs24 tarball though, so resorted
to manually updating the double-precision directory following the script
at mozjs24/mfbt/double-conversion/update.sh.
mozjs-double-conversion-aarch64.patch | 969 +++++++++++++++++++++++++++++++++
org.gnome.Sdk.json.in | 4 +
2 files changed, 973 insertions(+), 0 deletions(-)
---
diff --git a/mozjs-double-conversion-aarch64.patch b/mozjs-double-conversion-aarch64.patch
new file mode 100644
index 0000000..5fdca49
--- /dev/null
+++ b/mozjs-double-conversion-aarch64.patch
@@ -0,0 +1,969 @@
+diff -upr mozjs24-1/mfbt/double-conversion/bignum.cc
mozjs24-double-conversion-update/mfbt/double-conversion/bignum.cc
+--- mozjs24-1/mfbt/double-conversion/bignum.cc 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/bignum.cc 2016-04-20 16:03:00.150347220 +0100
+@@ -40,6 +40,7 @@ Bignum::Bignum()
+
+ template<typename S>
+ static int BitSize(S value) {
++ (void) value; // Mark variable as used.
+ return 8 * sizeof(value);
+ }
+
+@@ -103,7 +104,7 @@ void Bignum::AssignDecimalString(Vector<
+ const int kMaxUint64DecimalDigits = 19;
+ Zero();
+ int length = value.length();
+- int pos = 0;
++ unsigned int pos = 0;
+ // Let's just say that each digit needs 4 bits.
+ while (length >= kMaxUint64DecimalDigits) {
+ uint64_t digits = ReadUInt64(value, pos, kMaxUint64DecimalDigits);
+@@ -122,9 +123,8 @@ void Bignum::AssignDecimalString(Vector<
+ static int HexCharValue(char c) {
+ if ('0' <= c && c <= '9') return c - '0';
+ if ('a' <= c && c <= 'f') return 10 + c - 'a';
+- if ('A' <= c && c <= 'F') return 10 + c - 'A';
+- UNREACHABLE();
+- return 0; // To make compiler happy.
++ ASSERT('A' <= c && c <= 'F');
++ return 10 + c - 'A';
+ }
+
+
+@@ -501,13 +501,14 @@ uint16_t Bignum::DivideModuloIntBignum(c
+ // Start by removing multiples of 'other' until both numbers have the same
+ // number of digits.
+ while (BigitLength() > other.BigitLength()) {
+- // This naive approach is extremely inefficient if the this divided other
+- // might be big. This function is implemented for doubleToString where
++ // This naive approach is extremely inefficient if `this` divided by other
++ // is big. This function is implemented for doubleToString where
+ // the result should be small (less than 10).
+ ASSERT(other.bigits_[other.used_digits_ - 1] >= ((1 << kBigitSize) / 16));
++ ASSERT(bigits_[used_digits_ - 1] < 0x10000);
+ // Remove the multiples of the first digit.
+ // Example this = 23 and other equals 9. -> Remove 2 multiples.
+- result += bigits_[used_digits_ - 1];
++ result += static_cast<uint16_t>(bigits_[used_digits_ - 1]);
+ SubtractTimes(other, bigits_[used_digits_ - 1]);
+ }
+
+@@ -523,13 +524,15 @@ uint16_t Bignum::DivideModuloIntBignum(c
+ // Shortcut for easy (and common) case.
+ int quotient = this_bigit / other_bigit;
+ bigits_[used_digits_ - 1] = this_bigit - other_bigit * quotient;
+- result += quotient;
++ ASSERT(quotient < 0x10000);
++ result += static_cast<uint16_t>(quotient);
+ Clamp();
+ return result;
+ }
+
+ int division_estimate = this_bigit / (other_bigit + 1);
+- result += division_estimate;
++ ASSERT(division_estimate < 0x10000);
++ result += static_cast<uint16_t>(division_estimate);
+ SubtractTimes(other, division_estimate);
+
+ if (other_bigit * (division_estimate + 1) > this_bigit) {
+@@ -560,8 +563,8 @@ static int SizeInHexChars(S number) {
+
+ static char HexCharOfValue(int value) {
+ ASSERT(0 <= value && value <= 16);
+- if (value < 10) return value + '0';
+- return value - 10 + 'A';
++ if (value < 10) return static_cast<char>(value + '0');
++ return static_cast<char>(value - 10 + 'A');
+ }
+
+
+@@ -755,7 +758,6 @@ void Bignum::SubtractTimes(const Bignum&
+ Chunk difference = bigits_[i] - borrow;
+ bigits_[i] = difference & kBigitMask;
+ borrow = difference >> (kChunkSize - 1);
+- ++i;
+ }
+ Clamp();
+ }
+diff -upr mozjs24-1/mfbt/double-conversion/bignum-dtoa.cc
mozjs24-double-conversion-update/mfbt/double-conversion/bignum-dtoa.cc
+--- mozjs24-1/mfbt/double-conversion/bignum-dtoa.cc 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/bignum-dtoa.cc 2016-04-20 16:03:00.150347220
+0100
+@@ -192,13 +192,13 @@ static void GenerateShortestDigits(Bignu
+ delta_plus = delta_minus;
+ }
+ *length = 0;
+- while (true) {
++ for (;;) {
+ uint16_t digit;
+ digit = numerator->DivideModuloIntBignum(*denominator);
+ ASSERT(digit <= 9); // digit is a uint16_t and therefore always positive.
+ // digit = numerator / denominator (integer division).
+ // numerator = numerator % denominator.
+- buffer[(*length)++] = digit + '0';
++ buffer[(*length)++] = static_cast<char>(digit + '0');
+
+ // Can we stop already?
+ // If the remainder of the division is less than the distance to the lower
+@@ -282,7 +282,7 @@ static void GenerateShortestDigits(Bignu
+ // exponent (decimal_point), when rounding upwards.
+ static void GenerateCountedDigits(int count, int* decimal_point,
+ Bignum* numerator, Bignum* denominator,
+- Vector<char>(buffer), int* length) {
++ Vector<char> buffer, int* length) {
+ ASSERT(count >= 0);
+ for (int i = 0; i < count - 1; ++i) {
+ uint16_t digit;
+@@ -290,7 +290,7 @@ static void GenerateCountedDigits(int co
+ ASSERT(digit <= 9); // digit is a uint16_t and therefore always positive.
+ // digit = numerator / denominator (integer division).
+ // numerator = numerator % denominator.
+- buffer[i] = digit + '0';
++ buffer[i] = static_cast<char>(digit + '0');
+ // Prepare for next iteration.
+ numerator->Times10();
+ }
+@@ -300,7 +300,8 @@ static void GenerateCountedDigits(int co
+ if (Bignum::PlusCompare(*numerator, *numerator, *denominator) >= 0) {
+ digit++;
+ }
+- buffer[count - 1] = digit + '0';
++ ASSERT(digit <= 10);
++ buffer[count - 1] = static_cast<char>(digit + '0');
+ // Correct bad digits (in case we had a sequence of '9's). Propagate the
+ // carry until we hat a non-'9' or til we reach the first digit.
+ for (int i = count - 1; i > 0; --i) {
+diff -upr mozjs24-1/mfbt/double-conversion/bignum.h
mozjs24-double-conversion-update/mfbt/double-conversion/bignum.h
+--- mozjs24-1/mfbt/double-conversion/bignum.h 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/bignum.h 2016-04-20 16:03:03.706387583 +0100
+@@ -49,7 +49,6 @@ class Bignum {
+
+ void AssignPowerUInt16(uint16_t base, int exponent);
+
+- void AddUInt16(uint16_t operand);
+ void AddUInt64(uint64_t operand);
+ void AddBignum(const Bignum& other);
+ // Precondition: this >= other.
+diff -upr mozjs24-1/mfbt/double-conversion/cached-powers.cc
mozjs24-double-conversion-update/mfbt/double-conversion/cached-powers.cc
+--- mozjs24-1/mfbt/double-conversion/cached-powers.cc 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/cached-powers.cc 2016-04-20 16:03:00.150347220
+0100
+@@ -131,7 +131,6 @@ static const CachedPower kCachedPowers[]
+ {UINT64_2PART_C(0xaf87023b, 9bf0ee6b), 1066, 340},
+ };
+
+-static const int kCachedPowersLength = ARRAY_SIZE(kCachedPowers);
+ static const int kCachedPowersOffset = 348; // -1 * the first decimal_exponent.
+ static const double kD_1_LOG2_10 = 0.30102999566398114; // 1 / lg(10)
+ // Difference between the decimal exponents in the table above.
+@@ -149,9 +148,10 @@ void PowersOfTenCache::GetCachedPowerFor
+ int foo = kCachedPowersOffset;
+ int index =
+ (foo + static_cast<int>(k) - 1) / kDecimalExponentDistance + 1;
+- ASSERT(0 <= index && index < kCachedPowersLength);
++ ASSERT(0 <= index && index < static_cast<int>(ARRAY_SIZE(kCachedPowers)));
+ CachedPower cached_power = kCachedPowers[index];
+ ASSERT(min_exponent <= cached_power.binary_exponent);
++ (void) max_exponent; // Mark variable as used.
+ ASSERT(cached_power.binary_exponent <= max_exponent);
+ *decimal_exponent = cached_power.decimal_exponent;
+ *power = DiyFp(cached_power.significand, cached_power.binary_exponent);
+diff -upr mozjs24-1/mfbt/double-conversion/diy-fp.h
mozjs24-double-conversion-update/mfbt/double-conversion/diy-fp.h
+--- mozjs24-1/mfbt/double-conversion/diy-fp.h 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/diy-fp.h 2016-04-20 16:03:03.706387583 +0100
+@@ -42,7 +42,7 @@ class DiyFp {
+ static const int kSignificandSize = 64;
+
+ DiyFp() : f_(0), e_(0) {}
+- DiyFp(uint64_t f, int e) : f_(f), e_(e) {}
++ DiyFp(uint64_t significand, int exponent) : f_(significand), e_(exponent) {}
+
+ // this = this - other.
+ // The exponents of both numbers must be the same and the significand of this
+@@ -76,22 +76,22 @@ class DiyFp {
+
+ void Normalize() {
+ ASSERT(f_ != 0);
+- uint64_t f = f_;
+- int e = e_;
++ uint64_t significand = f_;
++ int exponent = e_;
+
+ // This method is mainly called for normalizing boundaries. In general
+ // boundaries need to be shifted by 10 bits. We thus optimize for this case.
+ const uint64_t k10MSBits = UINT64_2PART_C(0xFFC00000, 00000000);
+- while ((f & k10MSBits) == 0) {
+- f <<= 10;
+- e -= 10;
++ while ((significand & k10MSBits) == 0) {
++ significand <<= 10;
++ exponent -= 10;
+ }
+- while ((f & kUint64MSB) == 0) {
+- f <<= 1;
+- e--;
++ while ((significand & kUint64MSB) == 0) {
++ significand <<= 1;
++ exponent--;
+ }
+- f_ = f;
+- e_ = e;
++ f_ = significand;
++ e_ = exponent;
+ }
+
+ static DiyFp Normalize(const DiyFp& a) {
+diff -upr mozjs24-1/mfbt/double-conversion/double-conversion.cc
mozjs24-double-conversion-update/mfbt/double-conversion/double-conversion.cc
+--- mozjs24-1/mfbt/double-conversion/double-conversion.cc 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/double-conversion.cc 2016-04-20
16:03:00.150347220 +0100
+@@ -118,7 +118,7 @@ void DoubleToStringConverter::CreateDeci
+ StringBuilder* result_builder) const {
+ // Create a representation that is padded with zeros if needed.
+ if (decimal_point <= 0) {
+- // "0.00000decimal_rep".
++ // "0.00000decimal_rep" or "0.000decimal_rep00".
+ result_builder->AddCharacter('0');
+ if (digits_after_point > 0) {
+ result_builder->AddCharacter('.');
+@@ -129,7 +129,7 @@ void DoubleToStringConverter::CreateDeci
+ result_builder->AddPadding('0', remaining_digits);
+ }
+ } else if (decimal_point >= length) {
+- // "decimal_rep0000.00000" or "decimal_rep.0000"
++ // "decimal_rep0000.00000" or "decimal_rep.0000".
+ result_builder->AddSubstring(decimal_digits, length);
+ result_builder->AddPadding('0', decimal_point - length);
+ if (digits_after_point > 0) {
+@@ -137,7 +137,7 @@ void DoubleToStringConverter::CreateDeci
+ result_builder->AddPadding('0', digits_after_point);
+ }
+ } else {
+- // "decima.l_rep000"
++ // "decima.l_rep000".
+ ASSERT(digits_after_point > 0);
+ result_builder->AddSubstring(decimal_digits, decimal_point);
+ result_builder->AddCharacter('.');
+@@ -348,7 +348,6 @@ static BignumDtoaMode DtoaToBignumDtoaMo
+ case DoubleToStringConverter::PRECISION: return BIGNUM_DTOA_PRECISION;
+ default:
+ UNREACHABLE();
+- return BIGNUM_DTOA_SHORTEST; // To silence compiler.
+ }
+ }
+
+@@ -403,8 +402,8 @@ void DoubleToStringConverter::DoubleToAs
+ vector, length, point);
+ break;
+ default:
+- UNREACHABLE();
+ fast_worked = false;
++ UNREACHABLE();
+ }
+ if (fast_worked) return;
+
+@@ -417,8 +416,9 @@ void DoubleToStringConverter::DoubleToAs
+
+ // Consumes the given substring from the iterator.
+ // Returns false, if the substring does not match.
+-static bool ConsumeSubString(const char** current,
+- const char* end,
++template <class Iterator>
++static bool ConsumeSubString(Iterator* current,
++ Iterator end,
+ const char* substring) {
+ ASSERT(**current == *substring);
+ for (substring++; *substring != '\0'; substring++) {
+@@ -440,10 +440,36 @@ static bool ConsumeSubString(const char*
+ const int kMaxSignificantDigits = 772;
+
+
++static const char kWhitespaceTable7[] = { 32, 13, 10, 9, 11, 12 };
++static const int kWhitespaceTable7Length = ARRAY_SIZE(kWhitespaceTable7);
++
++
++static const uc16 kWhitespaceTable16[] = {
++ 160, 8232, 8233, 5760, 6158, 8192, 8193, 8194, 8195,
++ 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279
++};
++static const int kWhitespaceTable16Length = ARRAY_SIZE(kWhitespaceTable16);
++
++
++static bool isWhitespace(int x) {
++ if (x < 128) {
++ for (int i = 0; i < kWhitespaceTable7Length; i++) {
++ if (kWhitespaceTable7[i] == x) return true;
++ }
++ } else {
++ for (int i = 0; i < kWhitespaceTable16Length; i++) {
++ if (kWhitespaceTable16[i] == x) return true;
++ }
++ }
++ return false;
++}
++
++
+ // Returns true if a nonspace found and false if the end has reached.
+-static inline bool AdvanceToNonspace(const char** current, const char* end) {
++template <class Iterator>
++static inline bool AdvanceToNonspace(Iterator* current, Iterator end) {
+ while (*current != end) {
+- if (**current != ' ') return true;
++ if (!isWhitespace(**current)) return true;
+ ++*current;
+ }
+ return false;
+@@ -462,26 +488,57 @@ static double SignedZero(bool sign) {
+ }
+
+
++// Returns true if 'c' is a decimal digit that is valid for the given radix.
++//
++// The function is small and could be inlined, but VS2012 emitted a warning
++// because it constant-propagated the radix and concluded that the last
++// condition was always true. By moving it into a separate function the
++// compiler wouldn't warn anymore.
++#if _MSC_VER
++#pragma optimize("",off)
++static bool IsDecimalDigitForRadix(int c, int radix) {
++ return '0' <= c && c <= '9' && (c - '0') < radix;
++}
++#pragma optimize("",on)
++#else
++static bool inline IsDecimalDigitForRadix(int c, int radix) {
++ return '0' <= c && c <= '9' && (c - '0') < radix;
++}
++#endif
++// Returns true if 'c' is a character digit that is valid for the given radix.
++// The 'a_character' should be 'a' or 'A'.
++//
++// The function is small and could be inlined, but VS2012 emitted a warning
++// because it constant-propagated the radix and concluded that the first
++// condition was always false. By moving it into a separate function the
++// compiler wouldn't warn anymore.
++static bool IsCharacterDigitForRadix(int c, int radix, char a_character) {
++ return radix > 10 && c >= a_character && c < a_character + radix - 10;
++}
++
++
+ // Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end.
+-template <int radix_log_2>
+-static double RadixStringToIeee(const char* current,
+- const char* end,
++template <int radix_log_2, class Iterator>
++static double RadixStringToIeee(Iterator* current,
++ Iterator end,
+ bool sign,
+ bool allow_trailing_junk,
+ double junk_string_value,
+ bool read_as_double,
+- const char** trailing_pointer) {
+- ASSERT(current != end);
++ bool* result_is_junk) {
++ ASSERT(*current != end);
+
+ const int kDoubleSize = Double::kSignificandSize;
+ const int kSingleSize = Single::kSignificandSize;
+ const int kSignificandSize = read_as_double? kDoubleSize: kSingleSize;
+
++ *result_is_junk = true;
++
+ // Skip leading 0s.
+- while (*current == '0') {
+- ++current;
+- if (current == end) {
+- *trailing_pointer = end;
++ while (**current == '0') {
++ ++(*current);
++ if (*current == end) {
++ *result_is_junk = false;
+ return SignedZero(sign);
+ }
+ }
+@@ -492,14 +549,14 @@ static double RadixStringToIeee(const ch
+
+ do {
+ int digit;
+- if (*current >= '0' && *current <= '9' && *current < '0' + radix) {
+- digit = static_cast<char>(*current) - '0';
+- } else if (radix > 10 && *current >= 'a' && *current < 'a' + radix - 10) {
+- digit = static_cast<char>(*current) - 'a' + 10;
+- } else if (radix > 10 && *current >= 'A' && *current < 'A' + radix - 10) {
+- digit = static_cast<char>(*current) - 'A' + 10;
++ if (IsDecimalDigitForRadix(**current, radix)) {
++ digit = static_cast<char>(**current) - '0';
++ } else if (IsCharacterDigitForRadix(**current, radix, 'a')) {
++ digit = static_cast<char>(**current) - 'a' + 10;
++ } else if (IsCharacterDigitForRadix(**current, radix, 'A')) {
++ digit = static_cast<char>(**current) - 'A' + 10;
+ } else {
+- if (allow_trailing_junk || !AdvanceToNonspace(¤t, end)) {
++ if (allow_trailing_junk || !AdvanceToNonspace(current, end)) {
+ break;
+ } else {
+ return junk_string_value;
+@@ -523,14 +580,14 @@ static double RadixStringToIeee(const ch
+ exponent = overflow_bits_count;
+
+ bool zero_tail = true;
+- while (true) {
+- ++current;
+- if (current == end || !isDigit(*current, radix)) break;
+- zero_tail = zero_tail && *current == '0';
++ for (;;) {
++ ++(*current);
++ if (*current == end || !isDigit(**current, radix)) break;
++ zero_tail = zero_tail && **current == '0';
+ exponent += radix_log_2;
+ }
+
+- if (!allow_trailing_junk && AdvanceToNonspace(¤t, end)) {
++ if (!allow_trailing_junk && AdvanceToNonspace(current, end)) {
+ return junk_string_value;
+ }
+
+@@ -552,13 +609,13 @@ static double RadixStringToIeee(const ch
+ }
+ break;
+ }
+- ++current;
+- } while (current != end);
++ ++(*current);
++ } while (*current != end);
+
+ ASSERT(number < ((int64_t)1 << kSignificandSize));
+ ASSERT(static_cast<int64_t>(static_cast<double>(number)) == number);
+
+- *trailing_pointer = current;
++ *result_is_junk = false;
+
+ if (exponent == 0) {
+ if (sign) {
+@@ -573,13 +630,14 @@ static double RadixStringToIeee(const ch
+ }
+
+
++template <class Iterator>
+ double StringToDoubleConverter::StringToIeee(
+- const char* input,
++ Iterator input,
+ int length,
+- int* processed_characters_count,
+- bool read_as_double) {
+- const char* current = input;
+- const char* end = input + length;
++ bool read_as_double,
++ int* processed_characters_count) const {
++ Iterator current = input;
++ Iterator end = input + length;
+
+ *processed_characters_count = 0;
+
+@@ -600,7 +658,7 @@ double StringToDoubleConverter::StringTo
+
+ if (allow_leading_spaces || allow_trailing_spaces) {
+ if (!AdvanceToNonspace(¤t, end)) {
+- *processed_characters_count = current - input;
++ *processed_characters_count = static_cast<int>(current - input);
+ return empty_string_value_;
+ }
+ if (!allow_leading_spaces && (input != current)) {
+@@ -626,7 +684,7 @@ double StringToDoubleConverter::StringTo
+ if (*current == '+' || *current == '-') {
+ sign = (*current == '-');
+ ++current;
+- const char* next_non_space = current;
++ Iterator next_non_space = current;
+ // Skip following spaces (if allowed).
+ if (!AdvanceToNonspace(&next_non_space, end)) return junk_string_value_;
+ if (!allow_spaces_after_sign && (current != next_non_space)) {
+@@ -649,7 +707,7 @@ double StringToDoubleConverter::StringTo
+ }
+
+ ASSERT(buffer_pos == 0);
+- *processed_characters_count = current - input;
++ *processed_characters_count = static_cast<int>(current - input);
+ return sign ? -Double::Infinity() : Double::Infinity();
+ }
+ }
+@@ -668,7 +726,7 @@ double StringToDoubleConverter::StringTo
+ }
+
+ ASSERT(buffer_pos == 0);
+- *processed_characters_count = current - input;
++ *processed_characters_count = static_cast<int>(current - input);
+ return sign ? -Double::NaN() : Double::NaN();
+ }
+ }
+@@ -677,7 +735,7 @@ double StringToDoubleConverter::StringTo
+ if (*current == '0') {
+ ++current;
+ if (current == end) {
+- *processed_characters_count = current - input;
++ *processed_characters_count = static_cast<int>(current - input);
+ return SignedZero(sign);
+ }
+
+@@ -690,17 +748,17 @@ double StringToDoubleConverter::StringTo
+ return junk_string_value_; // "0x".
+ }
+
+- const char* tail_pointer = NULL;
+- double result = RadixStringToIeee<4>(current,
++ bool result_is_junk;
++ double result = RadixStringToIeee<4>(¤t,
+ end,
+ sign,
+ allow_trailing_junk,
+ junk_string_value_,
+ read_as_double,
+- &tail_pointer);
+- if (tail_pointer != NULL) {
+- if (allow_trailing_spaces) AdvanceToNonspace(&tail_pointer, end);
+- *processed_characters_count = tail_pointer - input;
++ &result_is_junk);
++ if (!result_is_junk) {
++ if (allow_trailing_spaces) AdvanceToNonspace(¤t, end);
++ *processed_characters_count = static_cast<int>(current - input);
+ }
+ return result;
+ }
+@@ -709,7 +767,7 @@ double StringToDoubleConverter::StringTo
+ while (*current == '0') {
+ ++current;
+ if (current == end) {
+- *processed_characters_count = current - input;
++ *processed_characters_count = static_cast<int>(current - input);
+ return SignedZero(sign);
+ }
+ }
+@@ -757,7 +815,7 @@ double StringToDoubleConverter::StringTo
+ while (*current == '0') {
+ ++current;
+ if (current == end) {
+- *processed_characters_count = current - input;
++ *processed_characters_count = static_cast<int>(current - input);
+ return SignedZero(sign);
+ }
+ exponent--; // Move this 0 into the exponent.
+@@ -801,9 +859,9 @@ double StringToDoubleConverter::StringTo
+ return junk_string_value_;
+ }
+ }
+- char sign = '+';
++ char exponen_sign = '+';
+ if (*current == '+' || *current == '-') {
+- sign = static_cast<char>(*current);
++ exponen_sign = static_cast<char>(*current);
+ ++current;
+ if (current == end) {
+ if (allow_trailing_junk) {
+@@ -837,7 +895,7 @@ double StringToDoubleConverter::StringTo
+ ++current;
+ } while (current != end && *current >= '0' && *current <= '9');
+
+- exponent += (sign == '-' ? -num : num);
++ exponent += (exponen_sign == '-' ? -num : num);
+ }
+
+ if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
+@@ -855,16 +913,17 @@ double StringToDoubleConverter::StringTo
+
+ if (octal) {
+ double result;
+- const char* tail_pointer = NULL;
+- result = RadixStringToIeee<3>(buffer,
++ bool result_is_junk;
++ char* start = buffer;
++ result = RadixStringToIeee<3>(&start,
+ buffer + buffer_pos,
+ sign,
+ allow_trailing_junk,
+ junk_string_value_,
+ read_as_double,
+- &tail_pointer);
+- ASSERT(tail_pointer != NULL);
+- *processed_characters_count = current - input;
++ &result_is_junk);
++ ASSERT(!result_is_junk);
++ *processed_characters_count = static_cast<int>(current - input);
+ return result;
+ }
+
+@@ -882,8 +941,42 @@ double StringToDoubleConverter::StringTo
+ } else {
+ converted = Strtof(Vector<const char>(buffer, buffer_pos), exponent);
+ }
+- *processed_characters_count = current - input;
++ *processed_characters_count = static_cast<int>(current - input);
+ return sign? -converted: converted;
+ }
+
++
++double StringToDoubleConverter::StringToDouble(
++ const char* buffer,
++ int length,
++ int* processed_characters_count) const {
++ return StringToIeee(buffer, length, true, processed_characters_count);
++}
++
++
++double StringToDoubleConverter::StringToDouble(
++ const uc16* buffer,
++ int length,
++ int* processed_characters_count) const {
++ return StringToIeee(buffer, length, true, processed_characters_count);
++}
++
++
++float StringToDoubleConverter::StringToFloat(
++ const char* buffer,
++ int length,
++ int* processed_characters_count) const {
++ return static_cast<float>(StringToIeee(buffer, length, false,
++ processed_characters_count));
++}
++
++
++float StringToDoubleConverter::StringToFloat(
++ const uc16* buffer,
++ int length,
++ int* processed_characters_count) const {
++ return static_cast<float>(StringToIeee(buffer, length, false,
++ processed_characters_count));
++}
++
+ } // namespace double_conversion
+diff -upr mozjs24-1/mfbt/double-conversion/double-conversion.h
mozjs24-double-conversion-update/mfbt/double-conversion/double-conversion.h
+--- mozjs24-1/mfbt/double-conversion/double-conversion.h 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/double-conversion.h 2016-04-20
16:03:16.050527696 +0100
+@@ -416,9 +416,10 @@ class StringToDoubleConverter {
+ // junk, too.
+ // - ALLOW_TRAILING_JUNK: ignore trailing characters that are not part of
+ // a double literal.
+- // - ALLOW_LEADING_SPACES: skip over leading spaces.
+- // - ALLOW_TRAILING_SPACES: ignore trailing spaces.
+- // - ALLOW_SPACES_AFTER_SIGN: ignore spaces after the sign.
++ // - ALLOW_LEADING_SPACES: skip over leading whitespace, including spaces,
++ // new-lines, and tabs.
++ // - ALLOW_TRAILING_SPACES: ignore trailing whitespace.
++ // - ALLOW_SPACES_AFTER_SIGN: ignore whitespace after the sign.
+ // Ex: StringToDouble("- 123.2") -> -123.2.
+ // StringToDouble("+ 123.2") -> 123.2
+ //
+@@ -503,19 +504,24 @@ class StringToDoubleConverter {
+ // in the 'processed_characters_count'. Trailing junk is never included.
+ double StringToDouble(const char* buffer,
+ int length,
+- int* processed_characters_count) {
+- return StringToIeee(buffer, length, processed_characters_count, true);
+- }
++ int* processed_characters_count) const;
++
++ // Same as StringToDouble above but for 16 bit characters.
++ double StringToDouble(const uc16* buffer,
++ int length,
++ int* processed_characters_count) const;
+
+ // Same as StringToDouble but reads a float.
+ // Note that this is not equivalent to static_cast<float>(StringToDouble(...))
+ // due to potential double-rounding.
+ float StringToFloat(const char* buffer,
+ int length,
+- int* processed_characters_count) {
+- return static_cast<float>(StringToIeee(buffer, length,
+- processed_characters_count, false));
+- }
++ int* processed_characters_count) const;
++
++ // Same as StringToFloat above but for 16 bit characters.
++ float StringToFloat(const uc16* buffer,
++ int length,
++ int* processed_characters_count) const;
+
+ private:
+ const int flags_;
+@@ -524,10 +530,11 @@ class StringToDoubleConverter {
+ const char* const infinity_symbol_;
+ const char* const nan_symbol_;
+
+- double StringToIeee(const char* buffer,
++ template <class Iterator>
++ double StringToIeee(Iterator start_pointer,
+ int length,
+- int* processed_characters_count,
+- bool read_as_double);
++ bool read_as_double,
++ int* processed_characters_count) const;
+
+ DISALLOW_IMPLICIT_CONSTRUCTORS(StringToDoubleConverter);
+ };
+diff -upr mozjs24-1/mfbt/double-conversion/fast-dtoa.cc
mozjs24-double-conversion-update/mfbt/double-conversion/fast-dtoa.cc
+--- mozjs24-1/mfbt/double-conversion/fast-dtoa.cc 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/fast-dtoa.cc 2016-04-20 16:03:00.150347220
+0100
+@@ -248,10 +248,7 @@ static void BiggestPowerTen(uint32_t num
+ // Note: kPowersOf10[i] == 10^(i-1).
+ exponent_plus_one_guess++;
+ // We don't have any guarantees that 2^number_bits <= number.
+- // TODO(floitsch): can we change the 'while' into an 'if'? We definitely see
+- // number < (2^number_bits - 1), but I haven't encountered
+- // number < (2^number_bits - 2) yet.
+- while (number < kSmallPowersOfTen[exponent_plus_one_guess]) {
++ if (number < kSmallPowersOfTen[exponent_plus_one_guess]) {
+ exponent_plus_one_guess--;
+ }
+ *power = kSmallPowersOfTen[exponent_plus_one_guess];
+@@ -350,7 +347,8 @@ static bool DigitGen(DiyFp low,
+ // that is smaller than integrals.
+ while (*kappa > 0) {
+ int digit = integrals / divisor;
+- buffer[*length] = '0' + digit;
++ ASSERT(digit <= 9);
++ buffer[*length] = static_cast<char>('0' + digit);
+ (*length)++;
+ integrals %= divisor;
+ (*kappa)--;
+@@ -379,13 +377,14 @@ static bool DigitGen(DiyFp low,
+ ASSERT(one.e() >= -60);
+ ASSERT(fractionals < one.f());
+ ASSERT(UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF) / 10 >= one.f());
+- while (true) {
++ for (;;) {
+ fractionals *= 10;
+ unit *= 10;
+ unsafe_interval.set_f(unsafe_interval.f() * 10);
+ // Integer division by one.
+ int digit = static_cast<int>(fractionals >> -one.e());
+- buffer[*length] = '0' + digit;
++ ASSERT(digit <= 9);
++ buffer[*length] = static_cast<char>('0' + digit);
+ (*length)++;
+ fractionals &= one.f() - 1; // Modulo by one.
+ (*kappa)--;
+@@ -459,7 +458,8 @@ static bool DigitGenCounted(DiyFp w,
+ // that is smaller than 'integrals'.
+ while (*kappa > 0) {
+ int digit = integrals / divisor;
+- buffer[*length] = '0' + digit;
++ ASSERT(digit <= 9);
++ buffer[*length] = static_cast<char>('0' + digit);
+ (*length)++;
+ requested_digits--;
+ integrals %= divisor;
+@@ -492,7 +492,8 @@ static bool DigitGenCounted(DiyFp w,
+ w_error *= 10;
+ // Integer division by one.
+ int digit = static_cast<int>(fractionals >> -one.e());
+- buffer[*length] = '0' + digit;
++ ASSERT(digit <= 9);
++ buffer[*length] = static_cast<char>('0' + digit);
+ (*length)++;
+ requested_digits--;
+ fractionals &= one.f() - 1; // Modulo by one.
+diff -upr mozjs24-1/mfbt/double-conversion/fixed-dtoa.cc
mozjs24-double-conversion-update/mfbt/double-conversion/fixed-dtoa.cc
+--- mozjs24-1/mfbt/double-conversion/fixed-dtoa.cc 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/fixed-dtoa.cc 2016-04-20 16:03:00.150347220
+0100
+@@ -133,7 +133,7 @@ static void FillDigits32(uint32_t number
+ while (number != 0) {
+ int digit = number % 10;
+ number /= 10;
+- buffer[(*length) + number_length] = '0' + digit;
++ buffer[(*length) + number_length] = static_cast<char>('0' + digit);
+ number_length++;
+ }
+ // Exchange the digits.
+@@ -150,7 +150,7 @@ static void FillDigits32(uint32_t number
+ }
+
+
+-static void FillDigits64FixedLength(uint64_t number, int requested_length,
++static void FillDigits64FixedLength(uint64_t number,
+ Vector<char> buffer, int* length) {
+ const uint32_t kTen7 = 10000000;
+ // For efficiency cut the number into 3 uint32_t parts, and print those.
+@@ -253,7 +253,8 @@ static void FillFractionals(uint64_t fra
+ fractionals *= 5;
+ point--;
+ int digit = static_cast<int>(fractionals >> point);
+- buffer[*length] = '0' + digit;
++ ASSERT(digit <= 9);
++ buffer[*length] = static_cast<char>('0' + digit);
+ (*length)++;
+ fractionals -= static_cast<uint64_t>(digit) << point;
+ }
+@@ -274,7 +275,8 @@ static void FillFractionals(uint64_t fra
+ fractionals128.Multiply(5);
+ point--;
+ int digit = fractionals128.DivModPowerOf2(point);
+- buffer[*length] = '0' + digit;
++ ASSERT(digit <= 9);
++ buffer[*length] = static_cast<char>('0' + digit);
+ (*length)++;
+ }
+ if (fractionals128.BitAt(point - 1) == 1) {
+@@ -358,7 +360,7 @@ bool FastFixedDtoa(double v,
+ remainder = (dividend % divisor) << exponent;
+ }
+ FillDigits32(quotient, buffer, length);
+- FillDigits64FixedLength(remainder, divisor_power, buffer, length);
++ FillDigits64FixedLength(remainder, buffer, length);
+ *decimal_point = *length;
+ } else if (exponent >= 0) {
+ // 0 <= exponent <= 11
+diff -upr mozjs24-1/mfbt/double-conversion/ieee.h
mozjs24-double-conversion-update/mfbt/double-conversion/ieee.h
+--- mozjs24-1/mfbt/double-conversion/ieee.h 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/ieee.h 2016-04-20 16:03:03.706387583 +0100
+@@ -256,6 +256,8 @@ class Double {
+ return (significand & kSignificandMask) |
+ (biased_exponent << kPhysicalSignificandSize);
+ }
++
++ DISALLOW_COPY_AND_ASSIGN(Double);
+ };
+
+ class Single {
+@@ -391,6 +393,8 @@ class Single {
+ static const uint32_t kNaN = 0x7FC00000;
+
+ const uint32_t d32_;
++
++ DISALLOW_COPY_AND_ASSIGN(Single);
+ };
+
+ } // namespace double_conversion
+diff -upr mozjs24-1/mfbt/double-conversion/strtod.cc
mozjs24-double-conversion-update/mfbt/double-conversion/strtod.cc
+--- mozjs24-1/mfbt/double-conversion/strtod.cc 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/strtod.cc 2016-04-20 16:03:00.150347220 +0100
+@@ -137,6 +137,7 @@ static void TrimAndCut(Vector<const char
+ Vector<const char> right_trimmed = TrimTrailingZeros(left_trimmed);
+ exponent += left_trimmed.length() - right_trimmed.length();
+ if (right_trimmed.length() > kMaxSignificantDecimalDigits) {
++ (void) space_size; // Mark variable as used.
+ ASSERT(space_size >= kMaxSignificantDecimalDigits);
+ CutToMaxSignificantDigits(right_trimmed, exponent,
+ buffer_copy_space, updated_exponent);
+@@ -263,7 +264,6 @@ static DiyFp AdjustmentPowerOfTen(int ex
+ case 7: return DiyFp(UINT64_2PART_C(0x98968000, 00000000), -40);
+ default:
+ UNREACHABLE();
+- return DiyFp(0, 0);
+ }
+ }
+
+@@ -286,7 +286,7 @@ static bool DiyFpStrtod(Vector<const cha
+ const int kDenominator = 1 << kDenominatorLog;
+ // Move the remaining decimals into the exponent.
+ exponent += remaining_decimals;
+- int error = (remaining_decimals == 0 ? 0 : kDenominator / 2);
++ uint64_t error = (remaining_decimals == 0 ? 0 : kDenominator / 2);
+
+ int old_e = input.e();
+ input.Normalize();
+@@ -515,6 +515,7 @@ float Strtof(Vector<const char> buffer,
+ double double_next2 = Double(double_next).NextDouble();
+ f4 = static_cast<float>(double_next2);
+ }
++ (void) f2; // Mark variable as used.
+ ASSERT(f1 <= f2 && f2 <= f3 && f3 <= f4);
+
+ // If the guess doesn't lie near a single-precision boundary we can simply
+diff -upr mozjs24-1/mfbt/double-conversion/utils.h
mozjs24-double-conversion-update/mfbt/double-conversion/utils.h
+--- mozjs24-1/mfbt/double-conversion/utils.h 2013-10-29 20:40:19.000000000 +0000
++++ mozjs24-double-conversion-update/mfbt/double-conversion/utils.h 2016-04-20 16:03:23.534612645 +0100
+@@ -33,14 +33,29 @@
+
+ #include <assert.h>
+ #ifndef ASSERT
+-#define ASSERT(condition) (assert(condition))
++#define ASSERT(condition) \
++ assert(condition);
+ #endif
+ #ifndef UNIMPLEMENTED
+ #define UNIMPLEMENTED() (abort())
+ #endif
++#ifndef DOUBLE_CONVERSION_NO_RETURN
++#ifdef _MSC_VER
++#define DOUBLE_CONVERSION_NO_RETURN __declspec(noreturn)
++#else
++#define DOUBLE_CONVERSION_NO_RETURN __attribute__((noreturn))
++#endif
++#endif
+ #ifndef UNREACHABLE
++#ifdef _MSC_VER
++void DOUBLE_CONVERSION_NO_RETURN abort_noreturn();
++inline void abort_noreturn() { abort(); }
++#define UNREACHABLE() (abort_noreturn())
++#else
+ #define UNREACHABLE() (abort())
+ #endif
++#endif
++
+
+ // Double operations detection based on target architecture.
+ // Linux uses a 80bit wide floating point stack on x86. This induces double
+@@ -55,11 +70,16 @@
+ #if defined(_M_X64) || defined(__x86_64__) || \
+ defined(__ARMEL__) || defined(__avr32__) || \
+ defined(__hppa__) || defined(__ia64__) || \
+- defined(__mips__) || defined(__powerpc__) || \
++ defined(__mips__) || \
++ defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \
++ defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
+ defined(__sparc__) || defined(__sparc) || defined(__s390__) || \
+ defined(__SH4__) || defined(__alpha__) || \
+- defined(_MIPS_ARCH_MIPS32R2)
++ defined(_MIPS_ARCH_MIPS32R2) || \
++ defined(__AARCH64EL__) || defined(__aarch64__)
+ #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
++#elif defined(__mc68000__)
++#undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
+ #elif defined(_M_IX86) || defined(__i386__) || defined(__i386)
+ #if defined(_WIN32)
+ // Windows uses a 64bit wide floating point stack.
+@@ -71,9 +91,16 @@
+ #error Target architecture was not detected as supported by Double-Conversion.
+ #endif
+
++#if defined(__GNUC__)
++#define DOUBLE_CONVERSION_UNUSED __attribute__((unused))
++#else
++#define DOUBLE_CONVERSION_UNUSED
++#endif
+
+ #include "mozilla/StandardInteger.h"
+
++typedef uint16_t uc16;
++
+ // The following macro works on both 32 and 64-bit platforms.
+ // Usage: instead of writing 0x1234567890123456
+ // write UINT64_2PART_C(0x12345678,90123456);
+@@ -139,8 +166,8 @@ template <typename T>
+ class Vector {
+ public:
+ Vector() : start_(NULL), length_(0) {}
+- Vector(T* data, int length) : start_(data), length_(length) {
+- ASSERT(length == 0 || (length > 0 && data != NULL));
++ Vector(T* data, int len) : start_(data), length_(len) {
++ ASSERT(len == 0 || (len > 0 && data != NULL));
+ }
+
+ // Returns a vector using the same backing storage as this one,
+@@ -182,8 +209,8 @@ class Vector {
+ // buffer bounds on all operations in debug mode.
+ class StringBuilder {
+ public:
+- StringBuilder(char* buffer, int size)
+- : buffer_(buffer, size), position_(0) { }
++ StringBuilder(char* buffer, int buffer_size)
++ : buffer_(buffer, buffer_size), position_(0) { }
+
+ ~StringBuilder() { if (!is_finalized()) Finalize(); }
+
+@@ -280,7 +307,8 @@ template <class Dest, class Source>
+ inline Dest BitCast(const Source& source) {
+ // Compile time assertion: sizeof(Dest) == sizeof(Source)
+ // A compile error here means your Dest and Source have different sizes.
+- typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
++ DOUBLE_CONVERSION_UNUSED
++ typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
+
+ Dest dest;
+ memmove(&dest, &source, sizeof(dest));
+Only in mozjs24-double-conversion-update/mfbt/double-conversion: utils.h.orig
diff --git a/org.gnome.Sdk.json.in b/org.gnome.Sdk.json.in
index 70e1d57..8b2fa9a 100644
--- a/org.gnome.Sdk.json.in
+++ b/org.gnome.Sdk.json.in
@@ -527,6 +527,10 @@
{
"type": "patch",
"path": "mozjs-perl-fix.patch"
+ },
+ {
+ "type": "patch",
+ "path": "mozjs-double-conversion-aarch64.patch"
}
]
},
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
