Changeset 253335 in webkit for trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp

Timestamp:

Dec 10, 2019, 11:41:40 AM (6 years ago)

Author:

Tadeu Zagallo

Message:

Reduce JSC's binary size
​https://bugs.webkit.org/show_bug.cgi?id=204549

Reviewed by Saam Barati.

The Wasm interpreter landed in r251886 and significantly increased JSC's binary size. To try and
offset that, here and some easy fixes that get us ~200kb back:

• We were generating 2 instances of dumpBytecode, at 30kb each. I changed the generator to emit a cpp file instead, avoiding the duplication.
• We had 3 instances of computeUsesForBytecodeIndex at 11kb each. I kept the work that depended on the template type in the template function and moved the massive switch into computeUsesForBytecodeIndexImpl. I also did the same for computeDefsForBytecodeIndex.
• We had 8 instances of emit_compareAndJump(Slow) at 8kb (7kb for Slow) each. I kept the code that extracts the data from the bytecode in the template, but moved the bulk of the function into emit_compareAndJump(Slow)Impl.

• CMakeLists.txt:
• DerivedSources-output.xcfilelist:
• DerivedSources.make:
• Sources.txt:
• bytecode/BytecodeDumper.cpp:

(JSC::BytecodeDumperBase::printLocationAndOp):
(JSC::BytecodeDumperBase::dumpValue):

• bytecode/BytecodeDumper.h:

(JSC::BytecodeDumperBase::~BytecodeDumperBase):
(JSC::BytecodeDumperBase::dumpValue):
(JSC::BytecodeDumperBase::BytecodeDumperBase):
(JSC::BytecodeDumper::BytecodeDumper):

• bytecode/BytecodeUseDef.cpp: Copied from Source/JavaScriptCore/bytecode/BytecodeUseDef.h.

(JSC::computeUsesForBytecodeIndexImpl):
(JSC::computeDefsForBytecodeIndexImpl):

• bytecode/BytecodeUseDef.h:

(JSC::computeUsesForBytecodeIndex):
(JSC::computeDefsForBytecodeIndex):

• generator/DSL.rb:
• generator/Opcode.rb:
• generator/Options.rb:
• jit/JIT.h:
• jit/JITArithmetic.cpp:

(JSC::JIT::emit_compareAndJump):
(JSC::JIT::emit_compareAndJumpImpl):
(JSC::JIT::emit_compareUnsignedAndJump):
(JSC::JIT::emit_compareUnsignedAndJumpImpl):
(JSC::JIT::emit_compareUnsigned):
(JSC::JIT::emit_compareUnsignedImpl):
(JSC::JIT::emit_compareAndJumpSlow):
(JSC::JIT::emit_compareAndJumpSlowImpl):

File:

• trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp (modified) (8 diffs)

trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp

@@ -172 +172 @@
 void JIT::emit_compareAndJump(const Instruction* instruction, RelationalCondition condition)
 {
+    auto bytecode = instruction->as<Op>();
+    int op1 = bytecode.m_lhs.offset();
+    int op2 = bytecode.m_rhs.offset();
+    unsigned target = jumpTarget(instruction, bytecode.m_targetLabel);
+    emit_compareAndJumpImpl(op1, op2, target, condition);
+}
+
+void JIT::emit_compareAndJumpImpl(int op1, int op2, unsigned target, RelationalCondition condition)
+{
     // We generate inline code for the following cases in the fast path:
     // - int immediate to constant int immediate
@@ -177 +186 @@
     // - int immediate to int immediate
 
-    auto bytecode = instruction->as<Op>();
-    int op1 = bytecode.m_lhs.offset();
-    int op2 = bytecode.m_rhs.offset();
-    unsigned target = jumpTarget(instruction, bytecode.m_targetLabel);
     bool disallowAllocation = false;
     if (isOperandConstantChar(op1)) {
@@ -229 +234 @@
     int op2 = bytecode.m_rhs.offset();
     unsigned target = jumpTarget(instruction, bytecode.m_targetLabel);
+    emit_compareUnsignedAndJumpImpl(op1, op2, target, condition);
+}
+
+void JIT::emit_compareUnsignedAndJumpImpl(int op1, int op2, unsigned target, RelationalCondition condition)
+{
     if (isOperandConstantInt(op2)) {
         emitGetVirtualRegister(op1, regT0);
@@ -250 +260 @@
     int op1 = bytecode.m_lhs.offset();
     int op2 = bytecode.m_rhs.offset();
+    emit_compareUnsignedImpl(dst, op1, op2, condition);
+}
+
+void JIT::emit_compareUnsignedImpl(int dst, int op1, int op2, RelationalCondition condition)
+{
     if (isOperandConstantInt(op2)) {
         emitGetVirtualRegister(op1, regT0);
@@ -273 +288 @@
     int op2 = bytecode.m_rhs.offset();
     unsigned target = jumpTarget(instruction, bytecode.m_targetLabel);
+    emit_compareAndJumpSlowImpl(op1, op2, target, instruction->size(), condition, operation, invert, iter);
+}
+
+void JIT::emit_compareAndJumpSlowImpl(int op1, int op2, unsigned target, size_t instructionSize, DoubleCondition condition, size_t (JIT_OPERATION *operation)(JSGlobalObject*, EncodedJSValue, EncodedJSValue), bool invert, Vector<SlowCaseEntry>::iterator& iter)
+{
 
     // We generate inline code for the following cases in the slow path:
@@ -303 +323 @@
             emitJumpSlowToHot(branchDouble(condition, fpRegT0, fpRegT1), target);
 
-            emitJumpSlowToHot(jump(), instruction->size());
+            emitJumpSlowToHot(jump(), instructionSize);
 
             fail1.link(this);
@@ -329 +349 @@
             emitJumpSlowToHot(branchDouble(condition, fpRegT0, fpRegT1), target);
 
-            emitJumpSlowToHot(jump(), instruction->size());
+            emitJumpSlowToHot(jump(), instructionSize);
 
             fail1.link(this);
@@ -353 +373 @@
         emitJumpSlowToHot(branchDouble(condition, fpRegT0, fpRegT1), target);
 
-        emitJumpSlowToHot(jump(), instruction->size());
+        emitJumpSlowToHot(jump(), instructionSize);
 
         fail1.link(this);