summaryrefslogtreecommitdiff
path: root/moz/patches/dtoa.patch
diff options
context:
space:
mode:
Diffstat (limited to 'moz/patches/dtoa.patch')
-rw-r--r--moz/patches/dtoa.patch237
1 files changed, 237 insertions, 0 deletions
diff --git a/moz/patches/dtoa.patch b/moz/patches/dtoa.patch
new file mode 100644
index 000000000000..fce3be38b10b
--- /dev/null
+++ b/moz/patches/dtoa.patch
@@ -0,0 +1,237 @@
+--- misc/mozilla/nsprpub/pr/src/misc/prdtoa.c 20 Mar 2009 03:41:21 -0000 4.7
++++ misc/build/mozilla/nsprpub/pr/src/misc/prdtoa.c 15 Sep 2009 00:10:20 -0000
+@@ -169,17 +169,22 @@ void _PR_CleanupDtoa(void)
+ * Llong, #define #ULLong to be the corresponding unsigned type.
+ * #define KR_headers for old-style C function headers.
+ * #define Bad_float_h if your system lacks a float.h or if it does not
+ * define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
+ * FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
+ * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n)
+ * if memory is available and otherwise does something you deem
+ * appropriate. If MALLOC is undefined, malloc will be invoked
+- * directly -- and assumed always to succeed.
++ * directly -- and assumed always to succeed. Similarly, if you
++ * want something other than the system's free() to be called to
++ * recycle memory acquired from MALLOC, #define FREE to be the
++ * name of the alternate routine. (FREE or free is only called in
++ * pathological cases, e.g., in a dtoa call after a dtoa return in
++ * mode 3 with thousands of digits requested.)
+ * #define Omit_Private_Memory to omit logic (added Jan. 1998) for making
+ * memory allocations from a private pool of memory when possible.
+ * When used, the private pool is PRIVATE_MEM bytes long: 2304 bytes,
+ * unless #defined to be a different length. This default length
+ * suffices to get rid of MALLOC calls except for unusual cases,
+ * such as decimal-to-binary conversion of a very long string of
+ * digits. The longest string dtoa can return is about 751 bytes
+ * long. For conversions by strtod of strings of 800 digits and
+@@ -553,17 +558,17 @@ extern double rnd_prod(double, double),
+ #endif
+ #endif /* NO_LONG_LONG */
+
+ #ifndef MULTIPLE_THREADS
+ #define ACQUIRE_DTOA_LOCK(n) /*nothing*/
+ #define FREE_DTOA_LOCK(n) /*nothing*/
+ #endif
+
+-#define Kmax 15
++#define Kmax 7
+
+ struct
+ Bigint {
+ struct Bigint *next;
+ int k, maxwds, sign, wds;
+ ULong x[1];
+ };
+
+@@ -581,27 +586,28 @@ Balloc
+ {
+ int x;
+ Bigint *rv;
+ #ifndef Omit_Private_Memory
+ unsigned int len;
+ #endif
+
+ ACQUIRE_DTOA_LOCK(0);
+- if (rv = freelist[k]) {
++ /* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */
++ /* but this case seems very unlikely. */
++ if (k <= Kmax && (rv = freelist[k]))
+ freelist[k] = rv->next;
+- }
+ else {
+ x = 1 << k;
+ #ifdef Omit_Private_Memory
+ rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
+ #else
+ len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
+ /sizeof(double);
+- if (pmem_next - private_mem + len <= PRIVATE_mem) {
++ if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) {
+ rv = (Bigint*)pmem_next;
+ pmem_next += len;
+ }
+ else
+ rv = (Bigint*)MALLOC(len*sizeof(double));
+ #endif
+ rv->k = k;
+ rv->maxwds = x;
+@@ -615,20 +621,28 @@ Balloc
+ Bfree
+ #ifdef KR_headers
+ (v) Bigint *v;
+ #else
+ (Bigint *v)
+ #endif
+ {
+ if (v) {
+- ACQUIRE_DTOA_LOCK(0);
+- v->next = freelist[v->k];
+- freelist[v->k] = v;
+- FREE_DTOA_LOCK(0);
++ if (v->k > Kmax)
++#ifdef FREE
++ FREE((void*)v);
++#else
++ free((void*)v);
++#endif
++ else {
++ ACQUIRE_DTOA_LOCK(0);
++ v->next = freelist[v->k];
++ freelist[v->k] = v;
++ FREE_DTOA_LOCK(0);
++ }
+ }
+ }
+
+ #define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
+ y->wds*sizeof(Long) + 2*sizeof(int))
+
+ static Bigint *
+ multadd
+--- misc/mozilla/js/src/jsdtoa.c 2 Sep 2007 22:20:41 -0000 3.41
++++ misc/build/mozilla/js/src/jsdtoa.c 18 Sep 2009 16:15:13 -0000
+@@ -145,17 +145,22 @@
+ * and if "unsigned Llong" does not work as an unsigned version of
+ * Llong, #define #ULLong to be the corresponding unsigned type.
+ * #define Bad_float_h if your system lacks a float.h or if it does not
+ * define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
+ * FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
+ * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n)
+ * if memory is available and otherwise does something you deem
+ * appropriate. If MALLOC is undefined, malloc will be invoked
+- * directly -- and assumed always to succeed.
++ * directly -- and assumed always to succeed. Similarly, if you
++ * want something other than the system's free() to be called to
++ * recycle memory acquired from MALLOC, #define FREE to be the
++ * name of the alternate routine. (FREE or free is only called in
++ * pathological cases, e.g., in a dtoa call after a dtoa return in
++ * mode 3 with thousands of digits requested.)
+ * #define Omit_Private_Memory to omit logic (added Jan. 1998) for making
+ * memory allocations from a private pool of memory when possible.
+ * When used, the private pool is PRIVATE_MEM bytes long: 2000 bytes,
+ * unless #defined to be a different length. This default length
+ * suffices to get rid of MALLOC calls except for unusual cases,
+ * such as decimal-to-binary conversion of a very long string of
+ * digits.
+ * #define INFNAN_CHECK on IEEE systems to cause strtod to check for
+@@ -320,17 +325,17 @@ static PRLock *freelist_lock;
+ JS_END_MACRO
+ #define RELEASE_DTOA_LOCK() PR_Unlock(freelist_lock)
+ #else
+ #undef MULTIPLE_THREADS
+ #define ACQUIRE_DTOA_LOCK() /*nothing*/
+ #define RELEASE_DTOA_LOCK() /*nothing*/
+ #endif
+
+-#define Kmax 15
++#define Kmax 7
+
+ struct Bigint {
+ struct Bigint *next; /* Free list link */
+ int32 k; /* lg2(maxwds) */
+ int32 maxwds; /* Number of words allocated for x */
+ int32 sign; /* Zero if positive, 1 if negative. Ignored by most Bigint routines! */
+ int32 wds; /* Actual number of words. If value is nonzero, the most significant word must be nonzero. */
+ ULong x[1]; /* wds words of number in little endian order */
+@@ -400,26 +405,26 @@ static Bigint *Balloc(int32 k)
+
+ #ifdef ENABLE_OOM_TESTING
+ if (++allocationNum == desiredFailure) {
+ printf("Forced Failing Allocation number %d\n", allocationNum);
+ return NULL;
+ }
+ #endif
+
+- if ((rv = freelist[k]) != NULL)
++ if (k <= Kmax && (rv = freelist[k]) != NULL)
+ freelist[k] = rv->next;
+ if (rv == NULL) {
+ x = 1 << k;
+ #ifdef Omit_Private_Memory
+ rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
+ #else
+ len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
+ /sizeof(double);
+- if (pmem_next - private_mem + len <= PRIVATE_mem) {
++ if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) {
+ rv = (Bigint*)pmem_next;
+ pmem_next += len;
+ }
+ else
+ rv = (Bigint*)MALLOC(len*sizeof(double));
+ #endif
+ if (!rv)
+ return NULL;
+@@ -428,18 +433,26 @@ static Bigint *Balloc(int32 k)
+ }
+ rv->sign = rv->wds = 0;
+ return rv;
+ }
+
+ static void Bfree(Bigint *v)
+ {
+ if (v) {
+- v->next = freelist[v->k];
+- freelist[v->k] = v;
++ if (v->k > Kmax)
++#ifdef FREE
++ FREE((void*)v);
++#else
++ free((void*)v);
++#endif
++ else {
++ v->next = freelist[v->k];
++ freelist[v->k] = v;
++ }
+ }
+ }
+
+ #define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
+ y->wds*sizeof(Long) + 2*sizeof(int32))
+
+ /* Return b*m + a. Deallocate the old b. Both a and m must be between 0 and
+ * 65535 inclusive. NOTE: old b is deallocated on memory failure.
+--- misc/mozilla/js/src/jsdtoa.c 22 Sep 2009 06:16:27 -0000 3.42
++++ misc/build/mozilla/js/src/jsdtoa.c 15 Oct 2009 10:34:38 -0000
+@@ -405,19 +405,19 @@ static Bigint *Balloc(int32 k)
+
+ #ifdef ENABLE_OOM_TESTING
+ if (++allocationNum == desiredFailure) {
+ printf("Forced Failing Allocation number %d\n", allocationNum);
+ return NULL;
+ }
+ #endif
+
+- if (k <= Kmax && (rv = freelist[k]) != NULL)
++ if (k <= Kmax && (rv = freelist[k]))
+ freelist[k] = rv->next;
+- if (rv == NULL) {
++ else {
+ x = 1 << k;
+ #ifdef Omit_Private_Memory
+ rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
+ #else
+ len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
+ /sizeof(double);
+ if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) {
+ rv = (Bigint*)pmem_next;
generated by cgit (git 2.34.1) at 2024-06-15 07:34:14 +0000