Directly call ES2015 builtins instead of storing them in a var.

sjrd · sjrd · commit e4b60eb6f16a · 2022-01-30T14:02:35.000+01:00
Previously, when emitting ES2015, we stored some builtins that we often
use in global var defs:

  var $imul = Math.imul;
  var $fround = Math.fround;
  var $clz32 = Math.clz32;

It turns out that engines, especially V8, do a better job at optimizing
direct calls such as `Math.fround(x)` rather than indirect calls such
as `$fround(x)`. And that despite the fact that `$fround` can be
"proven" to be constant, contrary to `Math` or `Math.fround`.

Now, when emitting ES2015, we directly emit calls to `Math.fround(x)`
instead of storing `$fround`. The same applies to `Math.imul` and
`Math.clz32`.

We were already applying that strategy to `Object.is` and `Symbol`
(also ES2015+) and `Object.getOwnPropertyDescriptors` (ES2017+). We
consolidate the logic used for all of these polyfillable builtins.
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/ClassEmitter.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/ClassEmitter.scala
@@ -442,20 +442,17 @@ private[emitter] final class ClassEmitter(sjsGen: SJSGen) {
     } yield {
       implicit val pos = field.pos
 
-      val symbolValue = {
+      val symbolValueWithGlobals = {
         def description = origName.getOrElse(name).toString()
         val args =
           if (semantics.productionMode) Nil
           else js.StringLiteral(description) :: Nil
-
-        if (esFeatures.esVersion >= ESVersion.ES2015)
-          js.Apply(js.VarRef(js.Ident("Symbol")), args)
-        else
-          genCallHelper("privateJSFieldSymbol", args: _*)
+        genCallPolyfillableBuiltin(PolyfillableBuiltin.PrivateSymbolBuiltin, args: _*)
       }
 
-      globalVarDef("r", (tree.className, name), symbolValue,
-          origName.orElse(name))
+      symbolValueWithGlobals.flatMap { symbolValue =>
+        globalVarDef("r", (tree.className, name), symbolValue, origName.orElse(name))
+      }
     }
 
     WithGlobals.list(defs)
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/CoreJSLib.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/CoreJSLib.scala
@@ -28,6 +28,7 @@ import org.scalajs.linker.interface.unstable.RuntimeClassNameMapperImpl
 import org.scalajs.linker.backend.javascript.Trees._
 
 import EmitterNames._
+import PolyfillableBuiltin._
 
 private[emitter] object CoreJSLib {
 
@@ -167,8 +168,8 @@ private[emitter] object CoreJSLib {
     }
 
     private def defineJSBuiltinsSnapshotsAndPolyfills(): Tree = {
-      def genPolyfillFor(builtinName: String): Tree = builtinName match {
-        case "is" =>
+      def genPolyfillFor(builtin: PolyfillableBuiltin): Tree = builtin match {
+        case ObjectIsBuiltin =>
           val x = varRef("x")
           val y = varRef("y")
           genArrowFunction(paramList(x, y), Return {
@@ -181,7 +182,7 @@ private[emitter] object CoreJSLib {
             })
           })
 
-        case "imul" =>
+        case ImulBuiltin =>
           val a = varRef("a")
           val b = varRef("b")
           val ah = varRef("ah")
@@ -196,7 +197,7 @@ private[emitter] object CoreJSLib {
               Return((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) | 0)
           ))
 
-        case "fround" =>
+        case FroundBuiltin =>
           val v = varRef("v")
           if (!strictFloats) {
             genArrowFunction(paramList(v), Return(+v))
@@ -300,7 +301,7 @@ private[emitter] object CoreJSLib {
                 typedArrayPolyfill, noTypedArrayPolyfill)
           }
 
-        case "clz32" =>
+        case Clz32Builtin =>
           val i = varRef("i")
           val r = varRef("r")
           genArrowFunction(paramList(i), Block(
@@ -314,7 +315,7 @@ private[emitter] object CoreJSLib {
               Return(r + (i >> 31))
           ))
 
-        case "privateJSFieldSymbol" =>
+        case PrivateSymbolBuiltin =>
           /* function privateJSFieldSymbol(description) {
            *   function rand32() {
            *     const s = ((Math.random() * 4294967296.0) | 0).toString(16);
@@ -359,7 +360,7 @@ private[emitter] object CoreJSLib {
               }
           ))
 
-        case "getOwnPropertyDescriptors" =>
+        case GetOwnPropertyDescriptorsBuiltin =>
           /* getOwnPropertyDescriptors = (() => {
            *   // Fetch or polyfill Reflect.ownKeys
            *   var ownKeysFun;
@@ -457,31 +458,24 @@ private[emitter] object CoreJSLib {
           Apply(funGenerator, Nil)
       }
 
-      val mathBuiltins = Block(
-        List("imul", "fround", "clz32").map { builtinName =>
-          val rhs0 = genIdentBracketSelect(MathRef, builtinName)
-          val rhs =
-            if (esVersion >= ESVersion.ES2015) rhs0
-            else rhs0 || genPolyfillFor(builtinName)
-          extractWithGlobals(globalVarDef(builtinName, CoreVar, rhs))
+      val polyfillDefs = for {
+        builtin <- PolyfillableBuiltin.All
+        if esVersion < builtin.availableInESVersion
+      } yield {
+        val polyfill = genPolyfillFor(builtin)
+        val rhs = builtin match {
+          case builtin: GlobalVarBuiltin =>
+            // (typeof GlobalVar !== "undefined") ? GlobalVar : polyfill
+            val globalVarRef = globalRef(builtin.globalVar)
+            If(UnaryOp(JSUnaryOp.typeof, globalVarRef) !== str("undefined"),
+                globalVarRef, polyfill)
+          case builtin: NamespacedBuiltin =>
+            // NamespaceGlobalVar.builtinName || polyfill
+            genIdentBracketSelect(globalRef(builtin.namespaceGlobalVar), builtin.builtinName) || polyfill
         }
-      )
-
-      val es5Compat = condTree(esVersion < ESVersion.ES2015)(Block(
-        extractWithGlobals(globalVarDef("is", CoreVar,
-            genIdentBracketSelect(ObjectRef, "is") || genPolyfillFor("is"))),
-        extractWithGlobals(globalVarDef("privateJSFieldSymbol", CoreVar,
-            If(UnaryOp(JSUnaryOp.typeof, SymbolRef) !== str("undefined"),
-                SymbolRef, genPolyfillFor("privateJSFieldSymbol"))))
-      ))
-
-      val es2017Compat = condTree(esVersion < ESVersion.ES2017)(Block(
-        extractWithGlobals(globalVarDef("getOwnPropertyDescriptors", CoreVar,
-            genIdentBracketSelect(ObjectRef, "getOwnPropertyDescriptors") ||
-                genPolyfillFor("getOwnPropertyDescriptors")))
-      ))
-
-      Block(mathBuiltins, es5Compat, es2017Compat)
+        extractWithGlobals(globalVarDef(builtin.builtinName, CoreVar, rhs))
+      }
+      Block(polyfillDefs)
     }
 
     private def declareCachedL0(): Tree = {
@@ -611,12 +605,8 @@ private[emitter] object CoreJSLib {
 
       defineFunction1("objectClone") { instance =>
         // return Object.create(Object.getPrototypeOf(instance), $getOwnPropertyDescriptors(instance));
-        val callGetOwnPropertyDescriptors = {
-          if (esVersion >= ESVersion.ES2017)
-            Apply(genIdentBracketSelect(ObjectRef, "getOwnPropertyDescriptors"), instance :: Nil)
-          else
-            genCallHelper("getOwnPropertyDescriptors", instance)
-        }
+        val callGetOwnPropertyDescriptors = genCallPolyfillableBuiltin(
+            GetOwnPropertyDescriptorsBuiltin, instance)
         Return(Apply(genIdentBracketSelect(ObjectRef, "create"), List(
             Apply(genIdentBracketSelect(ObjectRef, "getPrototypeOf"), instance :: Nil),
             callGetOwnPropertyDescriptors)))
@@ -894,7 +884,7 @@ private[emitter] object CoreJSLib {
                 (abs & bigInt(~0xffffL)) | bigInt(0x8000L)
               })),
               const(absR, Apply(NumberRef, y :: Nil)),
-              Return(genCallHelper("fround", If(x < bigInt(0L), -absR, absR)))
+              Return(genCallPolyfillableBuiltin(FroundBuiltin, If(x < bigInt(0L), -absR, absR)))
             )
           }
         ))
@@ -1188,7 +1178,7 @@ private[emitter] object CoreJSLib {
         condTree(strictFloats)(
           defineFunction1("isFloat") { v =>
             Return((typeof(v) === str("number")) &&
-                ((v !== v) || (genCallHelper("fround", v) === v)))
+                ((v !== v) || (genCallPolyfillableBuiltin(FroundBuiltin, v) === v)))
           }
         )
       )
@@ -1953,6 +1943,11 @@ private[emitter] object CoreJSLib {
     private def genArrowFunction(args: List[ParamDef], body: Tree): Function =
       jsGen.genArrowFunction(args, None, body)
 
+    private def genCallPolyfillableBuiltin(builtin: PolyfillableBuiltin,
+        args: Tree*): Tree = {
+      extractWithGlobals(sjsGen.genCallPolyfillableBuiltin(builtin, args: _*))
+    }
+
     private def maybeWrapInUBE(behavior: CheckedBehavior, exception: Tree): Tree = {
       if (behavior == CheckedBehavior.Fatal) {
         genScalaClassNew(UndefinedBehaviorErrorClass,
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/FunctionEmitter.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/FunctionEmitter.scala
@@ -33,6 +33,7 @@ import org.scalajs.linker.backend.javascript.{Trees => js}
 import java.io.StringWriter
 
 import EmitterNames._
+import PolyfillableBuiltin._
 import Transients._
 
 /** Desugaring of the IR to JavaScript functions.
@@ -2361,10 +2362,8 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
                 js.BinaryOp(if (op == ===) JSBinaryOp.=== else JSBinaryOp.!==,
                     newLhs, newRhs)
               } else {
-                val objectIs =
-                  if (!es2015) globalVar("is", CoreVar)
-                  else genIdentBracketSelect(genGlobalVarRef("Object"), "is")
-                val objectIsCall = js.Apply(objectIs, newLhs :: newRhs :: Nil)
+                val objectIsCall =
+                  genCallPolyfillableBuiltin(ObjectIsBuiltin, newLhs, newRhs)
                 if (op == ===) objectIsCall
                 else js.UnaryOp(JSUnaryOp.!, objectIsCall)
               }
@@ -2388,7 +2387,8 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
                 case IntLiteral(0) => or0(js.UnaryOp(JSUnaryOp.-, newRhs))
                 case _             => or0(js.BinaryOp(JSBinaryOp.-, newLhs, newRhs))
               }
-            case Int_* => genCallHelper("imul", newLhs, newRhs)
+            case Int_* =>
+              genCallPolyfillableBuiltin(ImulBuiltin, newLhs, newRhs)
             case Int_/ =>
               rhs match {
                 case IntLiteral(r) if r != 0 =>
@@ -2662,7 +2662,7 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
           }
 
         case Transient(NumberOfLeadingZeroes(num)) =>
-          genCallHelper("clz32", transformExprNoChar(num))
+          genCallPolyfillableBuiltin(Clz32Builtin, transformExprNoChar(num))
 
         case Transient(ObjectClassName(obj)) =>
           genCallHelper("objectClassName", transformExprNoChar(obj))
@@ -2991,10 +2991,15 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
       js.Apply(globalVar(field, (className, method.name)), args)
     }
 
-    private def genFround(arg: js.Tree)(implicit pos: Position): js.Tree = {
-      genCallHelper("fround", arg)
+    private def genCallPolyfillableBuiltin(
+        builtin: PolyfillableBuiltin, args: js.Tree*)(
+        implicit pos: Position): js.Tree = {
+      extractWithGlobals(sjsGen.genCallPolyfillableBuiltin(builtin, args: _*))
     }
 
+    private def genFround(arg: js.Tree)(implicit pos: Position): js.Tree =
+      genCallPolyfillableBuiltin(FroundBuiltin, arg)
+
     private def wrapBigInt32(tree: js.Tree)(implicit pos: Position): js.Tree =
       wrapBigIntN(32, tree)
 
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/PolyfillableBuiltin.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/PolyfillableBuiltin.scala
@@ -0,0 +1,46 @@
+/*
+ * Scala.js (https://www.scala-js.org/)
+ *
+ * Copyright EPFL.
+ *
+ * Licensed under Apache License 2.0
+ * (https://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package org.scalajs.linker.backend.emitter
+
+import org.scalajs.linker.interface.ESVersion
+
+private[emitter] sealed abstract class PolyfillableBuiltin(
+    val builtinName: String, val availableInESVersion: ESVersion)
+
+private[emitter] object PolyfillableBuiltin {
+  lazy val All: List[PolyfillableBuiltin] = List(
+    ObjectIsBuiltin,
+    ImulBuiltin,
+    FroundBuiltin,
+    Clz32Builtin,
+    PrivateSymbolBuiltin,
+    GetOwnPropertyDescriptorsBuiltin
+  )
+
+  sealed abstract class GlobalVarBuiltin(val globalVar: String,
+      builtinName: String, availableInESVersion: ESVersion)
+      extends PolyfillableBuiltin(builtinName, availableInESVersion)
+
+  sealed abstract class NamespacedBuiltin(val namespaceGlobalVar: String,
+      builtinName: String, availableInESVersion: ESVersion)
+      extends PolyfillableBuiltin(builtinName, availableInESVersion)
+
+  case object ObjectIsBuiltin extends NamespacedBuiltin("Object", "is", ESVersion.ES2015)
+  case object ImulBuiltin extends NamespacedBuiltin("Math", "imul", ESVersion.ES2015)
+  case object FroundBuiltin extends NamespacedBuiltin("Math", "fround", ESVersion.ES2015)
+  case object Clz32Builtin extends NamespacedBuiltin("Math", "clz32", ESVersion.ES2015)
+  case object PrivateSymbolBuiltin
+      extends GlobalVarBuiltin("Symbol", "privateJSFieldSymbol", ESVersion.ES2015)
+  case object GetOwnPropertyDescriptorsBuiltin
+      extends NamespacedBuiltin("Object", "getOwnPropertyDescriptors", ESVersion.ES2017)
+}
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/SJSGen.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/SJSGen.scala
@@ -21,6 +21,7 @@ import org.scalajs.linker.backend.javascript.Trees._
 import org.scalajs.linker.interface._
 
 import EmitterNames._
+import PolyfillableBuiltin._
 
 /** Scala.js specific tree generators that are used across the board.
  *
@@ -372,6 +373,23 @@ private[emitter] final class SJSGen(
     Apply(globalVar(helperName, CoreVar), args.toList)
   }
 
+  def genCallPolyfillableBuiltin(builtin: PolyfillableBuiltin, args: Tree*)(
+      implicit moduleContext: ModuleContext, globalKnowledge: GlobalKnowledge,
+      pos: Position): WithGlobals[Tree] = {
+    if (esFeatures.esVersion >= builtin.availableInESVersion) {
+      builtin match {
+        case builtin: GlobalVarBuiltin =>
+          for (global <- globalRef(builtin.globalVar)) yield
+            Apply(global, args.toList)
+        case builtin: NamespacedBuiltin =>
+          for (namespace <- globalRef(builtin.namespaceGlobalVar)) yield
+            Apply(genIdentBracketSelect(namespace, builtin.builtinName), args.toList)
+      }
+    } else {
+      WithGlobals(genCallHelper(builtin.builtinName, args: _*))
+    }
+  }
+
   def genLoadModule(moduleClass: ClassName)(
       implicit moduleContext: ModuleContext, globalKnowledge: GlobalKnowledge,
       pos: Position): Tree = {
