Allocate typed array for rempio2 result.

src/third_party/fdlibm/fdlibm.js

 // The following is adapted from fdlibm (http://www.netlib.org/fdlibm),
 //
 // ====================================================
 // Copyright (C) 1993-2004 by Sun Microsystems, Inc. All rights reserved.
 //
 // Developed at SunSoft, a Sun Microsystems, Inc. business.
 // Permission to use, copy, modify, and distribute this
 // software is freely granted, provided that this notice
 // is preserved.
 // ====================================================
 //
 // The original source code covered by the above license above has been
 // modified significantly by Google Inc.
 // Copyright 2014 the V8 project authors. All rights reserved.
 //
 // The following is a straightforward translation of fdlibm routines
 // by Raymond Toy (rtoy@google.com).
 
 // Double constants that do not have empty lower 32 bits are found in fdlibm.cc
 // and exposed through kMath as typed array. We assume the compiler to convert
 // from decimal to binary accurately enough to produce the intended values.
 // kMath is initialized to a Float64Array during genesis and not writable.
+// rempio2result is used as a container for return values of %RemPiO2. It is
+// initialized to a two-element Float64Array during genesis.
 
 "use strict";
 
 var kMath;
+var rempio2result;
 
 const INVPIO2 = kMath[0];
 const PIO2_1  = kMath[1];
 const PIO2_1T = kMath[2];
 const PIO2_2  = kMath[3];
 const PIO2_2T = kMath[4];
 const PIO2_3  = kMath[5];
 const PIO2_3T = kMath[6];
 const PIO4    = kMath[32];
 const PIO4LO  = kMath[33];
 
 // Compute k and r such that x - k*pi/2 = r where |r| < pi/4. For
 // precision, r is returned as two values y0 and y1 such that r = y0 + y1
 // to more than double precision.
+
 macro REMPIO2(X)
   var n, y0, y1;
   var hx = %_DoubleHi(X);
   var ix = hx & 0x7fffffff;
 
   if (ix < 0x4002d97c) {
     // |X| ~< 3*pi/4, special case with n = +/- 1
     if (hx > 0) {
       var z = X - PIO2_1;
       if (ix != 0x3ff921fb) {
@@ skipping 47 matching lines @@
       }
     }
     y1 = (r - y0) - w;
     if (hx < 0) {
       n = -n;
       y0 = -y0;
       y1 = -y1;
     }
   } else {
     // Need to do full Payne-Hanek reduction here.
-    var r = %RemPiO2(X);
-    n = r[0];
-    y0 = r[1];
-    y1 = r[2];
+    n = %RemPiO2(X, rempio2result);
+    y0 = rempio2result[0];
+    y1 = rempio2result[1];
   }
 endmacro
 
 
 // __kernel_sin(X, Y, IY)
 // kernel sin function on [-pi/4, pi/4], pi/4 ~ 0.7854
 // Input X is assumed to be bounded by ~pi/4 in magnitude.
 // Input Y is the tail of X so that x = X + Y.
 //
 // Algorithm
@@ skipping 865 matching lines @@
   z_l = CP_L * p_h + p_l * CP + dp_l;
 
   // log2(ax) = (ss + ...) * 2 / (3 * log(2)) = n + dp_h + z_h + z_l
   var t = n;
   var t1 = %_ConstructDouble(%_DoubleHi(((z_h + z_l) + dp_h) + t), 0);
   var t2 = z_l - (((t1 - t) - dp_h) - z_h);
 
   // t1 + t2 = log2(ax), sum up because we do not care about extra precision.
   return t1 + t2;
 }