https://bugs.webkit.org/show_bug.cgi?id=63218
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGSpeculativeJIT.cpp
1 /*
2  * Copyright (C) 2011 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "DFGSpeculativeJIT.h"
28
29 #if ENABLE(DFG_JIT)
30
31 namespace JSC { namespace DFG {
32
33 template<bool strict>
34 GPRReg SpeculativeJIT::fillSpeculateIntInternal(NodeIndex nodeIndex, DataFormat& returnFormat)
35 {
36     Node& node = m_jit.graph()[nodeIndex];
37     VirtualRegister virtualRegister = node.virtualRegister();
38     GenerationInfo& info = m_generationInfo[virtualRegister];
39
40     switch (info.registerFormat()) {
41     case DataFormatNone: {
42         GPRReg gpr = allocate();
43
44         if (node.isConstant()) {
45             m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
46             if (isInt32Constant(nodeIndex)) {
47                 m_jit.move(MacroAssembler::Imm32(valueOfInt32Constant(nodeIndex)), gpr);
48                 info.fillInteger(gpr);
49                 returnFormat = DataFormatInteger;
50                 return gpr;
51             }
52             m_jit.move(valueOfJSConstantAsImmPtr(nodeIndex), gpr);
53         } else {
54             DataFormat spillFormat = info.spillFormat();
55             ASSERT(spillFormat & DataFormatJS);
56
57             m_gprs.retain(gpr, virtualRegister, SpillOrderSpilled);
58
59             if (spillFormat == DataFormatJSInteger) {
60                 // If we know this was spilled as an integer we can fill without checking.
61                 if (strict) {
62                     m_jit.load32(JITCompiler::addressFor(virtualRegister), gpr);
63                     info.fillInteger(gpr);
64                     returnFormat = DataFormatInteger;
65                     return gpr;
66                 }
67                 m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), gpr);
68                 info.fillJSValue(gpr, DataFormatJSInteger);
69                 returnFormat = DataFormatJSInteger;
70                 return gpr;
71             }
72             m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), gpr);
73         }
74
75         // Fill as JSValue, and fall through.
76         info.fillJSValue(gpr, DataFormatJSInteger);
77         m_gprs.unlock(gpr);
78     }
79
80     case DataFormatJS: {
81         // Check the value is an integer.
82         GPRReg gpr = info.gpr();
83         m_gprs.lock(gpr);
84         speculationCheck(m_jit.branchPtr(MacroAssembler::Below, gpr, GPRInfo::tagTypeNumberRegister));
85         info.fillJSValue(gpr, DataFormatJSInteger);
86         // If !strict we're done, return.
87         if (!strict) {
88             returnFormat = DataFormatJSInteger;
89             return gpr;
90         }
91         // else fall through & handle as DataFormatJSInteger.
92         m_gprs.unlock(gpr);
93     }
94
95     case DataFormatJSInteger: {
96         // In a strict fill we need to strip off the value tag.
97         if (strict) {
98             GPRReg gpr = info.gpr();
99             GPRReg result;
100             // If the register has already been locked we need to take a copy.
101             // If not, we'll zero extend in place, so mark on the info that this is now type DataFormatInteger, not DataFormatJSInteger.
102             if (m_gprs.isLocked(gpr))
103                 result = allocate();
104             else {
105                 m_gprs.lock(gpr);
106                 info.fillInteger(gpr);
107                 result = gpr;
108             }
109             m_jit.zeroExtend32ToPtr(gpr, result);
110             returnFormat = DataFormatInteger;
111             return result;
112         }
113
114         GPRReg gpr = info.gpr();
115         m_gprs.lock(gpr);
116         returnFormat = DataFormatJSInteger;
117         return gpr;
118     }
119
120     case DataFormatInteger: {
121         GPRReg gpr = info.gpr();
122         m_gprs.lock(gpr);
123         returnFormat = DataFormatInteger;
124         return gpr;
125     }
126
127     case DataFormatDouble:
128     case DataFormatCell:
129     case DataFormatJSDouble:
130     case DataFormatJSCell: {
131         terminateSpeculativeExecution();
132         returnFormat = DataFormatInteger;
133         return allocate();
134     }
135     }
136
137     ASSERT_NOT_REACHED();
138     return InvalidGPRReg;
139 }
140
141 SpeculationCheck::SpeculationCheck(MacroAssembler::Jump check, SpeculativeJIT* jit, unsigned recoveryIndex)
142     : m_check(check)
143     , m_nodeIndex(jit->m_compileIndex)
144     , m_recoveryIndex(recoveryIndex)
145 {
146     for (gpr_iterator iter = jit->m_gprs.begin(); iter != jit->m_gprs.end(); ++iter) {
147         if (iter.name() != InvalidVirtualRegister) {
148             GenerationInfo& info =  jit->m_generationInfo[iter.name()];
149             m_gprInfo[iter.index()].nodeIndex = info.nodeIndex();
150             m_gprInfo[iter.index()].format = info.registerFormat();
151         } else
152             m_gprInfo[iter.index()].nodeIndex = NoNode;
153     }
154     for (fpr_iterator iter = jit->m_fprs.begin(); iter != jit->m_fprs.end(); ++iter) {
155         if (iter.name() != InvalidVirtualRegister) {
156             GenerationInfo& info =  jit->m_generationInfo[iter.name()];
157             ASSERT(info.registerFormat() == DataFormatDouble);
158             m_fprInfo[iter.index()] = info.nodeIndex();
159         } else
160             m_fprInfo[iter.index()] = NoNode;
161     }
162 }
163
164 GPRReg SpeculativeJIT::fillSpeculateInt(NodeIndex nodeIndex, DataFormat& returnFormat)
165 {
166     return fillSpeculateIntInternal<false>(nodeIndex, returnFormat);
167 }
168
169 GPRReg SpeculativeJIT::fillSpeculateIntStrict(NodeIndex nodeIndex)
170 {
171     DataFormat mustBeDataFormatInteger;
172     GPRReg result = fillSpeculateIntInternal<true>(nodeIndex, mustBeDataFormatInteger);
173     ASSERT(mustBeDataFormatInteger == DataFormatInteger);
174     return result;
175 }
176
177 GPRReg SpeculativeJIT::fillSpeculateCell(NodeIndex nodeIndex)
178 {
179     Node& node = m_jit.graph()[nodeIndex];
180     VirtualRegister virtualRegister = node.virtualRegister();
181     GenerationInfo& info = m_generationInfo[virtualRegister];
182
183     switch (info.registerFormat()) {
184     case DataFormatNone: {
185         GPRReg gpr = allocate();
186
187         if (node.isConstant()) {
188             JSValue jsValue = valueOfJSConstant(nodeIndex);
189             if (jsValue.isCell()) {
190                 m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
191                 m_jit.move(MacroAssembler::TrustedImmPtr(jsValue.asCell()), gpr);
192                 info.fillJSValue(gpr, DataFormatJSCell);
193                 return gpr;
194             }
195             terminateSpeculativeExecution();
196             return gpr;
197         }
198         ASSERT(info.spillFormat() & DataFormatJS);
199         m_gprs.retain(gpr, virtualRegister, SpillOrderSpilled);
200         m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), gpr);
201
202         if (info.spillFormat() != DataFormatJSCell)
203             speculationCheck(m_jit.branchTestPtr(MacroAssembler::NonZero, gpr, GPRInfo::tagMaskRegister));
204         info.fillJSValue(gpr, DataFormatJSCell);
205         return gpr;
206     }
207
208     case DataFormatCell:
209     case DataFormatJSCell: {
210         GPRReg gpr = info.gpr();
211         m_gprs.lock(gpr);
212         return gpr;
213     }
214
215     case DataFormatJS: {
216         GPRReg gpr = info.gpr();
217         m_gprs.lock(gpr);
218         speculationCheck(m_jit.branchTestPtr(MacroAssembler::NonZero, gpr, GPRInfo::tagMaskRegister));
219         info.fillJSValue(gpr, DataFormatJSCell);
220         return gpr;
221     }
222
223     case DataFormatJSInteger:
224     case DataFormatInteger:
225     case DataFormatJSDouble:
226     case DataFormatDouble: {
227         terminateSpeculativeExecution();
228         return allocate();
229     }
230     }
231
232     ASSERT_NOT_REACHED();
233     return InvalidGPRReg;
234 }
235
236 void SpeculativeJIT::compilePeepHoleIntegerBranch(Node& node, NodeIndex branchNodeIndex, JITCompiler::RelationalCondition condition)
237 {
238     Node& branchNode = m_jit.graph()[branchNodeIndex];
239     BlockIndex taken = m_jit.graph().blockIndexForBytecodeOffset(branchNode.takenBytecodeOffset());
240     BlockIndex notTaken = m_jit.graph().blockIndexForBytecodeOffset(branchNode.notTakenBytecodeOffset());
241
242     // The branch instruction will branch to the taken block.
243     // If taken is next, switch taken with notTaken & invert the branch condition so we can fall through.
244     if (taken == (m_block + 1)) {
245         condition = JITCompiler::invert(condition);
246         BlockIndex tmp = taken;
247         taken = notTaken;
248         notTaken = tmp;
249     }
250
251     if (isInt32Constant(node.child1)) {
252         int32_t imm = valueOfInt32Constant(node.child1);
253         SpeculateIntegerOperand op2(this, node.child2);
254         addBranch(m_jit.branch32(condition, JITCompiler::Imm32(imm), op2.gpr()), taken);
255     } else if (isInt32Constant(node.child2)) {
256         SpeculateIntegerOperand op1(this, node.child1);
257         int32_t imm = valueOfInt32Constant(node.child2);
258         addBranch(m_jit.branch32(condition, op1.gpr(), JITCompiler::Imm32(imm)), taken);
259     } else {
260         SpeculateIntegerOperand op1(this, node.child1);
261         SpeculateIntegerOperand op2(this, node.child2);
262         addBranch(m_jit.branch32(condition, op1.gpr(), op2.gpr()), taken);
263     }
264
265     // Check for fall through, otherwise we need to jump.
266     if (notTaken != (m_block + 1))
267         addBranch(m_jit.jump(), notTaken);
268 }
269
270 void SpeculativeJIT::compilePeepHoleEq(Node& node, NodeIndex branchNodeIndex)
271 {
272     Node& branchNode = m_jit.graph()[branchNodeIndex];
273     BlockIndex taken = m_jit.graph().blockIndexForBytecodeOffset(branchNode.takenBytecodeOffset());
274     BlockIndex notTaken = m_jit.graph().blockIndexForBytecodeOffset(branchNode.notTakenBytecodeOffset());
275
276     // The branch instruction will branch to the taken block.
277     // If taken is next, switch taken with notTaken & invert the branch condition so we can fall through.
278     JITCompiler::ResultCondition condition = JITCompiler::NonZero;
279     if (taken == (m_block + 1)) {
280         condition = JITCompiler::Zero;
281         BlockIndex tmp = taken;
282         taken = notTaken;
283         notTaken = tmp;
284     }
285
286     JSValueOperand op1(this, node.child1);
287     JSValueOperand op2(this, node.child2);
288     GPRReg op1GPR = op1.gpr();
289     GPRReg op2GPR = op2.gpr();
290     flushRegisters();
291
292     GPRResult result(this);
293     callOperation(operationCompareEq, result.gpr(), op1GPR, op2GPR);
294     addBranch(m_jit.branchTest8(condition, result.gpr()), taken);
295
296     // Check for fall through, otherwise we need to jump.
297     if (notTaken != (m_block + 1))
298         addBranch(m_jit.jump(), notTaken);
299 }
300
301 void SpeculativeJIT::compile(Node& node)
302 {
303     NodeType op = node.op;
304
305     switch (op) {
306     case JSConstant:
307         initConstantInfo(m_compileIndex);
308         break;
309
310     case GetLocal: {
311         GPRTemporary result(this);
312         PredictedType prediction = m_jit.graph().getPrediction(node.local());
313         if (prediction == PredictInt32) {
314             m_jit.load32(JITCompiler::payloadFor(node.local()), result.gpr());
315
316             // Like integerResult, but don't useChildren - our children are phi nodes,
317             // and don't represent values within this dataflow with virtual registers.
318             VirtualRegister virtualRegister = node.virtualRegister();
319             m_gprs.retain(result.gpr(), virtualRegister, SpillOrderInteger);
320             m_generationInfo[virtualRegister].initInteger(m_compileIndex, node.refCount(), result.gpr());
321         } else {
322             m_jit.loadPtr(JITCompiler::addressFor(node.local()), result.gpr());
323
324             // Like jsValueResult, but don't useChildren - our children are phi nodes,
325             // and don't represent values within this dataflow with virtual registers.
326             VirtualRegister virtualRegister = node.virtualRegister();
327             m_gprs.retain(result.gpr(), virtualRegister, SpillOrderJS);
328             m_generationInfo[virtualRegister].initJSValue(m_compileIndex, node.refCount(), result.gpr(), (prediction == PredictArray) ? DataFormatJSCell : DataFormatJS);
329         }
330         break;
331     }
332
333     case SetLocal: {
334         switch (m_jit.graph().getPrediction(node.local())) {
335         case PredictInt32: {
336             SpeculateIntegerOperand value(this, node.child1);
337             m_jit.store32(value.gpr(), JITCompiler::payloadFor(node.local()));
338             noResult(m_compileIndex);
339             break;
340         }
341         case PredictArray: {
342             SpeculateCellOperand cell(this, node.child1);
343             m_jit.storePtr(cell.gpr(), JITCompiler::addressFor(node.local()));
344             noResult(m_compileIndex);
345             break;
346         }
347
348         default: {
349             JSValueOperand value(this, node.child1);
350             m_jit.storePtr(value.gpr(), JITCompiler::addressFor(node.local()));
351             noResult(m_compileIndex);
352             break;
353         }
354         }
355         break;
356     }
357
358     case BitAnd:
359     case BitOr:
360     case BitXor:
361         if (isInt32Constant(node.child1)) {
362             SpeculateIntegerOperand op2(this, node.child2);
363             GPRTemporary result(this, op2);
364
365             bitOp(op, valueOfInt32Constant(node.child1), op2.gpr(), result.gpr());
366
367             integerResult(result.gpr(), m_compileIndex);
368         } else if (isInt32Constant(node.child2)) {
369             SpeculateIntegerOperand op1(this, node.child1);
370             GPRTemporary result(this, op1);
371
372             bitOp(op, valueOfInt32Constant(node.child2), op1.gpr(), result.gpr());
373
374             integerResult(result.gpr(), m_compileIndex);
375         } else {
376             SpeculateIntegerOperand op1(this, node.child1);
377             SpeculateIntegerOperand op2(this, node.child2);
378             GPRTemporary result(this, op1, op2);
379
380             GPRReg reg1 = op1.gpr();
381             GPRReg reg2 = op2.gpr();
382             bitOp(op, reg1, reg2, result.gpr());
383
384             integerResult(result.gpr(), m_compileIndex);
385         }
386         break;
387
388     case BitRShift:
389     case BitLShift:
390     case BitURShift:
391         if (isInt32Constant(node.child2)) {
392             SpeculateIntegerOperand op1(this, node.child1);
393             GPRTemporary result(this, op1);
394
395             shiftOp(op, op1.gpr(), valueOfInt32Constant(node.child2) & 0x1f, result.gpr());
396
397             integerResult(result.gpr(), m_compileIndex);
398         } else {
399             // Do not allow shift amount to be used as the result, MacroAssembler does not permit this.
400             SpeculateIntegerOperand op1(this, node.child1);
401             SpeculateIntegerOperand op2(this, node.child2);
402             GPRTemporary result(this, op1);
403
404             GPRReg reg1 = op1.gpr();
405             GPRReg reg2 = op2.gpr();
406             shiftOp(op, reg1, reg2, result.gpr());
407
408             integerResult(result.gpr(), m_compileIndex);
409         }
410         break;
411
412     case UInt32ToNumber: {
413         IntegerOperand op1(this, node.child1);
414         GPRTemporary result(this, op1);
415
416         // Test the operand is positive.
417         speculationCheck(m_jit.branch32(MacroAssembler::LessThan, op1.gpr(), TrustedImm32(0)));
418
419         m_jit.move(op1.gpr(), result.gpr());
420         integerResult(result.gpr(), m_compileIndex, op1.format());
421         break;
422     }
423
424     case ValueToInt32: {
425         SpeculateIntegerOperand op1(this, node.child1);
426         GPRTemporary result(this, op1);
427         m_jit.move(op1.gpr(), result.gpr());
428         integerResult(result.gpr(), m_compileIndex, op1.format());
429         break;
430     }
431
432     case ValueToNumber: {
433         SpeculateIntegerOperand op1(this, node.child1);
434         GPRTemporary result(this, op1);
435         m_jit.move(op1.gpr(), result.gpr());
436         integerResult(result.gpr(), m_compileIndex, op1.format());
437         break;
438     }
439
440     case ValueAdd:
441     case ArithAdd: {
442         if (isInt32Constant(node.child1)) {
443             int32_t imm1 = valueOfInt32Constant(node.child1);
444             SpeculateIntegerOperand op2(this, node.child2);
445             GPRTemporary result(this);
446
447             speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, op2.gpr(), Imm32(imm1), result.gpr()));
448
449             integerResult(result.gpr(), m_compileIndex);
450             break;
451         }
452             
453         if (isInt32Constant(node.child2)) {
454             SpeculateIntegerOperand op1(this, node.child1);
455             int32_t imm2 = valueOfInt32Constant(node.child2);
456             GPRTemporary result(this);
457
458             speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, op1.gpr(), Imm32(imm2), result.gpr()));
459
460             integerResult(result.gpr(), m_compileIndex);
461             break;
462         }
463             
464         SpeculateIntegerOperand op1(this, node.child1);
465         SpeculateIntegerOperand op2(this, node.child2);
466         GPRTemporary result(this, op1, op2);
467
468         GPRReg gpr1 = op1.gpr();
469         GPRReg gpr2 = op2.gpr();
470         GPRReg gprResult = result.gpr();
471         MacroAssembler::Jump check = m_jit.branchAdd32(MacroAssembler::Overflow, gpr1, gpr2, gprResult);
472
473         if (gpr1 == gprResult)
474             speculationCheck(check, SpeculationRecovery(SpeculativeAdd, gprResult, gpr2));
475         else if (gpr2 == gprResult)
476             speculationCheck(check, SpeculationRecovery(SpeculativeAdd, gprResult, gpr1));
477         else
478             speculationCheck(check);
479
480         integerResult(gprResult, m_compileIndex);
481         break;
482     }
483
484     case ArithSub: {
485         if (isInt32Constant(node.child2)) {
486             SpeculateIntegerOperand op1(this, node.child1);
487             int32_t imm2 = valueOfInt32Constant(node.child2);
488             GPRTemporary result(this);
489
490             speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, op1.gpr(), Imm32(imm2), result.gpr()));
491
492             integerResult(result.gpr(), m_compileIndex);
493             break;
494         }
495             
496         SpeculateIntegerOperand op1(this, node.child1);
497         SpeculateIntegerOperand op2(this, node.child2);
498         GPRTemporary result(this);
499
500         speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, op1.gpr(), op2.gpr(), result.gpr()));
501
502         integerResult(result.gpr(), m_compileIndex);
503         break;
504     }
505
506     case ArithMul: {
507         SpeculateIntegerOperand op1(this, node.child1);
508         SpeculateIntegerOperand op2(this, node.child2);
509         GPRTemporary result(this);
510
511         GPRReg reg1 = op1.gpr();
512         GPRReg reg2 = op2.gpr();
513         speculationCheck(m_jit.branchMul32(MacroAssembler::Overflow, reg1, reg2, result.gpr()));
514
515         MacroAssembler::Jump resultNonZero = m_jit.branchTest32(MacroAssembler::NonZero, result.gpr());
516         speculationCheck(m_jit.branch32(MacroAssembler::LessThan, reg1, TrustedImm32(0)));
517         speculationCheck(m_jit.branch32(MacroAssembler::LessThan, reg2, TrustedImm32(0)));
518         resultNonZero.link(&m_jit);
519
520         integerResult(result.gpr(), m_compileIndex);
521         break;
522     }
523
524     case ArithDiv: {
525         SpeculateIntegerOperand op1(this, node.child1);
526         SpeculateIntegerOperand op2(this, node.child2);
527         GPRTemporary result(this, op1, op2);
528
529         op1.gpr();
530         op2.gpr();
531         terminateSpeculativeExecution();
532
533         integerResult(result.gpr(), m_compileIndex);
534         break;
535     }
536
537     case ArithMod: {
538         SpeculateIntegerOperand op1(this, node.child1);
539         SpeculateIntegerOperand op2(this, node.child2);
540         GPRTemporary result(this, op1, op2);
541
542         op1.gpr();
543         op2.gpr();
544         terminateSpeculativeExecution();
545
546         integerResult(result.gpr(), m_compileIndex);
547         break;
548     }
549
550     case LogicalNot: {
551         JSValueOperand value(this, node.child1);
552         GPRTemporary result(this); // FIXME: We could reuse, but on speculation fail would need recovery to restore tag (akin to add).
553
554         m_jit.move(value.gpr(), result.gpr());
555         m_jit.xorPtr(TrustedImm32(static_cast<int32_t>(ValueFalse)), result.gpr());
556         speculationCheck(m_jit.branchTestPtr(JITCompiler::NonZero, result.gpr(), TrustedImm32(static_cast<int32_t>(~1))));
557         m_jit.xorPtr(TrustedImm32(static_cast<int32_t>(ValueTrue)), result.gpr());
558
559         // If we add a DataFormatBool, we should use it here.
560         jsValueResult(result.gpr(), m_compileIndex);
561         break;
562     }
563
564     case CompareLess: {
565         // Fused compare & branch.
566         NodeIndex branchNodeIndex = detectPeepHoleBranch();
567         if (branchNodeIndex != NoNode) {
568             // detectPeepHoleBranch currently only permits the branch to be the very next node,
569             // so can be no intervening nodes to also reference the compare. 
570             ASSERT(node.adjustedRefCount() == 1);
571
572             compilePeepHoleIntegerBranch(node, branchNodeIndex, JITCompiler::LessThan);
573
574             use(node.child1);
575             use(node.child2);
576             m_compileIndex = branchNodeIndex;
577             return;
578         }
579
580         // Normal case, not fused to branch.
581         SpeculateIntegerOperand op1(this, node.child1);
582         SpeculateIntegerOperand op2(this, node.child2);
583         GPRTemporary result(this, op1, op2);
584
585         m_jit.compare32(JITCompiler::LessThan, op1.gpr(), op2.gpr(), result.gpr());
586
587         // If we add a DataFormatBool, we should use it here.
588         m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
589         jsValueResult(result.gpr(), m_compileIndex);
590         break;
591     }
592
593     case CompareLessEq: {
594         // Fused compare & branch.
595         NodeIndex branchNodeIndex = detectPeepHoleBranch();
596         if (branchNodeIndex != NoNode) {
597             // detectPeepHoleBranch currently only permits the branch to be the very next node,
598             // so can be no intervening nodes to also reference the compare. 
599             ASSERT(node.adjustedRefCount() == 1);
600
601             compilePeepHoleIntegerBranch(node, branchNodeIndex, JITCompiler::LessThanOrEqual);
602
603             use(node.child1);
604             use(node.child2);
605             m_compileIndex = branchNodeIndex;
606             return;
607         }
608
609         // Normal case, not fused to branch.
610         SpeculateIntegerOperand op1(this, node.child1);
611         SpeculateIntegerOperand op2(this, node.child2);
612         GPRTemporary result(this, op1, op2);
613
614         m_jit.compare32(JITCompiler::LessThanOrEqual, op1.gpr(), op2.gpr(), result.gpr());
615
616         // If we add a DataFormatBool, we should use it here.
617         m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
618         jsValueResult(result.gpr(), m_compileIndex);
619         break;
620     }
621
622     case CompareEq: {
623         // Fused compare & branch.
624         NodeIndex branchNodeIndex = detectPeepHoleBranch();
625         if (branchNodeIndex != NoNode) {
626             // detectPeepHoleBranch currently only permits the branch to be the very next node,
627             // so can be no intervening nodes to also reference the compare. 
628             ASSERT(node.adjustedRefCount() == 1);
629
630             if (isInteger(node.child1) || isInteger(node.child2))
631                 compilePeepHoleIntegerBranch(node, branchNodeIndex, JITCompiler::Equal);
632             else
633                 compilePeepHoleEq(node, branchNodeIndex);
634
635             use(node.child1);
636             use(node.child2);
637             m_compileIndex = branchNodeIndex;
638             return;
639         }
640
641         SpeculateIntegerOperand op1(this, node.child1);
642         SpeculateIntegerOperand op2(this, node.child2);
643         GPRTemporary result(this, op1, op2);
644
645         m_jit.compare32(JITCompiler::Equal, op1.gpr(), op2.gpr(), result.gpr());
646
647         // If we add a DataFormatBool, we should use it here.
648         m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
649         jsValueResult(result.gpr(), m_compileIndex);
650         break;
651     }
652
653     case CompareStrictEq: {
654         SpeculateIntegerOperand op1(this, node.child1);
655         SpeculateIntegerOperand op2(this, node.child2);
656         GPRTemporary result(this, op1, op2);
657
658         m_jit.compare32(JITCompiler::Equal, op1.gpr(), op2.gpr(), result.gpr());
659
660         // If we add a DataFormatBool, we should use it here.
661         m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
662         jsValueResult(result.gpr(), m_compileIndex);
663         break;
664     }
665
666     case GetByVal: {
667         NodeIndex alias = node.child3;
668         if (alias != NoNode) {
669             // FIXME: result should be able to reuse child1, child2. Should have an 'UnusedOperand' type.
670             JSValueOperand aliasedValue(this, node.child3);
671             GPRTemporary result(this, aliasedValue);
672             m_jit.move(aliasedValue.gpr(), result.gpr());
673             jsValueResult(result.gpr(), m_compileIndex);
674             break;
675         }
676
677         SpeculateCellOperand base(this, node.child1);
678         SpeculateStrictInt32Operand property(this, node.child2);
679         GPRTemporary storage(this);
680
681         GPRReg baseReg = base.gpr();
682         GPRReg propertyReg = property.gpr();
683         GPRReg storageReg = storage.gpr();
684
685         // Get the array storage. We haven't yet checked this is a JSArray, so this is only safe if
686         // an access with offset JSArray::storageOffset() is valid for all JSCells!
687         m_jit.loadPtr(MacroAssembler::Address(baseReg, JSArray::storageOffset()), storageReg);
688
689         // Check that base is an array, and that property is contained within m_vector (< m_vectorLength).
690         // If we have predicted the base to be type array, we can skip the check.
691         Node& baseNode = m_jit.graph()[node.child1];
692         if (baseNode.op != GetLocal || m_jit.graph().getPrediction(baseNode.local()) != PredictArray)
693             speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg), MacroAssembler::TrustedImmPtr(m_jit.globalData()->jsArrayVPtr)));
694         speculationCheck(m_jit.branch32(MacroAssembler::AboveOrEqual, propertyReg, MacroAssembler::Address(baseReg, JSArray::vectorLengthOffset())));
695
696         // FIXME: In cases where there are subsequent by_val accesses to the same base it might help to cache
697         // the storage pointer - especially if there happens to be another register free right now. If we do so,
698         // then we'll need to allocate a new temporary for result.
699         GPRTemporary& result = storage;
700         m_jit.loadPtr(MacroAssembler::BaseIndex(storageReg, propertyReg, MacroAssembler::ScalePtr, OBJECT_OFFSETOF(ArrayStorage, m_vector[0])), result.gpr());
701         speculationCheck(m_jit.branchTestPtr(MacroAssembler::Zero, result.gpr()));
702
703         jsValueResult(result.gpr(), m_compileIndex);
704         break;
705     }
706
707     case PutByVal: {
708         SpeculateCellOperand base(this, node.child1);
709         SpeculateStrictInt32Operand property(this, node.child2);
710         JSValueOperand value(this, node.child3);
711         GPRTemporary storage(this);
712
713         // Map base, property & value into registers, allocate a register for storage.
714         GPRReg baseReg = base.gpr();
715         GPRReg propertyReg = property.gpr();
716         GPRReg valueReg = value.gpr();
717         GPRReg storageReg = storage.gpr();
718
719         // Check that base is an array, and that property is contained within m_vector (< m_vectorLength).
720         // If we have predicted the base to be type array, we can skip the check.
721         Node& baseNode = m_jit.graph()[node.child1];
722         if (baseNode.op != GetLocal || m_jit.graph().getPrediction(baseNode.local()) != PredictArray)
723             speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg), MacroAssembler::TrustedImmPtr(m_jit.globalData()->jsArrayVPtr)));
724         MacroAssembler::Jump withinArrayBounds = m_jit.branch32(MacroAssembler::Below, propertyReg, MacroAssembler::Address(baseReg, JSArray::vectorLengthOffset()));
725
726         // Code to handle put beyond array bounds.
727         silentSpillAllRegisters(storageReg, baseReg, propertyReg, valueReg);
728         setupStubArguments(baseReg, propertyReg, valueReg);
729         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
730         JITCompiler::Call functionCall = appendCallWithExceptionCheck(operationPutByValBeyondArrayBounds);
731         silentFillAllRegisters(storageReg);
732         JITCompiler::Jump wasBeyondArrayBounds = m_jit.jump();
733
734         withinArrayBounds.link(&m_jit);
735
736         // Get the array storage.
737         m_jit.loadPtr(MacroAssembler::Address(baseReg, JSArray::storageOffset()), storageReg);
738
739         // Check if we're writing to a hole; if so increment m_numValuesInVector.
740         MacroAssembler::Jump notHoleValue = m_jit.branchTestPtr(MacroAssembler::NonZero, MacroAssembler::BaseIndex(storageReg, propertyReg, MacroAssembler::ScalePtr, OBJECT_OFFSETOF(ArrayStorage, m_vector[0])));
741         m_jit.add32(TrustedImm32(1), MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_numValuesInVector)));
742
743         // If we're writing to a hole we might be growing the array; 
744         MacroAssembler::Jump lengthDoesNotNeedUpdate = m_jit.branch32(MacroAssembler::Below, propertyReg, MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_length)));
745         m_jit.add32(TrustedImm32(1), propertyReg);
746         m_jit.store32(propertyReg, MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_length)));
747         m_jit.sub32(TrustedImm32(1), propertyReg);
748
749         lengthDoesNotNeedUpdate.link(&m_jit);
750         notHoleValue.link(&m_jit);
751
752         // Store the value to the array.
753         m_jit.storePtr(valueReg, MacroAssembler::BaseIndex(storageReg, propertyReg, MacroAssembler::ScalePtr, OBJECT_OFFSETOF(ArrayStorage, m_vector[0])));
754
755         wasBeyondArrayBounds.link(&m_jit);
756
757         noResult(m_compileIndex);
758         break;
759     }
760
761     case PutByValAlias: {
762         SpeculateCellOperand base(this, node.child1);
763         SpeculateStrictInt32Operand property(this, node.child2);
764         JSValueOperand value(this, node.child3);
765         GPRTemporary storage(this, base); // storage may overwrite base.
766
767         // Get the array storage.
768         GPRReg storageReg = storage.gpr();
769         m_jit.loadPtr(MacroAssembler::Address(base.gpr(), JSArray::storageOffset()), storageReg);
770
771         // Map property & value into registers.
772         GPRReg propertyReg = property.gpr();
773         GPRReg valueReg = value.gpr();
774
775         // Store the value to the array.
776         m_jit.storePtr(valueReg, MacroAssembler::BaseIndex(storageReg, propertyReg, MacroAssembler::ScalePtr, OBJECT_OFFSETOF(ArrayStorage, m_vector[0])));
777
778         noResult(m_compileIndex);
779         break;
780     }
781
782     case DFG::Jump: {
783         BlockIndex taken = m_jit.graph().blockIndexForBytecodeOffset(node.takenBytecodeOffset());
784         if (taken != (m_block + 1))
785             addBranch(m_jit.jump(), taken);
786         noResult(m_compileIndex);
787         break;
788     }
789
790     case Branch: {
791         JSValueOperand value(this, node.child1);
792         GPRReg valueReg = value.gpr();
793
794         BlockIndex taken = m_jit.graph().blockIndexForBytecodeOffset(node.takenBytecodeOffset());
795         BlockIndex notTaken = m_jit.graph().blockIndexForBytecodeOffset(node.notTakenBytecodeOffset());
796
797         // Integers
798         addBranch(m_jit.branchPtr(MacroAssembler::Equal, valueReg, MacroAssembler::ImmPtr(JSValue::encode(jsNumber(0)))), notTaken);
799         MacroAssembler::Jump isNonZeroInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, valueReg, GPRInfo::tagTypeNumberRegister);
800
801         // Booleans
802         addBranch(m_jit.branchPtr(MacroAssembler::Equal, valueReg, MacroAssembler::ImmPtr(JSValue::encode(jsBoolean(false)))), notTaken);
803         speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, valueReg, MacroAssembler::ImmPtr(JSValue::encode(jsBoolean(true)))));
804
805         if (taken == (m_block + 1))
806             isNonZeroInteger.link(&m_jit);
807         else {
808             addBranch(isNonZeroInteger, taken);
809             addBranch(m_jit.jump(), taken);
810         }
811
812         noResult(m_compileIndex);
813         break;
814     }
815
816     case Return: {
817         ASSERT(GPRInfo::callFrameRegister != GPRInfo::regT1);
818         ASSERT(GPRInfo::regT1 != GPRInfo::returnValueGPR);
819         ASSERT(GPRInfo::returnValueGPR != GPRInfo::callFrameRegister);
820
821 #if DFG_SUCCESS_STATS
822         static SamplingCounter counter("SpeculativeJIT");
823         m_jit.emitCount(counter);
824 #endif
825
826         // Return the result in returnValueGPR.
827         JSValueOperand op1(this, node.child1);
828         m_jit.move(op1.gpr(), GPRInfo::returnValueGPR);
829
830         // Grab the return address.
831         m_jit.emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, GPRInfo::regT1);
832         // Restore our caller's "r".
833         m_jit.emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, GPRInfo::callFrameRegister);
834         // Return.
835         m_jit.restoreReturnAddressBeforeReturn(GPRInfo::regT1);
836         m_jit.ret();
837         
838         noResult(m_compileIndex);
839         break;
840     }
841
842     case ConvertThis: {
843         SpeculateCellOperand thisValue(this, node.child1);
844         GPRTemporary temp(this);
845
846         m_jit.loadPtr(JITCompiler::Address(thisValue.gpr(), JSCell::structureOffset()), temp.gpr());
847         speculationCheck(m_jit.branchTest8(JITCompiler::NonZero, JITCompiler::Address(temp.gpr(), Structure::typeInfoFlagsOffset()), JITCompiler::TrustedImm32(NeedsThisConversion)));
848
849         cellResult(thisValue.gpr(), m_compileIndex);
850         break;
851     }
852
853     case GetById: {
854         SpeculateCellOperand base(this, node.child1);
855         GPRTemporary result(this, base);
856
857         GPRReg baseGPR = base.gpr();
858         GPRReg resultGPR = result.gpr();
859
860         JITCompiler::DataLabelPtr structureToCompare;
861         JITCompiler::Jump structureCheck = m_jit.branchPtrWithPatch(JITCompiler::Equal, JITCompiler::Address(baseGPR, JSCell::structureOffset()), structureToCompare, JITCompiler::TrustedImmPtr(reinterpret_cast<void*>(-1)));
862
863         silentSpillAllRegisters(resultGPR, baseGPR);
864         m_jit.move(baseGPR, GPRInfo::argumentGPR1);
865         m_jit.move(JITCompiler::ImmPtr(identifier(node.identifierNumber())), GPRInfo::argumentGPR2);
866         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
867         JITCompiler::Call functionCall = appendCallWithExceptionCheck(operationGetByIdOptimize);
868         m_jit.move(GPRInfo::returnValueGPR, resultGPR);
869         silentFillAllRegisters(resultGPR);
870
871         JITCompiler::Jump handledByC = m_jit.jump();
872         structureCheck.link(&m_jit);
873
874         m_jit.loadPtr(JITCompiler::Address(baseGPR, JSObject::offsetOfPropertyStorage()), resultGPR);
875         JITCompiler::DataLabelCompact loadWithPatch = m_jit.loadPtrWithCompactAddressOffsetPatch(JITCompiler::Address(resultGPR, 0), resultGPR);
876
877         intptr_t checkToCall = m_jit.differenceBetween(structureToCompare, functionCall);
878         intptr_t callToLoad = m_jit.differenceBetween(functionCall, loadWithPatch);
879
880         handledByC.link(&m_jit);
881
882         m_jit.addPropertyAccess(functionCall, checkToCall, callToLoad);
883
884         jsValueResult(resultGPR, m_compileIndex);
885         break;
886     }
887
888     case PutById: {
889         JSValueOperand base(this, node.child1);
890         JSValueOperand value(this, node.child2);
891         GPRReg valueGPR = value.gpr();
892         GPRReg baseGPR = base.gpr();
893         flushRegisters();
894
895         callOperation(m_jit.codeBlock()->isStrictMode() ? operationPutByIdStrict : operationPutByIdNonStrict, valueGPR, baseGPR, identifier(node.identifierNumber()));
896         noResult(m_compileIndex);
897         break;
898     }
899
900     case PutByIdDirect: {
901         JSValueOperand base(this, node.child1);
902         JSValueOperand value(this, node.child2);
903         GPRReg valueGPR = value.gpr();
904         GPRReg baseGPR = base.gpr();
905         flushRegisters();
906
907         callOperation(m_jit.codeBlock()->isStrictMode() ? operationPutByIdDirectStrict : operationPutByIdDirectNonStrict, valueGPR, baseGPR, identifier(node.identifierNumber()));
908         noResult(m_compileIndex);
909         break;
910     }
911
912     case GetGlobalVar: {
913         GPRTemporary result(this);
914
915         JSVariableObject* globalObject = m_jit.codeBlock()->globalObject();
916         m_jit.loadPtr(globalObject->addressOfRegisters(), result.gpr());
917         m_jit.loadPtr(JITCompiler::addressForGlobalVar(result.gpr(), node.varNumber()), result.gpr());
918
919         jsValueResult(result.gpr(), m_compileIndex);
920         break;
921     }
922
923     case PutGlobalVar: {
924         JSValueOperand value(this, node.child1);
925         GPRTemporary temp(this);
926
927         JSVariableObject* globalObject = m_jit.codeBlock()->globalObject();
928         m_jit.loadPtr(globalObject->addressOfRegisters(), temp.gpr());
929         m_jit.storePtr(value.gpr(), JITCompiler::addressForGlobalVar(temp.gpr(), node.varNumber()));
930
931         noResult(m_compileIndex);
932         break;
933     }
934
935     case Phi:
936         ASSERT_NOT_REACHED();
937     }
938
939     if (node.hasResult() && node.mustGenerate())
940         use(m_compileIndex);
941 }
942
943 void SpeculativeJIT::compile(BasicBlock& block)
944 {
945     ASSERT(m_compileIndex == block.begin);
946     m_blockHeads[m_block] = m_jit.label();
947 #if DFG_JIT_BREAK_ON_EVERY_BLOCK
948     m_jit.breakpoint();
949 #endif
950
951     for (; m_compileIndex < block.end; ++m_compileIndex) {
952         Node& node = m_jit.graph()[m_compileIndex];
953         if (!node.shouldGenerate())
954             continue;
955
956 #if DFG_DEBUG_VERBOSE
957         fprintf(stderr, "SpeculativeJIT generating Node @%d at JIT offset 0x%x\n", (int)m_compileIndex, m_jit.debugOffset());
958 #endif
959 #if DFG_JIT_BREAK_ON_EVERY_NODE
960         m_jit.breakpoint();
961 #endif
962         checkConsistency();
963         compile(node);
964         if (!m_compileOkay)
965             return;
966         checkConsistency();
967     }
968 }
969
970 // If we are making type predictions about our arguments then
971 // we need to check that they are correct on function entry.
972 void SpeculativeJIT::checkArgumentTypes()
973 {
974     ASSERT(!m_compileIndex);
975     for (int i = 0; i < m_jit.codeBlock()->m_numParameters; ++i) {
976         VirtualRegister virtualRegister = (VirtualRegister)(m_jit.codeBlock()->thisRegister() + i);
977         switch (m_jit.graph().getPrediction(virtualRegister)) {
978         case PredictInt32:
979             speculationCheck(m_jit.branchPtr(MacroAssembler::Below, JITCompiler::addressFor(virtualRegister), GPRInfo::tagTypeNumberRegister));
980             break;
981
982         case PredictArray: {
983             GPRTemporary temp(this);
984             m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), temp.gpr());
985             speculationCheck(m_jit.branchTestPtr(MacroAssembler::NonZero, temp.gpr(), GPRInfo::tagMaskRegister));
986             speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(temp.gpr()), MacroAssembler::TrustedImmPtr(m_jit.globalData()->jsArrayVPtr)));
987             break;
988         }
989
990         default:
991             break;
992         }
993     }
994 }
995
996 // For any vars that we will be treating as numeric, write 0 to
997 // the var on entry. Throughout the block we will only read/write
998 // to the payload, by writing the tag now we prevent the GC from
999 // misinterpreting values as pointers.
1000 void SpeculativeJIT::initializeVariableTypes()
1001 {
1002     ASSERT(!m_compileIndex);
1003     for (int var = 0; var < m_jit.codeBlock()->m_numVars; ++var) {
1004         if (m_jit.graph().getPrediction(var) == PredictInt32)
1005             m_jit.storePtr(GPRInfo::tagTypeNumberRegister, JITCompiler::addressFor((VirtualRegister)var));
1006     }
1007 }
1008
1009 bool SpeculativeJIT::compile()
1010 {
1011     checkArgumentTypes();
1012     initializeVariableTypes();
1013
1014     ASSERT(!m_compileIndex);
1015     for (m_block = 0; m_block < m_jit.graph().m_blocks.size(); ++m_block) {
1016         compile(*m_jit.graph().m_blocks[m_block]);
1017         if (!m_compileOkay)
1018             return false;
1019     }
1020     linkBranches();
1021     return true;
1022 }
1023
1024 } } // namespace JSC::DFG
1025
1026 #endif