OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/v8.h" | 5 #include "src/v8.h" |
6 | 6 |
7 #include "src/code-factory.h" | 7 #include "src/code-factory.h" |
8 #include "src/code-stubs.h" | 8 #include "src/code-stubs.h" |
9 #include "src/hydrogen-osr.h" | 9 #include "src/hydrogen-osr.h" |
10 #include "src/ic/ic.h" | 10 #include "src/ic/ic.h" |
11 #include "src/ic/stub-cache.h" | 11 #include "src/ic/stub-cache.h" |
12 #include "src/mips64/lithium-codegen-mips64.h" | 12 #include "src/mips64/lithium-codegen-mips64.h" |
13 #include "src/mips64/lithium-gap-resolver-mips64.h" | 13 #include "src/mips64/lithium-gap-resolver-mips64.h" |
14 | 14 |
15 namespace v8 { | 15 namespace v8 { |
16 namespace internal { | 16 namespace internal { |
17 | 17 |
18 | 18 |
19 class SafepointGenerator FINAL : public CallWrapper { | 19 class SafepointGenerator FINAL : public CallWrapper { |
20 public: | 20 public: |
21 SafepointGenerator(LCodeGen* codegen, | 21 SafepointGenerator(LCodeGen* codegen, |
22 LPointerMap* pointers, | 22 LPointerMap* pointers, |
23 Safepoint::DeoptMode mode) | 23 Safepoint::DeoptMode mode) |
24 : codegen_(codegen), | 24 : codegen_(codegen), |
25 pointers_(pointers), | 25 pointers_(pointers), |
26 deopt_mode_(mode) { } | 26 deopt_mode_(mode) { } |
27 virtual ~SafepointGenerator() {} | 27 virtual ~SafepointGenerator() {} |
28 | 28 |
29 virtual void BeforeCall(int call_size) const OVERRIDE {} | 29 void BeforeCall(int call_size) const OVERRIDE {} |
30 | 30 |
31 virtual void AfterCall() const OVERRIDE { | 31 void AfterCall() const OVERRIDE { |
32 codegen_->RecordSafepoint(pointers_, deopt_mode_); | 32 codegen_->RecordSafepoint(pointers_, deopt_mode_); |
33 } | 33 } |
34 | 34 |
35 private: | 35 private: |
36 LCodeGen* codegen_; | 36 LCodeGen* codegen_; |
37 LPointerMap* pointers_; | 37 LPointerMap* pointers_; |
38 Safepoint::DeoptMode deopt_mode_; | 38 Safepoint::DeoptMode deopt_mode_; |
39 }; | 39 }; |
40 | 40 |
41 | 41 |
(...skipping 2616 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2658 __ bind(&done); | 2658 __ bind(&done); |
2659 } | 2659 } |
2660 | 2660 |
2661 | 2661 |
2662 void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) { | 2662 void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) { |
2663 class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode { | 2663 class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode { |
2664 public: | 2664 public: |
2665 DeferredInstanceOfKnownGlobal(LCodeGen* codegen, | 2665 DeferredInstanceOfKnownGlobal(LCodeGen* codegen, |
2666 LInstanceOfKnownGlobal* instr) | 2666 LInstanceOfKnownGlobal* instr) |
2667 : LDeferredCode(codegen), instr_(instr) { } | 2667 : LDeferredCode(codegen), instr_(instr) { } |
2668 virtual void Generate() OVERRIDE { | 2668 void Generate() OVERRIDE { |
2669 codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_); | 2669 codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_); |
2670 } | 2670 } |
2671 virtual LInstruction* instr() OVERRIDE { return instr_; } | 2671 LInstruction* instr() OVERRIDE { return instr_; } |
2672 Label* map_check() { return &map_check_; } | 2672 Label* map_check() { return &map_check_; } |
2673 | 2673 |
2674 private: | 2674 private: |
2675 LInstanceOfKnownGlobal* instr_; | 2675 LInstanceOfKnownGlobal* instr_; |
2676 Label map_check_; | 2676 Label map_check_; |
2677 }; | 2677 }; |
2678 | 2678 |
2679 DeferredInstanceOfKnownGlobal* deferred; | 2679 DeferredInstanceOfKnownGlobal* deferred; |
2680 deferred = new(zone()) DeferredInstanceOfKnownGlobal(this, instr); | 2680 deferred = new(zone()) DeferredInstanceOfKnownGlobal(this, instr); |
2681 | 2681 |
(...skipping 1017 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3699 __ bind(&done); | 3699 __ bind(&done); |
3700 } | 3700 } |
3701 | 3701 |
3702 | 3702 |
3703 void LCodeGen::DoMathAbs(LMathAbs* instr) { | 3703 void LCodeGen::DoMathAbs(LMathAbs* instr) { |
3704 // Class for deferred case. | 3704 // Class for deferred case. |
3705 class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode { | 3705 class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode { |
3706 public: | 3706 public: |
3707 DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr) | 3707 DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr) |
3708 : LDeferredCode(codegen), instr_(instr) { } | 3708 : LDeferredCode(codegen), instr_(instr) { } |
3709 virtual void Generate() OVERRIDE { | 3709 void Generate() OVERRIDE { |
3710 codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_); | 3710 codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_); |
3711 } | 3711 } |
3712 virtual LInstruction* instr() OVERRIDE { return instr_; } | 3712 LInstruction* instr() OVERRIDE { return instr_; } |
| 3713 |
3713 private: | 3714 private: |
3714 LMathAbs* instr_; | 3715 LMathAbs* instr_; |
3715 }; | 3716 }; |
3716 | 3717 |
3717 Representation r = instr->hydrogen()->value()->representation(); | 3718 Representation r = instr->hydrogen()->value()->representation(); |
3718 if (r.IsDouble()) { | 3719 if (r.IsDouble()) { |
3719 FPURegister input = ToDoubleRegister(instr->value()); | 3720 FPURegister input = ToDoubleRegister(instr->value()); |
3720 FPURegister result = ToDoubleRegister(instr->result()); | 3721 FPURegister result = ToDoubleRegister(instr->result()); |
3721 __ abs_d(result, input); | 3722 __ abs_d(result, input); |
3722 } else if (r.IsSmiOrInteger32()) { | 3723 } else if (r.IsSmiOrInteger32()) { |
(...skipping 827 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4550 instr->hydrogen()->pretenure_flag()); | 4551 instr->hydrogen()->pretenure_flag()); |
4551 CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr); | 4552 CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr); |
4552 } | 4553 } |
4553 | 4554 |
4554 | 4555 |
4555 void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) { | 4556 void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) { |
4556 class DeferredStringCharCodeAt FINAL : public LDeferredCode { | 4557 class DeferredStringCharCodeAt FINAL : public LDeferredCode { |
4557 public: | 4558 public: |
4558 DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr) | 4559 DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr) |
4559 : LDeferredCode(codegen), instr_(instr) { } | 4560 : LDeferredCode(codegen), instr_(instr) { } |
4560 virtual void Generate() OVERRIDE { | 4561 void Generate() OVERRIDE { codegen()->DoDeferredStringCharCodeAt(instr_); } |
4561 codegen()->DoDeferredStringCharCodeAt(instr_); | 4562 LInstruction* instr() OVERRIDE { return instr_; } |
4562 } | 4563 |
4563 virtual LInstruction* instr() OVERRIDE { return instr_; } | |
4564 private: | 4564 private: |
4565 LStringCharCodeAt* instr_; | 4565 LStringCharCodeAt* instr_; |
4566 }; | 4566 }; |
4567 | 4567 |
4568 DeferredStringCharCodeAt* deferred = | 4568 DeferredStringCharCodeAt* deferred = |
4569 new(zone()) DeferredStringCharCodeAt(this, instr); | 4569 new(zone()) DeferredStringCharCodeAt(this, instr); |
4570 StringCharLoadGenerator::Generate(masm(), | 4570 StringCharLoadGenerator::Generate(masm(), |
4571 ToRegister(instr->string()), | 4571 ToRegister(instr->string()), |
4572 ToRegister(instr->index()), | 4572 ToRegister(instr->index()), |
4573 ToRegister(instr->result()), | 4573 ToRegister(instr->result()), |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4605 __ SmiUntag(v0); | 4605 __ SmiUntag(v0); |
4606 __ StoreToSafepointRegisterSlot(v0, result); | 4606 __ StoreToSafepointRegisterSlot(v0, result); |
4607 } | 4607 } |
4608 | 4608 |
4609 | 4609 |
4610 void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) { | 4610 void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) { |
4611 class DeferredStringCharFromCode FINAL : public LDeferredCode { | 4611 class DeferredStringCharFromCode FINAL : public LDeferredCode { |
4612 public: | 4612 public: |
4613 DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr) | 4613 DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr) |
4614 : LDeferredCode(codegen), instr_(instr) { } | 4614 : LDeferredCode(codegen), instr_(instr) { } |
4615 virtual void Generate() OVERRIDE { | 4615 void Generate() OVERRIDE { |
4616 codegen()->DoDeferredStringCharFromCode(instr_); | 4616 codegen()->DoDeferredStringCharFromCode(instr_); |
4617 } | 4617 } |
4618 virtual LInstruction* instr() OVERRIDE { return instr_; } | 4618 LInstruction* instr() OVERRIDE { return instr_; } |
| 4619 |
4619 private: | 4620 private: |
4620 LStringCharFromCode* instr_; | 4621 LStringCharFromCode* instr_; |
4621 }; | 4622 }; |
4622 | 4623 |
4623 DeferredStringCharFromCode* deferred = | 4624 DeferredStringCharFromCode* deferred = |
4624 new(zone()) DeferredStringCharFromCode(this, instr); | 4625 new(zone()) DeferredStringCharFromCode(this, instr); |
4625 | 4626 |
4626 DCHECK(instr->hydrogen()->value()->representation().IsInteger32()); | 4627 DCHECK(instr->hydrogen()->value()->representation().IsInteger32()); |
4627 Register char_code = ToRegister(instr->char_code()); | 4628 Register char_code = ToRegister(instr->char_code()); |
4628 Register result = ToRegister(instr->result()); | 4629 Register result = ToRegister(instr->result()); |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4683 __ mtc1(ToRegister(input), dbl_scratch); | 4684 __ mtc1(ToRegister(input), dbl_scratch); |
4684 __ Cvt_d_uw(ToDoubleRegister(output), dbl_scratch, f22); // TODO(plind): f22? | 4685 __ Cvt_d_uw(ToDoubleRegister(output), dbl_scratch, f22); // TODO(plind): f22? |
4685 } | 4686 } |
4686 | 4687 |
4687 | 4688 |
4688 void LCodeGen::DoNumberTagU(LNumberTagU* instr) { | 4689 void LCodeGen::DoNumberTagU(LNumberTagU* instr) { |
4689 class DeferredNumberTagU FINAL : public LDeferredCode { | 4690 class DeferredNumberTagU FINAL : public LDeferredCode { |
4690 public: | 4691 public: |
4691 DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr) | 4692 DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr) |
4692 : LDeferredCode(codegen), instr_(instr) { } | 4693 : LDeferredCode(codegen), instr_(instr) { } |
4693 virtual void Generate() OVERRIDE { | 4694 void Generate() OVERRIDE { |
4694 codegen()->DoDeferredNumberTagIU(instr_, | 4695 codegen()->DoDeferredNumberTagIU(instr_, |
4695 instr_->value(), | 4696 instr_->value(), |
4696 instr_->temp1(), | 4697 instr_->temp1(), |
4697 instr_->temp2(), | 4698 instr_->temp2(), |
4698 UNSIGNED_INT32); | 4699 UNSIGNED_INT32); |
4699 } | 4700 } |
4700 virtual LInstruction* instr() OVERRIDE { return instr_; } | 4701 LInstruction* instr() OVERRIDE { return instr_; } |
| 4702 |
4701 private: | 4703 private: |
4702 LNumberTagU* instr_; | 4704 LNumberTagU* instr_; |
4703 }; | 4705 }; |
4704 | 4706 |
4705 Register input = ToRegister(instr->value()); | 4707 Register input = ToRegister(instr->value()); |
4706 Register result = ToRegister(instr->result()); | 4708 Register result = ToRegister(instr->result()); |
4707 | 4709 |
4708 DeferredNumberTagU* deferred = new(zone()) DeferredNumberTagU(this, instr); | 4710 DeferredNumberTagU* deferred = new(zone()) DeferredNumberTagU(this, instr); |
4709 __ Branch(deferred->entry(), hi, input, Operand(Smi::kMaxValue)); | 4711 __ Branch(deferred->entry(), hi, input, Operand(Smi::kMaxValue)); |
4710 __ SmiTag(result, input); | 4712 __ SmiTag(result, input); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4773 __ bind(&done); | 4775 __ bind(&done); |
4774 __ sdc1(dbl_scratch, FieldMemOperand(dst, HeapNumber::kValueOffset)); | 4776 __ sdc1(dbl_scratch, FieldMemOperand(dst, HeapNumber::kValueOffset)); |
4775 } | 4777 } |
4776 | 4778 |
4777 | 4779 |
4778 void LCodeGen::DoNumberTagD(LNumberTagD* instr) { | 4780 void LCodeGen::DoNumberTagD(LNumberTagD* instr) { |
4779 class DeferredNumberTagD FINAL : public LDeferredCode { | 4781 class DeferredNumberTagD FINAL : public LDeferredCode { |
4780 public: | 4782 public: |
4781 DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr) | 4783 DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr) |
4782 : LDeferredCode(codegen), instr_(instr) { } | 4784 : LDeferredCode(codegen), instr_(instr) { } |
4783 virtual void Generate() OVERRIDE { | 4785 void Generate() OVERRIDE { codegen()->DoDeferredNumberTagD(instr_); } |
4784 codegen()->DoDeferredNumberTagD(instr_); | 4786 LInstruction* instr() OVERRIDE { return instr_; } |
4785 } | 4787 |
4786 virtual LInstruction* instr() OVERRIDE { return instr_; } | |
4787 private: | 4788 private: |
4788 LNumberTagD* instr_; | 4789 LNumberTagD* instr_; |
4789 }; | 4790 }; |
4790 | 4791 |
4791 DoubleRegister input_reg = ToDoubleRegister(instr->value()); | 4792 DoubleRegister input_reg = ToDoubleRegister(instr->value()); |
4792 Register scratch = scratch0(); | 4793 Register scratch = scratch0(); |
4793 Register reg = ToRegister(instr->result()); | 4794 Register reg = ToRegister(instr->result()); |
4794 Register temp1 = ToRegister(instr->temp()); | 4795 Register temp1 = ToRegister(instr->temp()); |
4795 Register temp2 = ToRegister(instr->temp2()); | 4796 Register temp2 = ToRegister(instr->temp2()); |
4796 | 4797 |
(...skipping 202 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4999 } | 5000 } |
5000 __ bind(&done); | 5001 __ bind(&done); |
5001 } | 5002 } |
5002 | 5003 |
5003 | 5004 |
5004 void LCodeGen::DoTaggedToI(LTaggedToI* instr) { | 5005 void LCodeGen::DoTaggedToI(LTaggedToI* instr) { |
5005 class DeferredTaggedToI FINAL : public LDeferredCode { | 5006 class DeferredTaggedToI FINAL : public LDeferredCode { |
5006 public: | 5007 public: |
5007 DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr) | 5008 DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr) |
5008 : LDeferredCode(codegen), instr_(instr) { } | 5009 : LDeferredCode(codegen), instr_(instr) { } |
5009 virtual void Generate() OVERRIDE { | 5010 void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_); } |
5010 codegen()->DoDeferredTaggedToI(instr_); | 5011 LInstruction* instr() OVERRIDE { return instr_; } |
5011 } | 5012 |
5012 virtual LInstruction* instr() OVERRIDE { return instr_; } | |
5013 private: | 5013 private: |
5014 LTaggedToI* instr_; | 5014 LTaggedToI* instr_; |
5015 }; | 5015 }; |
5016 | 5016 |
5017 LOperand* input = instr->value(); | 5017 LOperand* input = instr->value(); |
5018 DCHECK(input->IsRegister()); | 5018 DCHECK(input->IsRegister()); |
5019 DCHECK(input->Equals(instr->result())); | 5019 DCHECK(input->Equals(instr->result())); |
5020 | 5020 |
5021 Register input_reg = ToRegister(input); | 5021 Register input_reg = ToRegister(input); |
5022 | 5022 |
(...skipping 184 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5207 } | 5207 } |
5208 | 5208 |
5209 | 5209 |
5210 void LCodeGen::DoCheckMaps(LCheckMaps* instr) { | 5210 void LCodeGen::DoCheckMaps(LCheckMaps* instr) { |
5211 class DeferredCheckMaps FINAL : public LDeferredCode { | 5211 class DeferredCheckMaps FINAL : public LDeferredCode { |
5212 public: | 5212 public: |
5213 DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object) | 5213 DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object) |
5214 : LDeferredCode(codegen), instr_(instr), object_(object) { | 5214 : LDeferredCode(codegen), instr_(instr), object_(object) { |
5215 SetExit(check_maps()); | 5215 SetExit(check_maps()); |
5216 } | 5216 } |
5217 virtual void Generate() OVERRIDE { | 5217 void Generate() OVERRIDE { |
5218 codegen()->DoDeferredInstanceMigration(instr_, object_); | 5218 codegen()->DoDeferredInstanceMigration(instr_, object_); |
5219 } | 5219 } |
5220 Label* check_maps() { return &check_maps_; } | 5220 Label* check_maps() { return &check_maps_; } |
5221 virtual LInstruction* instr() OVERRIDE { return instr_; } | 5221 LInstruction* instr() OVERRIDE { return instr_; } |
| 5222 |
5222 private: | 5223 private: |
5223 LCheckMaps* instr_; | 5224 LCheckMaps* instr_; |
5224 Label check_maps_; | 5225 Label check_maps_; |
5225 Register object_; | 5226 Register object_; |
5226 }; | 5227 }; |
5227 | 5228 |
5228 if (instr->hydrogen()->IsStabilityCheck()) { | 5229 if (instr->hydrogen()->IsStabilityCheck()) { |
5229 const UniqueSet<Map>* maps = instr->hydrogen()->maps(); | 5230 const UniqueSet<Map>* maps = instr->hydrogen()->maps(); |
5230 for (int i = 0; i < maps->size(); ++i) { | 5231 for (int i = 0; i < maps->size(); ++i) { |
5231 AddStabilityDependency(maps->at(i).handle()); | 5232 AddStabilityDependency(maps->at(i).handle()); |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5330 DoubleRegister result_reg = ToDoubleRegister(instr->result()); | 5331 DoubleRegister result_reg = ToDoubleRegister(instr->result()); |
5331 __ Move(result_reg, lo_reg, hi_reg); | 5332 __ Move(result_reg, lo_reg, hi_reg); |
5332 } | 5333 } |
5333 | 5334 |
5334 | 5335 |
5335 void LCodeGen::DoAllocate(LAllocate* instr) { | 5336 void LCodeGen::DoAllocate(LAllocate* instr) { |
5336 class DeferredAllocate FINAL : public LDeferredCode { | 5337 class DeferredAllocate FINAL : public LDeferredCode { |
5337 public: | 5338 public: |
5338 DeferredAllocate(LCodeGen* codegen, LAllocate* instr) | 5339 DeferredAllocate(LCodeGen* codegen, LAllocate* instr) |
5339 : LDeferredCode(codegen), instr_(instr) { } | 5340 : LDeferredCode(codegen), instr_(instr) { } |
5340 virtual void Generate() OVERRIDE { | 5341 void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); } |
5341 codegen()->DoDeferredAllocate(instr_); | 5342 LInstruction* instr() OVERRIDE { return instr_; } |
5342 } | 5343 |
5343 virtual LInstruction* instr() OVERRIDE { return instr_; } | |
5344 private: | 5344 private: |
5345 LAllocate* instr_; | 5345 LAllocate* instr_; |
5346 }; | 5346 }; |
5347 | 5347 |
5348 DeferredAllocate* deferred = | 5348 DeferredAllocate* deferred = |
5349 new(zone()) DeferredAllocate(this, instr); | 5349 new(zone()) DeferredAllocate(this, instr); |
5350 | 5350 |
5351 Register result = ToRegister(instr->result()); | 5351 Register result = ToRegister(instr->result()); |
5352 Register scratch = ToRegister(instr->temp1()); | 5352 Register scratch = ToRegister(instr->temp1()); |
5353 Register scratch2 = ToRegister(instr->temp2()); | 5353 Register scratch2 = ToRegister(instr->temp2()); |
(...skipping 391 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5745 LEnvironment* env = instr->environment(); | 5745 LEnvironment* env = instr->environment(); |
5746 safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index()); | 5746 safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index()); |
5747 } | 5747 } |
5748 | 5748 |
5749 | 5749 |
5750 void LCodeGen::DoStackCheck(LStackCheck* instr) { | 5750 void LCodeGen::DoStackCheck(LStackCheck* instr) { |
5751 class DeferredStackCheck FINAL : public LDeferredCode { | 5751 class DeferredStackCheck FINAL : public LDeferredCode { |
5752 public: | 5752 public: |
5753 DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr) | 5753 DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr) |
5754 : LDeferredCode(codegen), instr_(instr) { } | 5754 : LDeferredCode(codegen), instr_(instr) { } |
5755 virtual void Generate() OVERRIDE { | 5755 void Generate() OVERRIDE { codegen()->DoDeferredStackCheck(instr_); } |
5756 codegen()->DoDeferredStackCheck(instr_); | 5756 LInstruction* instr() OVERRIDE { return instr_; } |
5757 } | 5757 |
5758 virtual LInstruction* instr() OVERRIDE { return instr_; } | |
5759 private: | 5758 private: |
5760 LStackCheck* instr_; | 5759 LStackCheck* instr_; |
5761 }; | 5760 }; |
5762 | 5761 |
5763 DCHECK(instr->HasEnvironment()); | 5762 DCHECK(instr->HasEnvironment()); |
5764 LEnvironment* env = instr->environment(); | 5763 LEnvironment* env = instr->environment(); |
5765 // There is no LLazyBailout instruction for stack-checks. We have to | 5764 // There is no LLazyBailout instruction for stack-checks. We have to |
5766 // prepare for lazy deoptimization explicitly here. | 5765 // prepare for lazy deoptimization explicitly here. |
5767 if (instr->hydrogen()->is_function_entry()) { | 5766 if (instr->hydrogen()->is_function_entry()) { |
5768 // Perform stack overflow check. | 5767 // Perform stack overflow check. |
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5896 LLoadFieldByIndex* instr, | 5895 LLoadFieldByIndex* instr, |
5897 Register result, | 5896 Register result, |
5898 Register object, | 5897 Register object, |
5899 Register index) | 5898 Register index) |
5900 : LDeferredCode(codegen), | 5899 : LDeferredCode(codegen), |
5901 instr_(instr), | 5900 instr_(instr), |
5902 result_(result), | 5901 result_(result), |
5903 object_(object), | 5902 object_(object), |
5904 index_(index) { | 5903 index_(index) { |
5905 } | 5904 } |
5906 virtual void Generate() OVERRIDE { | 5905 void Generate() OVERRIDE { |
5907 codegen()->DoDeferredLoadMutableDouble(instr_, result_, object_, index_); | 5906 codegen()->DoDeferredLoadMutableDouble(instr_, result_, object_, index_); |
5908 } | 5907 } |
5909 virtual LInstruction* instr() OVERRIDE { return instr_; } | 5908 LInstruction* instr() OVERRIDE { return instr_; } |
| 5909 |
5910 private: | 5910 private: |
5911 LLoadFieldByIndex* instr_; | 5911 LLoadFieldByIndex* instr_; |
5912 Register result_; | 5912 Register result_; |
5913 Register object_; | 5913 Register object_; |
5914 Register index_; | 5914 Register index_; |
5915 }; | 5915 }; |
5916 | 5916 |
5917 Register object = ToRegister(instr->object()); | 5917 Register object = ToRegister(instr->object()); |
5918 Register index = ToRegister(instr->index()); | 5918 Register index = ToRegister(instr->index()); |
5919 Register result = ToRegister(instr->result()); | 5919 Register result = ToRegister(instr->result()); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5958 __ li(at, scope_info); | 5958 __ li(at, scope_info); |
5959 __ Push(at, ToRegister(instr->function())); | 5959 __ Push(at, ToRegister(instr->function())); |
5960 CallRuntime(Runtime::kPushBlockContext, 2, instr); | 5960 CallRuntime(Runtime::kPushBlockContext, 2, instr); |
5961 RecordSafepoint(Safepoint::kNoLazyDeopt); | 5961 RecordSafepoint(Safepoint::kNoLazyDeopt); |
5962 } | 5962 } |
5963 | 5963 |
5964 | 5964 |
5965 #undef __ | 5965 #undef __ |
5966 | 5966 |
5967 } } // namespace v8::internal | 5967 } } // namespace v8::internal |
OLD | NEW |