Changeset 229993 in webkit for trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

Timestamp:

Mar 27, 2018, 1:49:41 AM (7 years ago)

Author:

Yusuke Suzuki

Message:

[JSC] Remove repeated iteration of ElementNode
​https://bugs.webkit.org/show_bug.cgi?id=183987

Reviewed by Keith Miller.

BytecodeGenerator repeatedly iterates ElementNode to emit the efficient code.
While it is OK for small arrays, this repeated iteration takes much time
if the array is very large. For example, Kraken's initialization code includes
very large array with numeric literals. This makes bytecode compiling so long.

This patch carefully removes unnecessary iteration when emitting arrays.
This reduces one of Kraken/imaging-darkroom's bytecode compiling from 13.169856 ms
to 9.988050 ms.

• bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::emitNewArrayBuffer):
(JSC::BytecodeGenerator::emitNewArray):

• bytecompiler/BytecodeGenerator.h:
• bytecompiler/NodesCodegen.cpp:

(JSC::ArrayNode::emitBytecode):
(JSC::ArrayPatternNode::bindValue const):
(JSC::ArrayPatternNode::emitDirectBinding):

File:

• trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp (modified) (5 diffs)

trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

@@ -385 +385 @@
 RegisterID* ArrayNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
-    // FIXME: Should we put all of this code into emitNewArray?
-
+    bool hadVariableExpression = false;
     unsigned length = 0;
     ElementNode* firstPutElement;
@@ -392 +391 @@
         if (firstPutElement->elision() || firstPutElement->value()->isSpreadExpression())
             break;
+        if (!firstPutElement->value()->isConstant())
+            hadVariableExpression = true;
         ++length;
     }
 
+    auto newArray = [&generator] (RegisterID* dst, ElementNode* elements, unsigned length, bool hadVariableExpression) {
+        if (length && !hadVariableExpression) {
+            auto* array = JSFixedArray::create(*generator.vm(), length);
+            unsigned index = 0;
+            for (ElementNode* element = elements; index < length; element = element->next()) {
+                ASSERT(element->value()->isConstant());
+                array->set(*generator.vm(), index++, static_cast<ConstantNode*>(element->value())->jsValue(generator));
+            }
+            return generator.emitNewArrayBuffer(dst, array);
+        }
+        return generator.emitNewArray(dst, elements, length);
+    };
+
     if (!firstPutElement && !m_elision)
-        return generator.emitNewArray(generator.finalDestination(dst), m_element, length);
+        return newArray(generator.finalDestination(dst), m_element, length, hadVariableExpression);
 
     if (firstPutElement && firstPutElement->value()->isSpreadExpression()) {
-        bool hasElision = false;
-        for (ElementNode* node = m_element; node; node = node->next()) {
-            if (!!node->elision()) {
-                hasElision = true;
-                break;
+        bool hasElision = m_elision;
+        if (!hasElision) {
+            for (ElementNode* node = firstPutElement; node; node = node->next()) {
+                if (node->elision()) {
+                    hasElision = true;
+                    break;
+                }
             }
         }
-        if (!!m_elision)
-            hasElision = true;
 
         if (!hasElision)
@@ -413 +427 @@
     }
 
-    RefPtr<RegisterID> array = generator.emitNewArray(generator.tempDestination(dst), m_element, length);
+    RefPtr<RegisterID> array = newArray(generator.tempDestination(dst), m_element, length, hadVariableExpression);
     ElementNode* n = firstPutElement;
     for (; n; n = n->next()) {
@@ -4082 +4096 @@
 
         case BindingType::RestElement: {
-            RefPtr<RegisterID> array = generator.emitNewArray(generator.newTemporary(), 0, 0);
+            RefPtr<RegisterID> array = generator.emitNewArray(generator.newTemporary(), nullptr, 0);
 
             Ref<Label> iterationDone = generator.newLabel();
@@ -4134 +4148 @@
     RefPtr<RegisterID> resultRegister;
     if (dst && dst != generator.ignoredResult())
-        resultRegister = generator.emitNewArray(generator.newTemporary(), 0, 0);
+        resultRegister = generator.emitNewArray(generator.newTemporary(), nullptr, 0);
     if (m_targetPatterns.size() != elements.size())
         return nullptr;