4d9e36f6f9655bd38a23851f057acb71c74fe803
[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(constantAsJSValueAsImmPtr(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 = constantAsJSValue(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     int32_t imm;
252     if (isJSConstantWithInt32Value(node.child1, imm)) {
253         SpeculateIntegerOperand op2(this, node.child2);
254         addBranch(m_jit.branch32(condition, JITCompiler::Imm32(imm), op2.gpr()), taken);
255     } else if (isJSConstantWithInt32Value(node.child2, imm)) {
256         SpeculateIntegerOperand op1(this, node.child1);
257         addBranch(m_jit.branch32(condition, op1.gpr(), JITCompiler::Imm32(imm)), taken);
258     } else {
259         SpeculateIntegerOperand op1(this, node.child1);
260         SpeculateIntegerOperand op2(this, node.child2);
261         addBranch(m_jit.branch32(condition, op1.gpr(), op2.gpr()), taken);
262     }
263
264     // Check for fall through, otherwise we need to jump.
265     if (notTaken != (m_block + 1))
266         addBranch(m_jit.jump(), notTaken);
267 }
268
269 void SpeculativeJIT::compilePeepHoleEq(Node& node, NodeIndex branchNodeIndex)
270 {
271     Node& branchNode = m_jit.graph()[branchNodeIndex];
272     BlockIndex taken = m_jit.graph().blockIndexForBytecodeOffset(branchNode.takenBytecodeOffset());
273     BlockIndex notTaken = m_jit.graph().blockIndexForBytecodeOffset(branchNode.notTakenBytecodeOffset());
274
275     // The branch instruction will branch to the taken block.
276     // If taken is next, switch taken with notTaken & invert the branch condition so we can fall through.
277     JITCompiler::ResultCondition condition = JITCompiler::NonZero;
278     if (taken == (m_block + 1)) {
279         condition = JITCompiler::Zero;
280         BlockIndex tmp = taken;
281         taken = notTaken;
282         notTaken = tmp;
283     }
284
285     JSValueOperand op1(this, node.child1);
286     JSValueOperand op2(this, node.child2);
287     GPRReg op1GPR = op1.gpr();
288     GPRReg op2GPR = op2.gpr();
289     flushRegisters();
290
291     GPRResult result(this);
292     callOperation(operationCompareEq, result.gpr(), op1GPR, op2GPR);
293     addBranch(m_jit.branchTest8(condition, result.gpr()), taken);
294
295     // Check for fall through, otherwise we need to jump.
296     if (notTaken != (m_block + 1))
297         addBranch(m_jit.jump(), notTaken);
298 }
299
300 void SpeculativeJIT::compile(Node& node)
301 {
302     NodeType op = node.op;
303
304     switch (op) {
305     case Int32Constant:
306     case DoubleConstant:
307     case JSConstant:
308         initConstantInfo(m_compileIndex);
309         break;
310
311     case GetLocal: {
312         GPRTemporary result(this);
313         PredictedType prediction = m_jit.graph().getPrediction(node.local());
314         if (prediction == PredictInt32) {
315             m_jit.load32(JITCompiler::payloadFor(node.local()), result.gpr());
316
317             // Like integerResult, but don't useChildren - our children are phi nodes,
318             // and don't represent values within this dataflow with virtual registers.
319             VirtualRegister virtualRegister = node.virtualRegister();
320             m_gprs.retain(result.gpr(), virtualRegister, SpillOrderInteger);
321             m_generationInfo[virtualRegister].initInteger(m_compileIndex, node.refCount(), result.gpr());
322         } else {
323             m_jit.loadPtr(JITCompiler::addressFor(node.local()), result.gpr());
324
325             // Like jsValueResult, but don't useChildren - our children are phi nodes,
326             // and don't represent values within this dataflow with virtual registers.
327             VirtualRegister virtualRegister = node.virtualRegister();
328             m_gprs.retain(result.gpr(), virtualRegister, SpillOrderJS);
329             m_generationInfo[virtualRegister].initJSValue(m_compileIndex, node.refCount(), result.gpr(), (prediction == PredictArray) ? DataFormatJSCell : DataFormatJS);
330         }
331         break;
332     }
333
334     case SetLocal: {
335         switch (m_jit.graph().getPrediction(node.local())) {
336         case PredictInt32: {
337             SpeculateIntegerOperand value(this, node.child1);
338             m_jit.store32(value.gpr(), JITCompiler::payloadFor(node.local()));
339             noResult(m_compileIndex);
340             break;
341         }
342         case PredictArray: {
343             SpeculateCellOperand cell(this, node.child1);
344             m_jit.storePtr(cell.gpr(), JITCompiler::addressFor(node.local()));
345             noResult(m_compileIndex);
346             break;
347         }
348
349         default: {
350             JSValueOperand value(this, node.child1);
351             m_jit.storePtr(value.gpr(), JITCompiler::addressFor(node.local()));
352             noResult(m_compileIndex);
353             break;
354         }
355         }
356         break;
357     }
358
359     case BitAnd:
360     case BitOr:
361     case BitXor:
362         if (isInt32Constant(node.child1)) {
363             SpeculateIntegerOperand op2(this, node.child2);
364             GPRTemporary result(this, op2);
365
366             bitOp(op, valueOfInt32Constant(node.child1), op2.gpr(), result.gpr());
367
368             integerResult(result.gpr(), m_compileIndex);
369         } else if (isInt32Constant(node.child2)) {
370             SpeculateIntegerOperand op1(this, node.child1);
371             GPRTemporary result(this, op1);
372
373             bitOp(op, valueOfInt32Constant(node.child2), op1.gpr(), result.gpr());
374
375             integerResult(result.gpr(), m_compileIndex);
376         } else {
377             SpeculateIntegerOperand op1(this, node.child1);
378             SpeculateIntegerOperand op2(this, node.child2);
379             GPRTemporary result(this, op1, op2);
380
381             GPRReg reg1 = op1.gpr();
382             GPRReg reg2 = op2.gpr();
383             bitOp(op, reg1, reg2, result.gpr());
384
385             integerResult(result.gpr(), m_compileIndex);
386         }
387         break;
388
389     case BitRShift:
390     case BitLShift:
391     case BitURShift:
392         if (isInt32Constant(node.child2)) {
393             SpeculateIntegerOperand op1(this, node.child1);
394             GPRTemporary result(this, op1);
395
396             shiftOp(op, op1.gpr(), valueOfInt32Constant(node.child2) & 0x1f, result.gpr());
397
398             integerResult(result.gpr(), m_compileIndex);
399         } else {
400             // Do not allow shift amount to be used as the result, MacroAssembler does not permit this.
401             SpeculateIntegerOperand op1(this, node.child1);
402             SpeculateIntegerOperand op2(this, node.child2);
403             GPRTemporary result(this, op1);
404
405             GPRReg reg1 = op1.gpr();
406             GPRReg reg2 = op2.gpr();
407             shiftOp(op, reg1, reg2, result.gpr());
408
409             integerResult(result.gpr(), m_compileIndex);
410         }
411         break;
412
413     case UInt32ToNumber: {
414         IntegerOperand op1(this, node.child1);
415         GPRTemporary result(this, op1);
416
417         // Test the operand is positive.
418         speculationCheck(m_jit.branch32(MacroAssembler::LessThan, op1.gpr(), TrustedImm32(0)));
419
420         m_jit.move(op1.gpr(), result.gpr());
421         integerResult(result.gpr(), m_compileIndex, op1.format());
422         break;
423     }
424
425     case NumberToInt32: {
426         SpeculateIntegerOperand op1(this, node.child1);
427         GPRTemporary result(this, op1);
428         m_jit.move(op1.gpr(), result.gpr());
429         integerResult(result.gpr(), m_compileIndex, op1.format());
430         break;
431     }
432
433     case Int32ToNumber: {
434         SpeculateIntegerOperand op1(this, node.child1);
435         GPRTemporary result(this, op1);
436         m_jit.move(op1.gpr(), result.gpr());
437         integerResult(result.gpr(), m_compileIndex, op1.format());
438         break;
439     }
440
441     case ValueToInt32: {
442         SpeculateIntegerOperand op1(this, node.child1);
443         GPRTemporary result(this, op1);
444         m_jit.move(op1.gpr(), result.gpr());
445         integerResult(result.gpr(), m_compileIndex, op1.format());
446         break;
447     }
448
449     case ValueToNumber: {
450         SpeculateIntegerOperand op1(this, node.child1);
451         GPRTemporary result(this, op1);
452         m_jit.move(op1.gpr(), result.gpr());
453         integerResult(result.gpr(), m_compileIndex, op1.format());
454         break;
455     }
456
457     case ValueAdd:
458     case ArithAdd: {
459         int32_t imm1;
460         if (isDoubleConstantWithInt32Value(node.child1, imm1)) {
461             SpeculateIntegerOperand op2(this, node.child2);
462             GPRTemporary result(this);
463
464             speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, op2.gpr(), Imm32(imm1), result.gpr()));
465
466             integerResult(result.gpr(), m_compileIndex);
467             break;
468         }
469             
470         int32_t imm2;
471         if (isDoubleConstantWithInt32Value(node.child2, imm2)) {
472             SpeculateIntegerOperand op1(this, node.child1);
473             GPRTemporary result(this);
474
475             speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, op1.gpr(), Imm32(imm2), result.gpr()));
476
477             integerResult(result.gpr(), m_compileIndex);
478             break;
479         }
480             
481         SpeculateIntegerOperand op1(this, node.child1);
482         SpeculateIntegerOperand op2(this, node.child2);
483         GPRTemporary result(this, op1, op2);
484
485         GPRReg gpr1 = op1.gpr();
486         GPRReg gpr2 = op2.gpr();
487         GPRReg gprResult = result.gpr();
488         MacroAssembler::Jump check = m_jit.branchAdd32(MacroAssembler::Overflow, gpr1, gpr2, gprResult);
489
490         if (gpr1 == gprResult)
491             speculationCheck(check, SpeculationRecovery(SpeculativeAdd, gprResult, gpr2));
492         else if (gpr2 == gprResult)
493             speculationCheck(check, SpeculationRecovery(SpeculativeAdd, gprResult, gpr1));
494         else
495             speculationCheck(check);
496
497         integerResult(gprResult, m_compileIndex);
498         break;
499     }
500
501     case ArithSub: {
502         int32_t imm2;
503         if (isDoubleConstantWithInt32Value(node.child2, imm2)) {
504             SpeculateIntegerOperand op1(this, node.child1);
505             GPRTemporary result(this);
506
507             speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, op1.gpr(), Imm32(imm2), result.gpr()));
508
509             integerResult(result.gpr(), m_compileIndex);
510             break;
511         }
512             
513         SpeculateIntegerOperand op1(this, node.child1);
514         SpeculateIntegerOperand op2(this, node.child2);
515         GPRTemporary result(this);
516
517         speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, op1.gpr(), op2.gpr(), result.gpr()));
518
519         integerResult(result.gpr(), m_compileIndex);
520         break;
521     }
522
523     case ArithMul: {
524         SpeculateIntegerOperand op1(this, node.child1);
525         SpeculateIntegerOperand op2(this, node.child2);
526         GPRTemporary result(this);
527
528         GPRReg reg1 = op1.gpr();
529         GPRReg reg2 = op2.gpr();
530         speculationCheck(m_jit.branchMul32(MacroAssembler::Overflow, reg1, reg2, result.gpr()));
531
532         MacroAssembler::Jump resultNonZero = m_jit.branchTest32(MacroAssembler::NonZero, result.gpr());
533         speculationCheck(m_jit.branch32(MacroAssembler::LessThan, reg1, TrustedImm32(0)));
534         speculationCheck(m_jit.branch32(MacroAssembler::LessThan, reg2, TrustedImm32(0)));
535         resultNonZero.link(&m_jit);
536
537         integerResult(result.gpr(), m_compileIndex);
538         break;
539     }
540
541     case ArithDiv: {
542         SpeculateIntegerOperand op1(this, node.child1);
543         SpeculateIntegerOperand op2(this, node.child2);
544         GPRTemporary result(this, op1, op2);
545
546         op1.gpr();
547         op2.gpr();
548         terminateSpeculativeExecution();
549
550         integerResult(result.gpr(), m_compileIndex);
551         break;
552     }
553
554     case ArithMod: {
555         SpeculateIntegerOperand op1(this, node.child1);
556         SpeculateIntegerOperand op2(this, node.child2);
557         GPRTemporary result(this, op1, op2);
558
559         op1.gpr();
560         op2.gpr();
561         terminateSpeculativeExecution();
562
563         integerResult(result.gpr(), m_compileIndex);
564         break;
565     }
566
567     case LogicalNot: {
568         JSValueOperand value(this, node.child1);
569         GPRTemporary result(this); // FIXME: We could reuse, but on speculation fail would need recovery to restore tag (akin to add).
570
571         m_jit.move(value.gpr(), result.gpr());
572         m_jit.xorPtr(TrustedImm32(static_cast<int32_t>(ValueFalse)), result.gpr());
573         speculationCheck(m_jit.branchTestPtr(JITCompiler::NonZero, result.gpr(), TrustedImm32(static_cast<int32_t>(~1))));
574         m_jit.xorPtr(TrustedImm32(static_cast<int32_t>(ValueTrue)), result.gpr());
575
576         // If we add a DataFormatBool, we should use it here.
577         jsValueResult(result.gpr(), m_compileIndex);
578         break;
579     }
580
581     case CompareLess: {
582         // Fused compare & branch.
583         NodeIndex branchNodeIndex = detectPeepHoleBranch();
584         if (branchNodeIndex != NoNode) {
585             // detectPeepHoleBranch currently only permits the branch to be the very next node,
586             // so can be no intervening nodes to also reference the compare. 
587             ASSERT(node.adjustedRefCount() == 1);
588
589             compilePeepHoleIntegerBranch(node, branchNodeIndex, JITCompiler::LessThan);
590
591             use(node.child1);
592             use(node.child2);
593             m_compileIndex = branchNodeIndex;
594             return;
595         }
596
597         // Normal case, not fused to branch.
598         SpeculateIntegerOperand op1(this, node.child1);
599         SpeculateIntegerOperand op2(this, node.child2);
600         GPRTemporary result(this, op1, op2);
601
602         m_jit.compare32(JITCompiler::LessThan, op1.gpr(), op2.gpr(), result.gpr());
603
604         // If we add a DataFormatBool, we should use it here.
605         m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
606         jsValueResult(result.gpr(), m_compileIndex);
607         break;
608     }
609
610     case CompareLessEq: {
611         // Fused compare & branch.
612         NodeIndex branchNodeIndex = detectPeepHoleBranch();
613         if (branchNodeIndex != NoNode) {
614             // detectPeepHoleBranch currently only permits the branch to be the very next node,
615             // so can be no intervening nodes to also reference the compare. 
616             ASSERT(node.adjustedRefCount() == 1);
617
618             compilePeepHoleIntegerBranch(node, branchNodeIndex, JITCompiler::LessThanOrEqual);
619
620             use(node.child1);
621             use(node.child2);
622             m_compileIndex = branchNodeIndex;
623             return;
624         }
625
626         // Normal case, not fused to branch.
627         SpeculateIntegerOperand op1(this, node.child1);
628         SpeculateIntegerOperand op2(this, node.child2);
629         GPRTemporary result(this, op1, op2);
630
631         m_jit.compare32(JITCompiler::LessThanOrEqual, op1.gpr(), op2.gpr(), result.gpr());
632
633         // If we add a DataFormatBool, we should use it here.
634         m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
635         jsValueResult(result.gpr(), m_compileIndex);
636         break;
637     }
638
639     case CompareEq: {
640         // Fused compare & branch.
641         NodeIndex branchNodeIndex = detectPeepHoleBranch();
642         if (branchNodeIndex != NoNode) {
643             // detectPeepHoleBranch currently only permits the branch to be the very next node,
644             // so can be no intervening nodes to also reference the compare. 
645             ASSERT(node.adjustedRefCount() == 1);
646
647             if (isInteger(node.child1) || isInteger(node.child2))
648                 compilePeepHoleIntegerBranch(node, branchNodeIndex, JITCompiler::Equal);
649             else
650                 compilePeepHoleEq(node, branchNodeIndex);
651
652             use(node.child1);
653             use(node.child2);
654             m_compileIndex = branchNodeIndex;
655             return;
656         }
657
658         SpeculateIntegerOperand op1(this, node.child1);
659         SpeculateIntegerOperand op2(this, node.child2);
660         GPRTemporary result(this, op1, op2);
661
662         m_jit.compare32(JITCompiler::Equal, op1.gpr(), op2.gpr(), result.gpr());
663
664         // If we add a DataFormatBool, we should use it here.
665         m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
666         jsValueResult(result.gpr(), m_compileIndex);
667         break;
668     }
669
670     case CompareStrictEq: {
671         SpeculateIntegerOperand op1(this, node.child1);
672         SpeculateIntegerOperand op2(this, node.child2);
673         GPRTemporary result(this, op1, op2);
674
675         m_jit.compare32(JITCompiler::Equal, op1.gpr(), op2.gpr(), result.gpr());
676
677         // If we add a DataFormatBool, we should use it here.
678         m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
679         jsValueResult(result.gpr(), m_compileIndex);
680         break;
681     }
682
683     case GetByVal: {
684         NodeIndex alias = node.child3;
685         if (alias != NoNode) {
686             // FIXME: result should be able to reuse child1, child2. Should have an 'UnusedOperand' type.
687             JSValueOperand aliasedValue(this, node.child3);
688             GPRTemporary result(this, aliasedValue);
689             m_jit.move(aliasedValue.gpr(), result.gpr());
690             jsValueResult(result.gpr(), m_compileIndex);
691             break;
692         }
693
694         SpeculateCellOperand base(this, node.child1);
695         SpeculateStrictInt32Operand property(this, node.child2);
696         GPRTemporary storage(this);
697
698         GPRReg baseReg = base.gpr();
699         GPRReg propertyReg = property.gpr();
700         GPRReg storageReg = storage.gpr();
701
702         // Get the array storage. We haven't yet checked this is a JSArray, so this is only safe if
703         // an access with offset JSArray::storageOffset() is valid for all JSCells!
704         m_jit.loadPtr(MacroAssembler::Address(baseReg, JSArray::storageOffset()), storageReg);
705
706         // Check that base is an array, and that property is contained within m_vector (< m_vectorLength).
707         // If we have predicted the base to be type array, we can skip the check.
708         Node& baseNode = m_jit.graph()[node.child1];
709         if (baseNode.op != GetLocal || m_jit.graph().getPrediction(baseNode.local()) != PredictArray)
710             speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg), MacroAssembler::TrustedImmPtr(m_jit.globalData()->jsArrayVPtr)));
711         speculationCheck(m_jit.branch32(MacroAssembler::AboveOrEqual, propertyReg, MacroAssembler::Address(baseReg, JSArray::vectorLengthOffset())));
712
713         // FIXME: In cases where there are subsequent by_val accesses to the same base it might help to cache
714         // the storage pointer - especially if there happens to be another register free right now. If we do so,
715         // then we'll need to allocate a new temporary for result.
716         GPRTemporary& result = storage;
717         m_jit.loadPtr(MacroAssembler::BaseIndex(storageReg, propertyReg, MacroAssembler::ScalePtr, OBJECT_OFFSETOF(ArrayStorage, m_vector[0])), result.gpr());
718         speculationCheck(m_jit.branchTestPtr(MacroAssembler::Zero, result.gpr()));
719
720         jsValueResult(result.gpr(), m_compileIndex);
721         break;
722     }
723
724     case PutByVal: {
725         SpeculateCellOperand base(this, node.child1);
726         SpeculateStrictInt32Operand property(this, node.child2);
727         JSValueOperand value(this, node.child3);
728         GPRTemporary storage(this);
729
730         // Map base, property & value into registers, allocate a register for storage.
731         GPRReg baseReg = base.gpr();
732         GPRReg propertyReg = property.gpr();
733         GPRReg valueReg = value.gpr();
734         GPRReg storageReg = storage.gpr();
735
736         // Check that base is an array, and that property is contained within m_vector (< m_vectorLength).
737         // If we have predicted the base to be type array, we can skip the check.
738         Node& baseNode = m_jit.graph()[node.child1];
739         if (baseNode.op != GetLocal || m_jit.graph().getPrediction(baseNode.local()) != PredictArray)
740             speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg), MacroAssembler::TrustedImmPtr(m_jit.globalData()->jsArrayVPtr)));
741         MacroAssembler::Jump withinArrayBounds = m_jit.branch32(MacroAssembler::Below, propertyReg, MacroAssembler::Address(baseReg, JSArray::vectorLengthOffset()));
742
743         // Code to handle put beyond array bounds.
744         silentSpillAllRegisters(storageReg, baseReg, propertyReg, valueReg);
745         setupStubArguments(baseReg, propertyReg, valueReg);
746         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
747         JITCompiler::Call functionCall = appendCallWithExceptionCheck(operationPutByValBeyondArrayBounds);
748         silentFillAllRegisters(storageReg);
749         JITCompiler::Jump wasBeyondArrayBounds = m_jit.jump();
750
751         withinArrayBounds.link(&m_jit);
752
753         // Get the array storage.
754         m_jit.loadPtr(MacroAssembler::Address(baseReg, JSArray::storageOffset()), storageReg);
755
756         // Check if we're writing to a hole; if so increment m_numValuesInVector.
757         MacroAssembler::Jump notHoleValue = m_jit.branchTestPtr(MacroAssembler::NonZero, MacroAssembler::BaseIndex(storageReg, propertyReg, MacroAssembler::ScalePtr, OBJECT_OFFSETOF(ArrayStorage, m_vector[0])));
758         m_jit.add32(TrustedImm32(1), MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_numValuesInVector)));
759
760         // If we're writing to a hole we might be growing the array; 
761         MacroAssembler::Jump lengthDoesNotNeedUpdate = m_jit.branch32(MacroAssembler::Below, propertyReg, MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_length)));
762         m_jit.add32(TrustedImm32(1), propertyReg);
763         m_jit.store32(propertyReg, MacroAssembler::Address(storageReg, OBJECT_OFFSETOF(ArrayStorage, m_length)));
764         m_jit.sub32(TrustedImm32(1), propertyReg);
765
766         lengthDoesNotNeedUpdate.link(&m_jit);
767         notHoleValue.link(&m_jit);
768
769         // Store the value to the array.
770         m_jit.storePtr(valueReg, MacroAssembler::BaseIndex(storageReg, propertyReg, MacroAssembler::ScalePtr, OBJECT_OFFSETOF(ArrayStorage, m_vector[0])));
771
772         wasBeyondArrayBounds.link(&m_jit);
773
774         noResult(m_compileIndex);
775         break;
776     }
777
778     case PutByValAlias: {
779         SpeculateCellOperand base(this, node.child1);
780         SpeculateStrictInt32Operand property(this, node.child2);
781         JSValueOperand value(this, node.child3);
782         GPRTemporary storage(this, base); // storage may overwrite base.
783
784         // Get the array storage.
785         GPRReg storageReg = storage.gpr();
786         m_jit.loadPtr(MacroAssembler::Address(base.gpr(), JSArray::storageOffset()), storageReg);
787
788         // Map property & value into registers.
789         GPRReg propertyReg = property.gpr();
790         GPRReg valueReg = value.gpr();
791
792         // Store the value to the array.
793         m_jit.storePtr(valueReg, MacroAssembler::BaseIndex(storageReg, propertyReg, MacroAssembler::ScalePtr, OBJECT_OFFSETOF(ArrayStorage, m_vector[0])));
794
795         noResult(m_compileIndex);
796         break;
797     }
798
799     case DFG::Jump: {
800         BlockIndex taken = m_jit.graph().blockIndexForBytecodeOffset(node.takenBytecodeOffset());
801         if (taken != (m_block + 1))
802             addBranch(m_jit.jump(), taken);
803         noResult(m_compileIndex);
804         break;
805     }
806
807     case Branch: {
808         JSValueOperand value(this, node.child1);
809         GPRReg valueReg = value.gpr();
810
811         BlockIndex taken = m_jit.graph().blockIndexForBytecodeOffset(node.takenBytecodeOffset());
812         BlockIndex notTaken = m_jit.graph().blockIndexForBytecodeOffset(node.notTakenBytecodeOffset());
813
814         // Integers
815         addBranch(m_jit.branchPtr(MacroAssembler::Equal, valueReg, MacroAssembler::ImmPtr(JSValue::encode(jsNumber(0)))), notTaken);
816         MacroAssembler::Jump isNonZeroInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, valueReg, GPRInfo::tagTypeNumberRegister);
817
818         // Booleans
819         addBranch(m_jit.branchPtr(MacroAssembler::Equal, valueReg, MacroAssembler::ImmPtr(JSValue::encode(jsBoolean(false)))), notTaken);
820         speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, valueReg, MacroAssembler::ImmPtr(JSValue::encode(jsBoolean(true)))));
821
822         if (taken == (m_block + 1))
823             isNonZeroInteger.link(&m_jit);
824         else {
825             addBranch(isNonZeroInteger, taken);
826             addBranch(m_jit.jump(), taken);
827         }
828
829         noResult(m_compileIndex);
830         break;
831     }
832
833     case Return: {
834         ASSERT(GPRInfo::callFrameRegister != GPRInfo::regT1);
835         ASSERT(GPRInfo::regT1 != GPRInfo::returnValueGPR);
836         ASSERT(GPRInfo::returnValueGPR != GPRInfo::callFrameRegister);
837
838 #if DFG_SUCCESS_STATS
839         static SamplingCounter counter("SpeculativeJIT");
840         m_jit.emitCount(counter);
841 #endif
842
843         // Return the result in returnValueGPR.
844         JSValueOperand op1(this, node.child1);
845         m_jit.move(op1.gpr(), GPRInfo::returnValueGPR);
846
847         // Grab the return address.
848         m_jit.emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, GPRInfo::regT1);
849         // Restore our caller's "r".
850         m_jit.emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, GPRInfo::callFrameRegister);
851         // Return.
852         m_jit.restoreReturnAddressBeforeReturn(GPRInfo::regT1);
853         m_jit.ret();
854         
855         noResult(m_compileIndex);
856         break;
857     }
858
859     case ConvertThis: {
860         SpeculateCellOperand thisValue(this, node.child1);
861         GPRTemporary temp(this);
862
863         m_jit.loadPtr(JITCompiler::Address(thisValue.gpr(), JSCell::structureOffset()), temp.gpr());
864         speculationCheck(m_jit.branchTest8(JITCompiler::NonZero, JITCompiler::Address(temp.gpr(), Structure::typeInfoFlagsOffset()), JITCompiler::TrustedImm32(NeedsThisConversion)));
865
866         cellResult(thisValue.gpr(), m_compileIndex);
867         break;
868     }
869
870     case GetById: {
871         SpeculateCellOperand base(this, node.child1);
872         GPRTemporary result(this, base);
873
874         GPRReg baseGPR = base.gpr();
875         GPRReg resultGPR = result.gpr();
876
877         JITCompiler::DataLabelPtr structureToCompare;
878         JITCompiler::Jump structureCheck = m_jit.branchPtrWithPatch(JITCompiler::Equal, JITCompiler::Address(baseGPR, JSCell::structureOffset()), structureToCompare, JITCompiler::TrustedImmPtr(reinterpret_cast<void*>(-1)));
879
880         silentSpillAllRegisters(resultGPR, baseGPR);
881         m_jit.move(baseGPR, GPRInfo::argumentGPR1);
882         m_jit.move(JITCompiler::ImmPtr(identifier(node.identifierNumber())), GPRInfo::argumentGPR2);
883         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
884         JITCompiler::Call functionCall = appendCallWithExceptionCheck(operationGetByIdOptimize);
885         m_jit.move(GPRInfo::returnValueGPR, resultGPR);
886         silentFillAllRegisters(resultGPR);
887
888         JITCompiler::Jump handledByC = m_jit.jump();
889         structureCheck.link(&m_jit);
890
891         m_jit.loadPtr(JITCompiler::Address(baseGPR, JSObject::offsetOfPropertyStorage()), resultGPR);
892         JITCompiler::DataLabelCompact loadWithPatch = m_jit.loadPtrWithCompactAddressOffsetPatch(JITCompiler::Address(resultGPR, 0), resultGPR);
893
894         intptr_t checkToCall = m_jit.differenceBetween(structureToCompare, functionCall);
895         intptr_t callToLoad = m_jit.differenceBetween(functionCall, loadWithPatch);
896
897         handledByC.link(&m_jit);
898
899         m_jit.addPropertyAccess(functionCall, checkToCall, callToLoad);
900
901         jsValueResult(resultGPR, m_compileIndex);
902         break;
903     }
904
905     case PutById: {
906         JSValueOperand base(this, node.child1);
907         JSValueOperand value(this, node.child2);
908         GPRReg valueGPR = value.gpr();
909         GPRReg baseGPR = base.gpr();
910         flushRegisters();
911
912         callOperation(m_jit.codeBlock()->isStrictMode() ? operationPutByIdStrict : operationPutByIdNonStrict, valueGPR, baseGPR, identifier(node.identifierNumber()));
913         noResult(m_compileIndex);
914         break;
915     }
916
917     case PutByIdDirect: {
918         JSValueOperand base(this, node.child1);
919         JSValueOperand value(this, node.child2);
920         GPRReg valueGPR = value.gpr();
921         GPRReg baseGPR = base.gpr();
922         flushRegisters();
923
924         callOperation(m_jit.codeBlock()->isStrictMode() ? operationPutByIdDirectStrict : operationPutByIdDirectNonStrict, valueGPR, baseGPR, identifier(node.identifierNumber()));
925         noResult(m_compileIndex);
926         break;
927     }
928
929     case GetGlobalVar: {
930         GPRTemporary result(this);
931
932         JSVariableObject* globalObject = m_jit.codeBlock()->globalObject();
933         m_jit.loadPtr(globalObject->addressOfRegisters(), result.gpr());
934         m_jit.loadPtr(JITCompiler::addressForGlobalVar(result.gpr(), node.varNumber()), result.gpr());
935
936         jsValueResult(result.gpr(), m_compileIndex);
937         break;
938     }
939
940     case PutGlobalVar: {
941         JSValueOperand value(this, node.child1);
942         GPRTemporary temp(this);
943
944         JSVariableObject* globalObject = m_jit.codeBlock()->globalObject();
945         m_jit.loadPtr(globalObject->addressOfRegisters(), temp.gpr());
946         m_jit.storePtr(value.gpr(), JITCompiler::addressForGlobalVar(temp.gpr(), node.varNumber()));
947
948         noResult(m_compileIndex);
949         break;
950     }
951
952     case Phi:
953         ASSERT_NOT_REACHED();
954     }
955
956     if (node.hasResult() && node.mustGenerate())
957         use(m_compileIndex);
958 }
959
960 void SpeculativeJIT::compile(BasicBlock& block)
961 {
962     ASSERT(m_compileIndex == block.begin);
963     m_blockHeads[m_block] = m_jit.label();
964 #if DFG_JIT_BREAK_ON_EVERY_BLOCK
965     m_jit.breakpoint();
966 #endif
967
968     for (; m_compileIndex < block.end; ++m_compileIndex) {
969         Node& node = m_jit.graph()[m_compileIndex];
970         if (!node.shouldGenerate())
971             continue;
972
973 #if DFG_DEBUG_VERBOSE
974         fprintf(stderr, "SpeculativeJIT generating Node @%d at JIT offset 0x%x\n", (int)m_compileIndex, m_jit.debugOffset());
975 #endif
976 #if DFG_JIT_BREAK_ON_EVERY_NODE
977         m_jit.breakpoint();
978 #endif
979         checkConsistency();
980         compile(node);
981         if (!m_compileOkay)
982             return;
983         checkConsistency();
984     }
985 }
986
987 // If we are making type predictions about our arguments then
988 // we need to check that they are correct on function entry.
989 void SpeculativeJIT::checkArgumentTypes()
990 {
991     ASSERT(!m_compileIndex);
992     for (int i = 0; i < m_jit.codeBlock()->m_numParameters; ++i) {
993         VirtualRegister virtualRegister = (VirtualRegister)(m_jit.codeBlock()->thisRegister() + i);
994         switch (m_jit.graph().getPrediction(virtualRegister)) {
995         case PredictInt32:
996             speculationCheck(m_jit.branchPtr(MacroAssembler::Below, JITCompiler::addressFor(virtualRegister), GPRInfo::tagTypeNumberRegister));
997             break;
998
999         case PredictArray: {
1000             GPRTemporary temp(this);
1001             m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), temp.gpr());
1002             speculationCheck(m_jit.branchTestPtr(MacroAssembler::NonZero, temp.gpr(), GPRInfo::tagMaskRegister));
1003             speculationCheck(m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(temp.gpr()), MacroAssembler::TrustedImmPtr(m_jit.globalData()->jsArrayVPtr)));
1004             break;
1005         }
1006
1007         default:
1008             break;
1009         }
1010     }
1011 }
1012
1013 // For any vars that we will be treating as numeric, write 0 to
1014 // the var on entry. Throughout the block we will only read/write
1015 // to the payload, by writing the tag now we prevent the GC from
1016 // misinterpreting values as pointers.
1017 void SpeculativeJIT::initializeVariableTypes()
1018 {
1019     ASSERT(!m_compileIndex);
1020     for (int var = 0; var < m_jit.codeBlock()->m_numVars; ++var) {
1021         if (m_jit.graph().getPrediction(var) == PredictInt32)
1022             m_jit.storePtr(GPRInfo::tagTypeNumberRegister, JITCompiler::addressFor((VirtualRegister)var));
1023     }
1024 }
1025
1026 bool SpeculativeJIT::compile()
1027 {
1028     checkArgumentTypes();
1029     initializeVariableTypes();
1030
1031     ASSERT(!m_compileIndex);
1032     for (m_block = 0; m_block < m_jit.graph().m_blocks.size(); ++m_block) {
1033         compile(*m_jit.graph().m_blocks[m_block]);
1034         if (!m_compileOkay)
1035             return false;
1036     }
1037     linkBranches();
1038     return true;
1039 }
1040
1041 } } // namespace JSC::DFG
1042
1043 #endif