Use shared container to manage imports/exports.

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.
 
 var kMath;
 var rempio2result;
 
-(function(global, shared, exports) {
+(function(global, utils) {
   
 "use strict";
 
 %CheckIsBootstrapping();
 
+// -------------------------------------------------------------------
+// Imports
+
 var GlobalMath = global.Math;
 
-//-------------------------------------------------------------------
+var MathAbs;
+var MathExp;
+
+utils.Import(function(from) {
+  MathAbs = from.MathAbs;
+  MathExp = from.MathExp;
+});
+
+// -------------------------------------------------------------------
 
 define INVPIO2 = kMath[0];
 define PIO2_1  = kMath[1];
 define PIO2_1T = kMath[2];
 define PIO2_2  = kMath[3];
 define PIO2_2T = kMath[4];
 define PIO2_3  = kMath[5];
 define PIO2_3T = kMath[6];
 define PIO4    = kMath[32];
 define PIO4LO  = kMath[33];
@@ skipping 32 matching lines @@
       } else {
         // near pi/2, use 33+33+53 bit pi
         z += PIO2_2;
         y0 = z + PIO2_2T;
         y1 = (z - y0) + PIO2_2T;
       }
       n = -1;
     }
   } else if (ix <= 0x413921fb) {
     // |X| ~<= 2^19*(pi/2), medium size
-    var t = $abs(X);
+    var t = MathAbs(X);
     n = (t * INVPIO2 + 0.5) | 0;
     var r = t - n * PIO2_1;
     var w = n * PIO2_1T;
     // First round good to 85 bit
     y0 = r - w;
     if (ix - (%_DoubleHi(y0) & 0x7ff00000) > 0x1000000) {
       // 2nd iteration needed, good to 118
       t = r;
       w = n * PIO2_2;
       r = t - w;
@@ skipping 161 matching lines @@
 
 function KernelTan(x, y, returnTan) {
   var z;
   var w;
   var hx = %_DoubleHi(x);
   var ix = hx & 0x7fffffff;
 
   if (ix < 0x3e300000) {  // |x| < 2^-28
     if (((ix | %_DoubleLo(x)) | (returnTan + 1)) == 0) {
       // x == 0 && returnTan = -1
-      return 1 / $abs(x);
+      return 1 / MathAbs(x);
     } else {
       if (returnTan == 1) {
         return x;
       } else {
         // Compute -1/(x + y) carefully
         var w = x + y;
         var z = %_ConstructDouble(%_DoubleHi(w), 0);
         var v = y - (z - x);
         var a = -1 / w;
         var t = %_ConstructDouble(%_DoubleHi(a), 0);
@@ skipping 467 matching lines @@
 //      only sinh(0)=0 is exact for finite x.
 //
 define KSINH_OVERFLOW = kMath[51];
 define TWO_M28 = 3.725290298461914e-9;  // 2^-28, empty lower half
 define LOG_MAXD = 709.7822265625;  // 0x40862e42 00000000, empty lower half
 
 function MathSinh(x) {
   x = x * 1;  // Convert to number.
   var h = (x < 0) ? -0.5 : 0.5;
   // |x| in [0, 22]. return sign(x)*0.5*(E+E/(E+1))
-  var ax = $abs(x);
+  var ax = MathAbs(x);
   if (ax < 22) {
     // For |x| < 2^-28, sinh(x) = x
     if (ax < TWO_M28) return x;
     var t = MathExpm1(ax);
     if (ax < 1) return h * (2 * t - t * t / (t + 1));
     return h * (t + t / (t + 1));
   }
   // |x| in [22, log(maxdouble)], return 0.5 * exp(|x|)
-  if (ax < LOG_MAXD) return h * $exp(ax);
+  if (ax < LOG_MAXD) return h * MathExp(ax);
   // |x| in [log(maxdouble), overflowthreshold]
   // overflowthreshold = 710.4758600739426
   if (ax <= KSINH_OVERFLOW) {
-    var w = $exp(0.5 * ax);
+    var w = MathExp(0.5 * ax);
     var t = h * w;
     return t * w;
   }
   // |x| > overflowthreshold or is NaN.
   // Return Infinity of the appropriate sign or NaN.
   return x * INFINITY;
 }
 
 
 // ES6 draft 09-27-13, section 20.2.2.12.
@@ skipping 17 matching lines @@
 //      cosh(x) is |x| if x is +INF, -INF, or NaN.
 //      only cosh(0)=1 is exact for finite x.
 //
 define KCOSH_OVERFLOW = kMath[51];
 
 function MathCosh(x) {
   x = x * 1;  // Convert to number.
   var ix = %_DoubleHi(x) & 0x7fffffff;
   // |x| in [0,0.5*log2], return 1+expm1(|x|)^2/(2*exp(|x|))
   if (ix < 0x3fd62e43) {
-    var t = MathExpm1($abs(x));
+    var t = MathExpm1(MathAbs(x));
     var w = 1 + t;
     // For |x| < 2^-55, cosh(x) = 1
     if (ix < 0x3c800000) return w;
     return 1 + (t * t) / (w + w);
   }
   // |x| in [0.5*log2, 22], return (exp(|x|)+1/exp(|x|)/2
   if (ix < 0x40360000) {
-    var t = $exp($abs(x));
+    var t = MathExp(MathAbs(x));
     return 0.5 * t + 0.5 / t;
   }
   // |x| in [22, log(maxdouble)], return half*exp(|x|)
-  if (ix < 0x40862e42) return 0.5 * $exp($abs(x));
+  if (ix < 0x40862e42) return 0.5 * MathExp(MathAbs(x));
   // |x| in [log(maxdouble), overflowthreshold]
-  if ($abs(x) <= KCOSH_OVERFLOW) {
-    var w = $exp(0.5 * $abs(x));
+  if (MathAbs(x) <= KCOSH_OVERFLOW) {
+    var w = MathExp(0.5 * MathAbs(x));
     var t = 0.5 * w;
     return t * w;
   }
   if (NUMBER_IS_NAN(x)) return x;
   // |x| > overflowthreshold.
   return INFINITY;
 }
 
 // ES6 draft 09-27-13, section 20.2.2.21.
 // Return the base 10 logarithm of x
@@ skipping 82 matching lines @@
 
 // cp = 2/(3*ln(2)). Note that cp_h + cp_l is cp, but with more accuracy.
 define CP = kMath[61];
 define CP_H = kMath[62];
 define CP_L = kMath[63];
 // 2^53
 define TWO53 = 9007199254740992; 
 
 function MathLog2(x) {
   x = x * 1;  // Convert to number.
-  var ax = $abs(x);
+  var ax = MathAbs(x);
   var hx = %_DoubleHi(x);
   var lx = %_DoubleLo(x);
   var ix = hx & 0x7fffffff;
 
   // Handle special cases.
   // log2(+/- 0) = -Infinity
   if ((ix | lx) == 0) return -INFINITY;
 
   // log(x) = NaN, if x < 0
   if (hx < 0) return NAN;
@@ skipping 81 matching lines @@
   "log10", MathLog10,
   "log2", MathLog2,
   "log1p", MathLog1p,
   "expm1", MathExpm1
 ]);
 
 %SetInlineBuiltinFlag(MathSin);
 %SetInlineBuiltinFlag(MathCos);
 
 })