Skip to content

Commit 8f40efa

Browse files
saambaratisaambarati
committed
op_mul/ArithMul(Untyped,Untyped) should be an IC
https://bugs.webkit.org/show_bug.cgi?id=160108 Reviewed by Mark Lam. This patch makes Mul a type based IC in much the same way that we made Add a type-based IC. I implemented Mul in the same way. I abstracted the implementation of the Add IC in the various JITs to allow for it to work over arbitrary IC snippets. This will make adding Div/Sub/Pow in the future easy. This patch also adds a new boolean argument to the various snippet generateFastPath() methods to indicate if we should emit result profiling. I added this because we want this profiling to be emitted for Mul in the baseline, but not in the DFG. We used to indicate this through passing in a nullptr for the ArithProfile, but we no longer do that in the upper JIT tiers. So we are passing an explicit request from the JIT tier about whether or not it's worth it for the IC to emit profiling. We now emit much less code for Mul. Here is some data on the average Mul snippet/IC size: | JetStream | Unity 3D | ------| -------------|-------------- Old | ~280 bytes | ~280 bytes | ------| -------------|-------------- New | 210 bytes | 185 bytes | ------------------------------------ * bytecode/CodeBlock.cpp: (JSC::CodeBlock::addJITAddIC): (JSC::CodeBlock::addJITMulIC): (JSC::CodeBlock::findStubInfo): * bytecode/CodeBlock.h: (JSC::CodeBlock::stubInfoBegin): (JSC::CodeBlock::stubInfoEnd): * dfg/DFGSpeculativeJIT.cpp: (JSC::DFG::GPRTemporary::adopt): (JSC::DFG::FPRTemporary::FPRTemporary): (JSC::DFG::SpeculativeJIT::compileValueAdd): (JSC::DFG::SpeculativeJIT::compileMathIC): (JSC::DFG::SpeculativeJIT::compileArithMul): * dfg/DFGSpeculativeJIT.h: (JSC::DFG::SpeculativeJIT::callOperation): (JSC::DFG::GPRTemporary::GPRTemporary): (JSC::DFG::GPRTemporary::operator=): (JSC::DFG::FPRTemporary::~FPRTemporary): (JSC::DFG::FPRTemporary::fpr): * ftl/FTLLowerDFGToB3.cpp: (JSC::FTL::DFG::LowerDFGToB3::compileToThis): (JSC::FTL::DFG::LowerDFGToB3::compileValueAdd): (JSC::FTL::DFG::LowerDFGToB3::compileMathIC): (JSC::FTL::DFG::LowerDFGToB3::compileArithMul): * jit/JIT.h: (JSC::JIT::getSlowCase): * jit/JITAddGenerator.cpp: (JSC::JITAddGenerator::generateInline): (JSC::JITAddGenerator::generateFastPath): * jit/JITAddGenerator.h: (JSC::JITAddGenerator::JITAddGenerator): (JSC::JITAddGenerator::isLeftOperandValidConstant): (JSC::JITAddGenerator::isRightOperandValidConstant): * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_add): (JSC::JIT::emitSlow_op_add): (JSC::JIT::emitMathICFast): (JSC::JIT::emitMathICSlow): (JSC::JIT::emit_op_mul): (JSC::JIT::emitSlow_op_mul): (JSC::JIT::emit_op_sub): * jit/JITInlines.h: (JSC::JIT::callOperation): * jit/JITMathIC.h: (JSC::JITMathIC::slowPathStartLocation): (JSC::JITMathIC::slowPathCallLocation): (JSC::JITMathIC::isLeftOperandValidConstant): (JSC::JITMathIC::isRightOperandValidConstant): (JSC::JITMathIC::generateInline): (JSC::JITMathIC::generateOutOfLine): * jit/JITMathICForwards.h: * jit/JITMulGenerator.cpp: (JSC::JITMulGenerator::generateInline): (JSC::JITMulGenerator::generateFastPath): * jit/JITMulGenerator.h: (JSC::JITMulGenerator::JITMulGenerator): (JSC::JITMulGenerator::isLeftOperandValidConstant): (JSC::JITMulGenerator::isRightOperandValidConstant): (JSC::JITMulGenerator::didEmitFastPath): Deleted. (JSC::JITMulGenerator::endJumpList): Deleted. (JSC::JITMulGenerator::slowPathJumpList): Deleted. * jit/JITOperations.cpp: * jit/JITOperations.h: Canonical link: https://commits.webkit.org/178322@main git-svn-id: https://svn.webkit.org/repository/webkit/trunk@203693 268f45cc-cd09-0410-ab3c-d52691b4dbfc
1 parent c05993c commit 8f40efa

17 files changed

Lines changed: 460 additions & 297 deletions

‎Source/JavaScriptCore/ChangeLog‎

Lines changed: 93 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,96 @@
1+
2016-07-25 Saam Barati <sbarati@apple.com>
2+
3+
op_mul/ArithMul(Untyped,Untyped) should be an IC
4+
https://bugs.webkit.org/show_bug.cgi?id=160108
5+
6+
Reviewed by Mark Lam.
7+
8+
This patch makes Mul a type based IC in much the same way that we made
9+
Add a type-based IC. I implemented Mul in the same way. I abstracted the
10+
implementation of the Add IC in the various JITs to allow for it to
11+
work over arbitrary IC snippets. This will make adding Div/Sub/Pow in the
12+
future easy. This patch also adds a new boolean argument to the various
13+
snippet generateFastPath() methods to indicate if we should emit result profiling.
14+
I added this because we want this profiling to be emitted for Mul in
15+
the baseline, but not in the DFG. We used to indicate this through passing
16+
in a nullptr for the ArithProfile, but we no longer do that in the upper
17+
JIT tiers. So we are passing an explicit request from the JIT tier about
18+
whether or not it's worth it for the IC to emit profiling.
19+
20+
We now emit much less code for Mul. Here is some data on the average
21+
Mul snippet/IC size:
22+
23+
| JetStream | Unity 3D |
24+
------| -------------|--------------
25+
Old | ~280 bytes | ~280 bytes |
26+
------| -------------|--------------
27+
New | 210 bytes | 185 bytes |
28+
------------------------------------
29+
30+
* bytecode/CodeBlock.cpp:
31+
(JSC::CodeBlock::addJITAddIC):
32+
(JSC::CodeBlock::addJITMulIC):
33+
(JSC::CodeBlock::findStubInfo):
34+
* bytecode/CodeBlock.h:
35+
(JSC::CodeBlock::stubInfoBegin):
36+
(JSC::CodeBlock::stubInfoEnd):
37+
* dfg/DFGSpeculativeJIT.cpp:
38+
(JSC::DFG::GPRTemporary::adopt):
39+
(JSC::DFG::FPRTemporary::FPRTemporary):
40+
(JSC::DFG::SpeculativeJIT::compileValueAdd):
41+
(JSC::DFG::SpeculativeJIT::compileMathIC):
42+
(JSC::DFG::SpeculativeJIT::compileArithMul):
43+
* dfg/DFGSpeculativeJIT.h:
44+
(JSC::DFG::SpeculativeJIT::callOperation):
45+
(JSC::DFG::GPRTemporary::GPRTemporary):
46+
(JSC::DFG::GPRTemporary::operator=):
47+
(JSC::DFG::FPRTemporary::~FPRTemporary):
48+
(JSC::DFG::FPRTemporary::fpr):
49+
* ftl/FTLLowerDFGToB3.cpp:
50+
(JSC::FTL::DFG::LowerDFGToB3::compileToThis):
51+
(JSC::FTL::DFG::LowerDFGToB3::compileValueAdd):
52+
(JSC::FTL::DFG::LowerDFGToB3::compileMathIC):
53+
(JSC::FTL::DFG::LowerDFGToB3::compileArithMul):
54+
* jit/JIT.h:
55+
(JSC::JIT::getSlowCase):
56+
* jit/JITAddGenerator.cpp:
57+
(JSC::JITAddGenerator::generateInline):
58+
(JSC::JITAddGenerator::generateFastPath):
59+
* jit/JITAddGenerator.h:
60+
(JSC::JITAddGenerator::JITAddGenerator):
61+
(JSC::JITAddGenerator::isLeftOperandValidConstant):
62+
(JSC::JITAddGenerator::isRightOperandValidConstant):
63+
* jit/JITArithmetic.cpp:
64+
(JSC::JIT::emit_op_add):
65+
(JSC::JIT::emitSlow_op_add):
66+
(JSC::JIT::emitMathICFast):
67+
(JSC::JIT::emitMathICSlow):
68+
(JSC::JIT::emit_op_mul):
69+
(JSC::JIT::emitSlow_op_mul):
70+
(JSC::JIT::emit_op_sub):
71+
* jit/JITInlines.h:
72+
(JSC::JIT::callOperation):
73+
* jit/JITMathIC.h:
74+
(JSC::JITMathIC::slowPathStartLocation):
75+
(JSC::JITMathIC::slowPathCallLocation):
76+
(JSC::JITMathIC::isLeftOperandValidConstant):
77+
(JSC::JITMathIC::isRightOperandValidConstant):
78+
(JSC::JITMathIC::generateInline):
79+
(JSC::JITMathIC::generateOutOfLine):
80+
* jit/JITMathICForwards.h:
81+
* jit/JITMulGenerator.cpp:
82+
(JSC::JITMulGenerator::generateInline):
83+
(JSC::JITMulGenerator::generateFastPath):
84+
* jit/JITMulGenerator.h:
85+
(JSC::JITMulGenerator::JITMulGenerator):
86+
(JSC::JITMulGenerator::isLeftOperandValidConstant):
87+
(JSC::JITMulGenerator::isRightOperandValidConstant):
88+
(JSC::JITMulGenerator::didEmitFastPath): Deleted.
89+
(JSC::JITMulGenerator::endJumpList): Deleted.
90+
(JSC::JITMulGenerator::slowPathJumpList): Deleted.
91+
* jit/JITOperations.cpp:
92+
* jit/JITOperations.h:
93+
194
2016-07-25 Darin Adler <darin@apple.com>
295

396
Speed up make process slightly by improving "list of files" idiom

‎Source/JavaScriptCore/bytecode/CodeBlock.cpp‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3013,6 +3013,11 @@ JITAddIC* CodeBlock::addJITAddIC()
30133013
return m_addICs.add();
30143014
}
30153015

3016+
JITMulIC* CodeBlock::addJITMulIC()
3017+
{
3018+
return m_mulICs.add();
3019+
}
3020+
30163021
StructureStubInfo* CodeBlock::findStubInfo(CodeOrigin codeOrigin)
30173022
{
30183023
for (StructureStubInfo* stubInfo : m_stubInfos) {

‎Source/JavaScriptCore/bytecode/CodeBlock.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -250,6 +250,7 @@ class CodeBlock : public JSCell {
250250
#if ENABLE(JIT)
251251
StructureStubInfo* addStubInfo(AccessType);
252252
JITAddIC* addJITAddIC();
253+
JITMulIC* addJITMulIC();
253254
Bag<StructureStubInfo>::iterator stubInfoBegin() { return m_stubInfos.begin(); }
254255
Bag<StructureStubInfo>::iterator stubInfoEnd() { return m_stubInfos.end(); }
255256

@@ -1014,6 +1015,7 @@ class CodeBlock : public JSCell {
10141015
std::unique_ptr<RegisterAtOffsetList> m_calleeSaveRegisters;
10151016
Bag<StructureStubInfo> m_stubInfos;
10161017
Bag<JITAddIC> m_addICs;
1018+
Bag<JITMulIC> m_mulICs;
10171019
Bag<ByValInfo> m_byValInfos;
10181020
Bag<CallLinkInfo> m_callLinkInfos;
10191021
SentinelLinkedList<CallLinkInfo, BasicRawSentinelNode<CallLinkInfo>> m_incomingCalls;

‎Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp‎

Lines changed: 69 additions & 89 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,6 @@
4444
#include "JITBitXorGenerator.h"
4545
#include "JITDivGenerator.h"
4646
#include "JITLeftShiftGenerator.h"
47-
#include "JITMathIC.h"
4847
#include "JITMulGenerator.h"
4948
#include "JITRightShiftGenerator.h"
5049
#include "JITSubGenerator.h"
@@ -1317,6 +1316,16 @@ void GPRTemporary::adopt(GPRTemporary& other)
13171316
other.m_gpr = InvalidGPRReg;
13181317
}
13191318

1319+
FPRTemporary::FPRTemporary(FPRTemporary&& other)
1320+
{
1321+
ASSERT(other.m_jit);
1322+
ASSERT(other.m_fpr != InvalidFPRReg);
1323+
m_jit = other.m_jit;
1324+
m_fpr = other.m_fpr;
1325+
1326+
other.m_jit = nullptr;
1327+
}
1328+
13201329
FPRTemporary::FPRTemporary(SpeculativeJIT* jit)
13211330
: m_jit(jit)
13221331
, m_fpr(InvalidFPRReg)
@@ -3336,6 +3345,27 @@ void SpeculativeJIT::compileValueAdd(Node* node)
33363345
return;
33373346
}
33383347

3348+
#if USE(JSVALUE64)
3349+
bool needsScratchGPRReg = true;
3350+
bool needsScratchFPRReg = false;
3351+
#else
3352+
bool needsScratchGPRReg = true;
3353+
bool needsScratchFPRReg = true;
3354+
#endif
3355+
3356+
JITAddIC* addIC = m_jit.codeBlock()->addJITAddIC();
3357+
auto repatchingFunction = operationValueAddOptimize;
3358+
auto nonRepatchingFunction = operationValueAdd;
3359+
3360+
compileMathIC(node, addIC, needsScratchGPRReg, needsScratchFPRReg, repatchingFunction, nonRepatchingFunction);
3361+
}
3362+
3363+
template <typename Generator, typename RepatchingFunction, typename NonRepatchingFunction>
3364+
void SpeculativeJIT::compileMathIC(Node* node, JITMathIC<Generator>* mathIC, bool needsScratchGPRReg, bool needsScratchFPRReg, RepatchingFunction repatchingFunction, NonRepatchingFunction nonRepatchingFunction)
3365+
{
3366+
Edge& leftChild = node->child1();
3367+
Edge& rightChild = node->child2();
3368+
33393369
Optional<JSValueOperand> left;
33403370
Optional<JSValueOperand> right;
33413371

@@ -3347,19 +3377,29 @@ void SpeculativeJIT::compileValueAdd(Node* node)
33473377
FPRReg leftFPR = leftNumber.fpr();
33483378
FPRReg rightFPR = rightNumber.fpr();
33493379

3380+
GPRReg scratchGPR = InvalidGPRReg;
3381+
FPRReg scratchFPR = InvalidFPRReg;
3382+
3383+
Optional<FPRTemporary> fprScratch;
3384+
if (needsScratchFPRReg) {
3385+
fprScratch = FPRTemporary(this);
3386+
scratchFPR = fprScratch->fpr();
3387+
}
3388+
33503389
#if USE(JSVALUE64)
3390+
Optional<GPRTemporary> gprScratch;
3391+
if (needsScratchGPRReg) {
3392+
gprScratch = GPRTemporary(this);
3393+
scratchGPR = gprScratch->gpr();
3394+
}
33513395
GPRTemporary result(this);
33523396
JSValueRegs resultRegs = JSValueRegs(result.gpr());
3353-
GPRTemporary scratch(this);
3354-
GPRReg scratchGPR = scratch.gpr();
3355-
FPRReg scratchFPR = InvalidFPRReg;
33563397
#else
33573398
GPRTemporary resultTag(this);
33583399
GPRTemporary resultPayload(this);
33593400
JSValueRegs resultRegs = JSValueRegs(resultPayload.gpr(), resultTag.gpr());
3360-
GPRReg scratchGPR = resultTag.gpr();
3361-
FPRTemporary fprScratch(this);
3362-
FPRReg scratchFPR = fprScratch.fpr();
3401+
if (needsScratchGPRReg)
3402+
scratchGPR = resultRegs.tagGPR();
33633403
#endif
33643404

33653405
SnippetOperand leftOperand(m_state.forNode(leftChild).resultType());
@@ -3374,21 +3414,21 @@ void SpeculativeJIT::compileValueAdd(Node* node)
33743414

33753415
ASSERT(!leftOperand.isConst() || !rightOperand.isConst());
33763416

3377-
if (!leftOperand.isConst()) {
3417+
if (!mathIC->isLeftOperandValidConstant()) {
33783418
left = JSValueOperand(this, leftChild);
33793419
leftRegs = left->jsValueRegs();
33803420
}
3381-
if (!rightOperand.isConst()) {
3421+
if (!mathIC->isRightOperandValidConstant()) {
33823422
right = JSValueOperand(this, rightChild);
33833423
rightRegs = right->jsValueRegs();
33843424
}
33853425

3386-
JITAddIC* addIC = m_jit.codeBlock()->addJITAddIC();
33873426
Box<MathICGenerationState> addICGenerationState = Box<MathICGenerationState>::create();
33883427
ArithProfile* arithProfile = m_jit.graph().baselineCodeBlockFor(node->origin.semantic)->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
3389-
addIC->m_generator = JITAddGenerator(leftOperand, rightOperand, resultRegs, leftRegs, rightRegs, leftFPR, rightFPR, scratchGPR, scratchFPR, arithProfile);
3428+
mathIC->m_generator = Generator(leftOperand, rightOperand, resultRegs, leftRegs, rightRegs, leftFPR, rightFPR, scratchGPR, scratchFPR, arithProfile);
33903429

3391-
bool generatedInline = addIC->generateInline(m_jit, *addICGenerationState);
3430+
bool shouldEmitProfiling = false;
3431+
bool generatedInline = mathIC->generateInline(m_jit, *addICGenerationState, shouldEmitProfiling);
33923432

33933433
if (generatedInline) {
33943434
ASSERT(!addICGenerationState->slowPathJumps.empty());
@@ -3406,38 +3446,38 @@ void SpeculativeJIT::compileValueAdd(Node* node)
34063446

34073447
auto innerLeftRegs = leftRegs;
34083448
auto innerRightRegs = rightRegs;
3409-
if (leftOperand.isConst()) {
3449+
if (mathIC->isLeftOperandValidConstant()) {
34103450
innerLeftRegs = resultRegs;
34113451
m_jit.moveValue(leftChild->asJSValue(), innerLeftRegs);
3412-
} else if (rightOperand.isConst()) {
3452+
} else if (mathIC->isRightOperandValidConstant()) {
34133453
innerRightRegs = resultRegs;
34143454
m_jit.moveValue(rightChild->asJSValue(), innerRightRegs);
34153455
}
34163456

34173457
if (addICGenerationState->shouldSlowPathRepatch)
3418-
addICGenerationState->slowPathCall = callOperation(operationValueAddOptimize, resultRegs, innerLeftRegs, innerRightRegs, TrustedImmPtr(addIC));
3458+
addICGenerationState->slowPathCall = callOperation(bitwise_cast<J_JITOperation_EJJMic>(repatchingFunction), resultRegs, innerLeftRegs, innerRightRegs, TrustedImmPtr(mathIC));
34193459
else
3420-
addICGenerationState->slowPathCall = callOperation(operationValueAdd, resultRegs, innerLeftRegs, innerRightRegs);
3460+
addICGenerationState->slowPathCall = callOperation(nonRepatchingFunction, resultRegs, innerLeftRegs, innerRightRegs);
34213461

34223462
silentFill(savePlans);
34233463
m_jit.exceptionCheck();
34243464
m_jit.jump().linkTo(done, &m_jit);
34253465

34263466
m_jit.addLinkTask([=] (LinkBuffer& linkBuffer) {
3427-
addIC->finalizeInlineCode(*addICGenerationState, linkBuffer);
3467+
mathIC->finalizeInlineCode(*addICGenerationState, linkBuffer);
34283468
});
34293469
});
34303470
} else {
3431-
if (leftOperand.isConst()) {
3471+
if (mathIC->isLeftOperandValidConstant()) {
34323472
left = JSValueOperand(this, leftChild);
34333473
leftRegs = left->jsValueRegs();
3434-
} else if (rightOperand.isConst()) {
3474+
} else if (mathIC->isRightOperandValidConstant()) {
34353475
right = JSValueOperand(this, rightChild);
34363476
rightRegs = right->jsValueRegs();
34373477
}
34383478

34393479
flushRegisters();
3440-
callOperation(operationValueAdd, resultRegs, leftRegs, rightRegs);
3480+
callOperation(nonRepatchingFunction, resultRegs, leftRegs, rightRegs);
34413481
m_jit.exceptionCheck();
34423482
}
34433483

@@ -4156,78 +4196,18 @@ void SpeculativeJIT::compileArithMul(Node* node)
41564196
return;
41574197
}
41584198

4159-
Optional<JSValueOperand> left;
4160-
Optional<JSValueOperand> right;
4161-
4162-
JSValueRegs leftRegs;
4163-
JSValueRegs rightRegs;
4164-
4165-
FPRTemporary leftNumber(this);
4166-
FPRTemporary rightNumber(this);
4167-
FPRReg leftFPR = leftNumber.fpr();
4168-
FPRReg rightFPR = rightNumber.fpr();
4169-
41704199
#if USE(JSVALUE64)
4171-
GPRTemporary result(this);
4172-
JSValueRegs resultRegs = JSValueRegs(result.gpr());
4173-
GPRTemporary scratch(this);
4174-
GPRReg scratchGPR = scratch.gpr();
4175-
FPRReg scratchFPR = InvalidFPRReg;
4200+
bool needsScratchGPRReg = true;
4201+
bool needsScratchFPRReg = false;
41764202
#else
4177-
GPRTemporary resultTag(this);
4178-
GPRTemporary resultPayload(this);
4179-
JSValueRegs resultRegs = JSValueRegs(resultPayload.gpr(), resultTag.gpr());
4180-
GPRReg scratchGPR = resultTag.gpr();
4181-
FPRTemporary fprScratch(this);
4182-
FPRReg scratchFPR = fprScratch.fpr();
4203+
bool needsScratchGPRReg = true;
4204+
bool needsScratchFPRReg = true;
41834205
#endif
4184-
4185-
SnippetOperand leftOperand(m_state.forNode(leftChild).resultType());
4186-
SnippetOperand rightOperand(m_state.forNode(rightChild).resultType());
4187-
4188-
// The snippet generator does not support both operands being constant. If the left
4189-
// operand is already const, we'll ignore the right operand's constness.
4190-
if (leftChild->isInt32Constant())
4191-
leftOperand.setConstInt32(leftChild->asInt32());
4192-
else if (rightChild->isInt32Constant())
4193-
rightOperand.setConstInt32(rightChild->asInt32());
4194-
4195-
ASSERT(!leftOperand.isConst() || !rightOperand.isConst());
4196-
4197-
if (!leftOperand.isPositiveConstInt32()) {
4198-
left = JSValueOperand(this, leftChild);
4199-
leftRegs = left->jsValueRegs();
4200-
}
4201-
if (!rightOperand.isPositiveConstInt32()) {
4202-
right = JSValueOperand(this, rightChild);
4203-
rightRegs = right->jsValueRegs();
4204-
}
4205-
4206-
JITMulGenerator gen(leftOperand, rightOperand, resultRegs, leftRegs, rightRegs,
4207-
leftFPR, rightFPR, scratchGPR, scratchFPR);
4208-
gen.generateFastPath(m_jit);
4209-
4210-
ASSERT(gen.didEmitFastPath());
4211-
gen.endJumpList().append(m_jit.jump());
4212-
4213-
gen.slowPathJumpList().link(&m_jit);
4214-
silentSpillAllRegisters(resultRegs);
4215-
4216-
if (leftOperand.isPositiveConstInt32()) {
4217-
leftRegs = resultRegs;
4218-
m_jit.moveValue(leftChild->asJSValue(), leftRegs);
4219-
} else if (rightOperand.isPositiveConstInt32()) {
4220-
rightRegs = resultRegs;
4221-
m_jit.moveValue(rightChild->asJSValue(), rightRegs);
4222-
}
4223-
4224-
callOperation(operationValueMul, resultRegs, leftRegs, rightRegs);
4225-
4226-
silentFillAllRegisters(resultRegs);
4227-
m_jit.exceptionCheck();
4228-
4229-
gen.endJumpList().link(&m_jit);
4230-
jsValueResult(resultRegs, node);
4206+
JITMulIC* mulIC = m_jit.codeBlock()->addJITMulIC();
4207+
auto repatchingFunction = operationValueMulOptimize;
4208+
auto nonRepatchingFunction = operationValueMul;
4209+
4210+
compileMathIC(node, mulIC, needsScratchGPRReg, needsScratchFPRReg, repatchingFunction, nonRepatchingFunction);
42314211
return;
42324212
}
42334213

0 commit comments

Comments
 (0)