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 3 // found in the LICENSE file. 4 5 #ifndef V8_X64_LITHIUM_X64_H_ 6 #define V8_X64_LITHIUM_X64_H_ 7 8 #include "src/hydrogen.h" 9 #include "src/lithium.h" 10 #include "src/lithium-allocator.h" 11 #include "src/safepoint-table.h" 12 #include "src/utils.h" 13 14 namespace v8 { 15 namespace internal { 16 17 // Forward declarations. 18 class LCodeGen; 19 20 #define LITHIUM_CONCRETE_INSTRUCTION_LIST(V) \ 21 V(AccessArgumentsAt) \ 22 V(AddI) \ 23 V(Allocate) \ 24 V(AllocateBlockContext) \ 25 V(ApplyArguments) \ 26 V(ArgumentsElements) \ 27 V(ArgumentsLength) \ 28 V(ArithmeticD) \ 29 V(ArithmeticT) \ 30 V(BitI) \ 31 V(BoundsCheck) \ 32 V(Branch) \ 33 V(CallJSFunction) \ 34 V(CallWithDescriptor) \ 35 V(CallFunction) \ 36 V(CallNew) \ 37 V(CallNewArray) \ 38 V(CallRuntime) \ 39 V(CallStub) \ 40 V(CheckInstanceType) \ 41 V(CheckMaps) \ 42 V(CheckMapValue) \ 43 V(CheckNonSmi) \ 44 V(CheckSmi) \ 45 V(CheckValue) \ 46 V(ClampDToUint8) \ 47 V(ClampIToUint8) \ 48 V(ClampTToUint8) \ 49 V(ClassOfTestAndBranch) \ 50 V(CompareMinusZeroAndBranch) \ 51 V(CompareNumericAndBranch) \ 52 V(CmpObjectEqAndBranch) \ 53 V(CmpHoleAndBranch) \ 54 V(CmpMapAndBranch) \ 55 V(CmpT) \ 56 V(ConstantD) \ 57 V(ConstantE) \ 58 V(ConstantI) \ 59 V(ConstantS) \ 60 V(ConstantT) \ 61 V(ConstructDouble) \ 62 V(Context) \ 63 V(DateField) \ 64 V(DebugBreak) \ 65 V(DeclareGlobals) \ 66 V(Deoptimize) \ 67 V(DivByConstI) \ 68 V(DivByPowerOf2I) \ 69 V(DivI) \ 70 V(DoubleBits) \ 71 V(DoubleToI) \ 72 V(DoubleToSmi) \ 73 V(Drop) \ 74 V(DummyUse) \ 75 V(Dummy) \ 76 V(FlooringDivByConstI) \ 77 V(FlooringDivByPowerOf2I) \ 78 V(FlooringDivI) \ 79 V(ForInCacheArray) \ 80 V(ForInPrepareMap) \ 81 V(FunctionLiteral) \ 82 V(GetCachedArrayIndex) \ 83 V(Goto) \ 84 V(HasCachedArrayIndexAndBranch) \ 85 V(HasInstanceTypeAndBranch) \ 86 V(InnerAllocatedObject) \ 87 V(InstanceOf) \ 88 V(InstanceOfKnownGlobal) \ 89 V(InstructionGap) \ 90 V(Integer32ToDouble) \ 91 V(InvokeFunction) \ 92 V(IsConstructCallAndBranch) \ 93 V(IsObjectAndBranch) \ 94 V(IsStringAndBranch) \ 95 V(IsSmiAndBranch) \ 96 V(IsUndetectableAndBranch) \ 97 V(Label) \ 98 V(LazyBailout) \ 99 V(LoadContextSlot) \ 100 V(LoadRoot) \ 101 V(LoadFieldByIndex) \ 102 V(LoadFunctionPrototype) \ 103 V(LoadGlobalCell) \ 104 V(LoadGlobalGeneric) \ 105 V(LoadKeyed) \ 106 V(LoadKeyedGeneric) \ 107 V(LoadNamedField) \ 108 V(LoadNamedGeneric) \ 109 V(MapEnumLength) \ 110 V(MathAbs) \ 111 V(MathClz32) \ 112 V(MathExp) \ 113 V(MathFloor) \ 114 V(MathFround) \ 115 V(MathLog) \ 116 V(MathMinMax) \ 117 V(MathPowHalf) \ 118 V(MathRound) \ 119 V(MathSqrt) \ 120 V(ModByConstI) \ 121 V(ModByPowerOf2I) \ 122 V(ModI) \ 123 V(MulI) \ 124 V(NumberTagD) \ 125 V(NumberTagI) \ 126 V(NumberTagU) \ 127 V(NumberUntagD) \ 128 V(OsrEntry) \ 129 V(Parameter) \ 130 V(Power) \ 131 V(PushArgument) \ 132 V(RegExpLiteral) \ 133 V(Return) \ 134 V(SeqStringGetChar) \ 135 V(SeqStringSetChar) \ 136 V(ShiftI) \ 137 V(SmiTag) \ 138 V(SmiUntag) \ 139 V(StackCheck) \ 140 V(StoreCodeEntry) \ 141 V(StoreContextSlot) \ 142 V(StoreFrameContext) \ 143 V(StoreGlobalCell) \ 144 V(StoreKeyed) \ 145 V(StoreKeyedGeneric) \ 146 V(StoreNamedField) \ 147 V(StoreNamedGeneric) \ 148 V(StringAdd) \ 149 V(StringCharCodeAt) \ 150 V(StringCharFromCode) \ 151 V(StringCompareAndBranch) \ 152 V(SubI) \ 153 V(TaggedToI) \ 154 V(TailCallThroughMegamorphicCache) \ 155 V(ThisFunction) \ 156 V(ToFastProperties) \ 157 V(TransitionElementsKind) \ 158 V(TrapAllocationMemento) \ 159 V(Typeof) \ 160 V(TypeofIsAndBranch) \ 161 V(Uint32ToDouble) \ 162 V(UnknownOSRValue) \ 163 V(WrapReceiver) 164 165 166 #define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \ 167 virtual Opcode opcode() const FINAL OVERRIDE { \ 168 return LInstruction::k##type; \ 169 } \ 170 virtual void CompileToNative(LCodeGen* generator) FINAL OVERRIDE; \ 171 virtual const char* Mnemonic() const FINAL OVERRIDE { \ 172 return mnemonic; \ 173 } \ 174 static L##type* cast(LInstruction* instr) { \ 175 DCHECK(instr->Is##type()); \ 176 return reinterpret_cast<L##type*>(instr); \ 177 } 178 179 180 #define DECLARE_HYDROGEN_ACCESSOR(type) \ 181 H##type* hydrogen() const { \ 182 return H##type::cast(hydrogen_value()); \ 183 } 184 185 186 class LInstruction : public ZoneObject { 187 public: 188 LInstruction() 189 : environment_(NULL), 190 hydrogen_value_(NULL), 191 bit_field_(IsCallBits::encode(false)) { 192 } 193 194 virtual ~LInstruction() {} 195 196 virtual void CompileToNative(LCodeGen* generator) = 0; 197 virtual const char* Mnemonic() const = 0; 198 virtual void PrintTo(StringStream* stream); 199 virtual void PrintDataTo(StringStream* stream); 200 virtual void PrintOutputOperandTo(StringStream* stream); 201 202 enum Opcode { 203 // Declare a unique enum value for each instruction. 204 #define DECLARE_OPCODE(type) k##type, 205 LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE) 206 kNumberOfInstructions 207 #undef DECLARE_OPCODE 208 }; 209 210 virtual Opcode opcode() const = 0; 211 212 // Declare non-virtual type testers for all leaf IR classes. 213 #define DECLARE_PREDICATE(type) \ 214 bool Is##type() const { return opcode() == k##type; } 215 LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_PREDICATE) 216 #undef DECLARE_PREDICATE 217 218 // Declare virtual predicates for instructions that don't have 219 // an opcode. 220 virtual bool IsGap() const { return false; } 221 222 virtual bool IsControl() const { return false; } 223 224 // Try deleting this instruction if possible. 225 virtual bool TryDelete() { return false; } 226 227 void set_environment(LEnvironment* env) { environment_ = env; } 228 LEnvironment* environment() const { return environment_; } 229 bool HasEnvironment() const { return environment_ != NULL; } 230 231 void set_pointer_map(LPointerMap* p) { pointer_map_.set(p); } 232 LPointerMap* pointer_map() const { return pointer_map_.get(); } 233 bool HasPointerMap() const { return pointer_map_.is_set(); } 234 235 void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; } 236 HValue* hydrogen_value() const { return hydrogen_value_; } 237 238 void MarkAsCall() { bit_field_ = IsCallBits::update(bit_field_, true); } 239 bool IsCall() const { return IsCallBits::decode(bit_field_); } 240 241 // Interface to the register allocator and iterators. 242 bool ClobbersTemps() const { return IsCall(); } 243 bool ClobbersRegisters() const { return IsCall(); } 244 virtual bool ClobbersDoubleRegisters(Isolate* isolate) const { 245 return IsCall(); 246 } 247 248 virtual void SetDeferredLazyDeoptimizationEnvironment(LEnvironment* env) { } 249 250 // Interface to the register allocator and iterators. 251 bool IsMarkedAsCall() const { return IsCall(); } 252 253 virtual bool HasResult() const = 0; 254 virtual LOperand* result() const = 0; 255 256 LOperand* FirstInput() { return InputAt(0); } 257 LOperand* Output() { return HasResult() ? result() : NULL; } 258 259 virtual bool HasInterestingComment(LCodeGen* gen) const { return true; } 260 261 virtual bool MustSignExtendResult(LPlatformChunk* chunk) const { 262 return false; 263 } 264 265 #ifdef DEBUG 266 void VerifyCall(); 267 #endif 268 269 virtual int InputCount() = 0; 270 virtual LOperand* InputAt(int i) = 0; 271 272 private: 273 // Iterator support. 274 friend class InputIterator; 275 276 friend class TempIterator; 277 virtual int TempCount() = 0; 278 virtual LOperand* TempAt(int i) = 0; 279 280 class IsCallBits: public BitField<bool, 0, 1> {}; 281 282 LEnvironment* environment_; 283 SetOncePointer<LPointerMap> pointer_map_; 284 HValue* hydrogen_value_; 285 int bit_field_; 286 }; 287 288 289 // R = number of result operands (0 or 1). 290 template<int R> 291 class LTemplateResultInstruction : public LInstruction { 292 public: 293 // Allow 0 or 1 output operands. 294 STATIC_ASSERT(R == 0 || R == 1); 295 virtual bool HasResult() const FINAL OVERRIDE { 296 return R != 0 && result() != NULL; 297 } 298 void set_result(LOperand* operand) { results_[0] = operand; } 299 LOperand* result() const { return results_[0]; } 300 301 virtual bool MustSignExtendResult( 302 LPlatformChunk* chunk) const FINAL OVERRIDE; 303 304 protected: 305 EmbeddedContainer<LOperand*, R> results_; 306 }; 307 308 309 // R = number of result operands (0 or 1). 310 // I = number of input operands. 311 // T = number of temporary operands. 312 template<int R, int I, int T> 313 class LTemplateInstruction : public LTemplateResultInstruction<R> { 314 protected: 315 EmbeddedContainer<LOperand*, I> inputs_; 316 EmbeddedContainer<LOperand*, T> temps_; 317 318 private: 319 // Iterator support. 320 virtual int InputCount() FINAL OVERRIDE { return I; } 321 virtual LOperand* InputAt(int i) FINAL OVERRIDE { return inputs_[i]; } 322 323 virtual int TempCount() FINAL OVERRIDE { return T; } 324 virtual LOperand* TempAt(int i) FINAL OVERRIDE { return temps_[i]; } 325 }; 326 327 328 class LGap : public LTemplateInstruction<0, 0, 0> { 329 public: 330 explicit LGap(HBasicBlock* block) 331 : block_(block) { 332 parallel_moves_[BEFORE] = NULL; 333 parallel_moves_[START] = NULL; 334 parallel_moves_[END] = NULL; 335 parallel_moves_[AFTER] = NULL; 336 } 337 338 // Can't use the DECLARE-macro here because of sub-classes. 339 virtual bool IsGap() const FINAL OVERRIDE { return true; } 340 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 341 static LGap* cast(LInstruction* instr) { 342 DCHECK(instr->IsGap()); 343 return reinterpret_cast<LGap*>(instr); 344 } 345 346 bool IsRedundant() const; 347 348 HBasicBlock* block() const { return block_; } 349 350 enum InnerPosition { 351 BEFORE, 352 START, 353 END, 354 AFTER, 355 FIRST_INNER_POSITION = BEFORE, 356 LAST_INNER_POSITION = AFTER 357 }; 358 359 LParallelMove* GetOrCreateParallelMove(InnerPosition pos, 360 Zone* zone) { 361 if (parallel_moves_[pos] == NULL) { 362 parallel_moves_[pos] = new(zone) LParallelMove(zone); 363 } 364 return parallel_moves_[pos]; 365 } 366 367 LParallelMove* GetParallelMove(InnerPosition pos) { 368 return parallel_moves_[pos]; 369 } 370 371 private: 372 LParallelMove* parallel_moves_[LAST_INNER_POSITION + 1]; 373 HBasicBlock* block_; 374 }; 375 376 377 class LInstructionGap FINAL : public LGap { 378 public: 379 explicit LInstructionGap(HBasicBlock* block) : LGap(block) { } 380 381 virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { 382 return !IsRedundant(); 383 } 384 385 DECLARE_CONCRETE_INSTRUCTION(InstructionGap, "gap") 386 }; 387 388 389 class LGoto FINAL : public LTemplateInstruction<0, 0, 0> { 390 public: 391 explicit LGoto(HBasicBlock* block) : block_(block) { } 392 393 virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE; 394 DECLARE_CONCRETE_INSTRUCTION(Goto, "goto") 395 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 396 virtual bool IsControl() const OVERRIDE { return true; } 397 398 int block_id() const { return block_->block_id(); } 399 400 private: 401 HBasicBlock* block_; 402 }; 403 404 405 class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> { 406 public: 407 LLazyBailout() : gap_instructions_size_(0) { } 408 409 DECLARE_CONCRETE_INSTRUCTION(LazyBailout, "lazy-bailout") 410 411 void set_gap_instructions_size(int gap_instructions_size) { 412 gap_instructions_size_ = gap_instructions_size; 413 } 414 int gap_instructions_size() { return gap_instructions_size_; } 415 416 private: 417 int gap_instructions_size_; 418 }; 419 420 421 class LDummy FINAL : public LTemplateInstruction<1, 0, 0> { 422 public: 423 LDummy() {} 424 DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy") 425 }; 426 427 428 class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> { 429 public: 430 explicit LDummyUse(LOperand* value) { 431 inputs_[0] = value; 432 } 433 DECLARE_CONCRETE_INSTRUCTION(DummyUse, "dummy-use") 434 }; 435 436 437 class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> { 438 public: 439 virtual bool IsControl() const OVERRIDE { return true; } 440 DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize") 441 DECLARE_HYDROGEN_ACCESSOR(Deoptimize) 442 }; 443 444 445 class LLabel FINAL : public LGap { 446 public: 447 explicit LLabel(HBasicBlock* block) 448 : LGap(block), replacement_(NULL) { } 449 450 virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { 451 return false; 452 } 453 DECLARE_CONCRETE_INSTRUCTION(Label, "label") 454 455 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 456 457 int block_id() const { return block()->block_id(); } 458 bool is_loop_header() const { return block()->IsLoopHeader(); } 459 bool is_osr_entry() const { return block()->is_osr_entry(); } 460 Label* label() { return &label_; } 461 LLabel* replacement() const { return replacement_; } 462 void set_replacement(LLabel* label) { replacement_ = label; } 463 bool HasReplacement() const { return replacement_ != NULL; } 464 465 private: 466 Label label_; 467 LLabel* replacement_; 468 }; 469 470 471 class LParameter FINAL : public LTemplateInstruction<1, 0, 0> { 472 public: 473 virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { 474 return false; 475 } 476 DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter") 477 }; 478 479 480 class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> { 481 public: 482 explicit LCallStub(LOperand* context) { 483 inputs_[0] = context; 484 } 485 486 LOperand* context() { return inputs_[0]; } 487 488 DECLARE_CONCRETE_INSTRUCTION(CallStub, "call-stub") 489 DECLARE_HYDROGEN_ACCESSOR(CallStub) 490 }; 491 492 493 class LTailCallThroughMegamorphicCache FINAL 494 : public LTemplateInstruction<0, 3, 0> { 495 public: 496 explicit LTailCallThroughMegamorphicCache(LOperand* context, 497 LOperand* receiver, 498 LOperand* name) { 499 inputs_[0] = context; 500 inputs_[1] = receiver; 501 inputs_[2] = name; 502 } 503 504 LOperand* context() { return inputs_[0]; } 505 LOperand* receiver() { return inputs_[1]; } 506 LOperand* name() { return inputs_[2]; } 507 508 DECLARE_CONCRETE_INSTRUCTION(TailCallThroughMegamorphicCache, 509 "tail-call-through-megamorphic-cache") 510 DECLARE_HYDROGEN_ACCESSOR(TailCallThroughMegamorphicCache) 511 }; 512 513 514 class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> { 515 public: 516 virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { 517 return false; 518 } 519 DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value") 520 }; 521 522 523 template<int I, int T> 524 class LControlInstruction : public LTemplateInstruction<0, I, T> { 525 public: 526 LControlInstruction() : false_label_(NULL), true_label_(NULL) { } 527 528 virtual bool IsControl() const FINAL OVERRIDE { return true; } 529 530 int SuccessorCount() { return hydrogen()->SuccessorCount(); } 531 HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); } 532 533 int TrueDestination(LChunk* chunk) { 534 return chunk->LookupDestination(true_block_id()); 535 } 536 int FalseDestination(LChunk* chunk) { 537 return chunk->LookupDestination(false_block_id()); 538 } 539 540 Label* TrueLabel(LChunk* chunk) { 541 if (true_label_ == NULL) { 542 true_label_ = chunk->GetAssemblyLabel(TrueDestination(chunk)); 543 } 544 return true_label_; 545 } 546 Label* FalseLabel(LChunk* chunk) { 547 if (false_label_ == NULL) { 548 false_label_ = chunk->GetAssemblyLabel(FalseDestination(chunk)); 549 } 550 return false_label_; 551 } 552 553 protected: 554 int true_block_id() { return SuccessorAt(0)->block_id(); } 555 int false_block_id() { return SuccessorAt(1)->block_id(); } 556 557 private: 558 HControlInstruction* hydrogen() { 559 return HControlInstruction::cast(this->hydrogen_value()); 560 } 561 562 Label* false_label_; 563 Label* true_label_; 564 }; 565 566 567 class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 0> { 568 public: 569 LWrapReceiver(LOperand* receiver, LOperand* function) { 570 inputs_[0] = receiver; 571 inputs_[1] = function; 572 } 573 574 LOperand* receiver() { return inputs_[0]; } 575 LOperand* function() { return inputs_[1]; } 576 577 DECLARE_CONCRETE_INSTRUCTION(WrapReceiver, "wrap-receiver") 578 DECLARE_HYDROGEN_ACCESSOR(WrapReceiver) 579 }; 580 581 582 class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> { 583 public: 584 LApplyArguments(LOperand* function, 585 LOperand* receiver, 586 LOperand* length, 587 LOperand* elements) { 588 inputs_[0] = function; 589 inputs_[1] = receiver; 590 inputs_[2] = length; 591 inputs_[3] = elements; 592 } 593 594 LOperand* function() { return inputs_[0]; } 595 LOperand* receiver() { return inputs_[1]; } 596 LOperand* length() { return inputs_[2]; } 597 LOperand* elements() { return inputs_[3]; } 598 599 DECLARE_CONCRETE_INSTRUCTION(ApplyArguments, "apply-arguments") 600 }; 601 602 603 class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> { 604 public: 605 LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) { 606 inputs_[0] = arguments; 607 inputs_[1] = length; 608 inputs_[2] = index; 609 } 610 611 LOperand* arguments() { return inputs_[0]; } 612 LOperand* length() { return inputs_[1]; } 613 LOperand* index() { return inputs_[2]; } 614 615 DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at") 616 617 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 618 }; 619 620 621 class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> { 622 public: 623 explicit LArgumentsLength(LOperand* elements) { 624 inputs_[0] = elements; 625 } 626 627 LOperand* elements() { return inputs_[0]; } 628 629 DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength, "arguments-length") 630 }; 631 632 633 class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> { 634 public: 635 DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements") 636 DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements) 637 }; 638 639 640 class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> { 641 public: 642 LModByPowerOf2I(LOperand* dividend, int32_t divisor) { 643 inputs_[0] = dividend; 644 divisor_ = divisor; 645 } 646 647 LOperand* dividend() { return inputs_[0]; } 648 int32_t divisor() const { return divisor_; } 649 650 DECLARE_CONCRETE_INSTRUCTION(ModByPowerOf2I, "mod-by-power-of-2-i") 651 DECLARE_HYDROGEN_ACCESSOR(Mod) 652 653 private: 654 int32_t divisor_; 655 }; 656 657 658 class LModByConstI FINAL : public LTemplateInstruction<1, 1, 2> { 659 public: 660 LModByConstI(LOperand* dividend, 661 int32_t divisor, 662 LOperand* temp1, 663 LOperand* temp2) { 664 inputs_[0] = dividend; 665 divisor_ = divisor; 666 temps_[0] = temp1; 667 temps_[1] = temp2; 668 } 669 670 LOperand* dividend() { return inputs_[0]; } 671 int32_t divisor() const { return divisor_; } 672 LOperand* temp1() { return temps_[0]; } 673 LOperand* temp2() { return temps_[1]; } 674 675 DECLARE_CONCRETE_INSTRUCTION(ModByConstI, "mod-by-const-i") 676 DECLARE_HYDROGEN_ACCESSOR(Mod) 677 678 private: 679 int32_t divisor_; 680 }; 681 682 683 class LModI FINAL : public LTemplateInstruction<1, 2, 1> { 684 public: 685 LModI(LOperand* left, LOperand* right, LOperand* temp) { 686 inputs_[0] = left; 687 inputs_[1] = right; 688 temps_[0] = temp; 689 } 690 691 LOperand* left() { return inputs_[0]; } 692 LOperand* right() { return inputs_[1]; } 693 LOperand* temp() { return temps_[0]; } 694 695 DECLARE_CONCRETE_INSTRUCTION(ModI, "mod-i") 696 DECLARE_HYDROGEN_ACCESSOR(Mod) 697 }; 698 699 700 class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> { 701 public: 702 LDivByPowerOf2I(LOperand* dividend, int32_t divisor) { 703 inputs_[0] = dividend; 704 divisor_ = divisor; 705 } 706 707 LOperand* dividend() { return inputs_[0]; } 708 int32_t divisor() const { return divisor_; } 709 710 DECLARE_CONCRETE_INSTRUCTION(DivByPowerOf2I, "div-by-power-of-2-i") 711 DECLARE_HYDROGEN_ACCESSOR(Div) 712 713 private: 714 int32_t divisor_; 715 }; 716 717 718 class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 2> { 719 public: 720 LDivByConstI(LOperand* dividend, 721 int32_t divisor, 722 LOperand* temp1, 723 LOperand* temp2) { 724 inputs_[0] = dividend; 725 divisor_ = divisor; 726 temps_[0] = temp1; 727 temps_[1] = temp2; 728 } 729 730 LOperand* dividend() { return inputs_[0]; } 731 int32_t divisor() const { return divisor_; } 732 LOperand* temp1() { return temps_[0]; } 733 LOperand* temp2() { return temps_[1]; } 734 735 DECLARE_CONCRETE_INSTRUCTION(DivByConstI, "div-by-const-i") 736 DECLARE_HYDROGEN_ACCESSOR(Div) 737 738 private: 739 int32_t divisor_; 740 }; 741 742 743 class LDivI FINAL : public LTemplateInstruction<1, 2, 1> { 744 public: 745 LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) { 746 inputs_[0] = dividend; 747 inputs_[1] = divisor; 748 temps_[0] = temp; 749 } 750 751 LOperand* dividend() { return inputs_[0]; } 752 LOperand* divisor() { return inputs_[1]; } 753 LOperand* temp() { return temps_[0]; } 754 755 DECLARE_CONCRETE_INSTRUCTION(DivI, "div-i") 756 DECLARE_HYDROGEN_ACCESSOR(BinaryOperation) 757 }; 758 759 760 class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> { 761 public: 762 LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) { 763 inputs_[0] = dividend; 764 divisor_ = divisor; 765 } 766 767 LOperand* dividend() { return inputs_[0]; } 768 int32_t divisor() const { return divisor_; } 769 770 DECLARE_CONCRETE_INSTRUCTION(FlooringDivByPowerOf2I, 771 "flooring-div-by-power-of-2-i") 772 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv) 773 774 private: 775 int32_t divisor_; 776 }; 777 778 779 class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 3> { 780 public: 781 LFlooringDivByConstI(LOperand* dividend, 782 int32_t divisor, 783 LOperand* temp1, 784 LOperand* temp2, 785 LOperand* temp3) { 786 inputs_[0] = dividend; 787 divisor_ = divisor; 788 temps_[0] = temp1; 789 temps_[1] = temp2; 790 temps_[2] = temp3; 791 } 792 793 LOperand* dividend() { return inputs_[0]; } 794 int32_t divisor() const { return divisor_; } 795 LOperand* temp1() { return temps_[0]; } 796 LOperand* temp2() { return temps_[1]; } 797 LOperand* temp3() { return temps_[2]; } 798 799 DECLARE_CONCRETE_INSTRUCTION(FlooringDivByConstI, "flooring-div-by-const-i") 800 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv) 801 802 private: 803 int32_t divisor_; 804 }; 805 806 807 class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 1> { 808 public: 809 LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) { 810 inputs_[0] = dividend; 811 inputs_[1] = divisor; 812 temps_[0] = temp; 813 } 814 815 LOperand* dividend() { return inputs_[0]; } 816 LOperand* divisor() { return inputs_[1]; } 817 LOperand* temp() { return temps_[0]; } 818 819 DECLARE_CONCRETE_INSTRUCTION(FlooringDivI, "flooring-div-i") 820 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv) 821 }; 822 823 824 class LMulI FINAL : public LTemplateInstruction<1, 2, 0> { 825 public: 826 LMulI(LOperand* left, LOperand* right) { 827 inputs_[0] = left; 828 inputs_[1] = right; 829 } 830 831 LOperand* left() { return inputs_[0]; } 832 LOperand* right() { return inputs_[1]; } 833 834 DECLARE_CONCRETE_INSTRUCTION(MulI, "mul-i") 835 DECLARE_HYDROGEN_ACCESSOR(Mul) 836 }; 837 838 839 class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> { 840 public: 841 LCompareNumericAndBranch(LOperand* left, LOperand* right) { 842 inputs_[0] = left; 843 inputs_[1] = right; 844 } 845 846 LOperand* left() { return inputs_[0]; } 847 LOperand* right() { return inputs_[1]; } 848 849 DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch, 850 "compare-numeric-and-branch") 851 DECLARE_HYDROGEN_ACCESSOR(CompareNumericAndBranch) 852 853 Token::Value op() const { return hydrogen()->token(); } 854 bool is_double() const { 855 return hydrogen()->representation().IsDouble(); 856 } 857 858 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 859 }; 860 861 862 class LMathFloor FINAL : public LTemplateInstruction<1, 1, 0> { 863 public: 864 explicit LMathFloor(LOperand* value) { 865 inputs_[0] = value; 866 } 867 868 LOperand* value() { return inputs_[0]; } 869 870 DECLARE_CONCRETE_INSTRUCTION(MathFloor, "math-floor") 871 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation) 872 }; 873 874 875 class LMathRound FINAL : public LTemplateInstruction<1, 1, 1> { 876 public: 877 LMathRound(LOperand* value, LOperand* temp) { 878 inputs_[0] = value; 879 temps_[0] = temp; 880 } 881 882 LOperand* value() { return inputs_[0]; } 883 LOperand* temp() { return temps_[0]; } 884 885 DECLARE_CONCRETE_INSTRUCTION(MathRound, "math-round") 886 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation) 887 }; 888 889 890 class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> { 891 public: 892 explicit LMathFround(LOperand* value) { inputs_[0] = value; } 893 894 LOperand* value() { return inputs_[0]; } 895 896 DECLARE_CONCRETE_INSTRUCTION(MathFround, "math-fround") 897 }; 898 899 900 class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> { 901 public: 902 explicit LMathAbs(LOperand* context, LOperand* value) { 903 inputs_[1] = context; 904 inputs_[0] = value; 905 } 906 907 LOperand* context() { return inputs_[1]; } 908 LOperand* value() { return inputs_[0]; } 909 910 DECLARE_CONCRETE_INSTRUCTION(MathAbs, "math-abs") 911 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation) 912 }; 913 914 915 class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> { 916 public: 917 explicit LMathLog(LOperand* value) { 918 inputs_[0] = value; 919 } 920 921 LOperand* value() { return inputs_[0]; } 922 923 DECLARE_CONCRETE_INSTRUCTION(MathLog, "math-log") 924 }; 925 926 927 class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> { 928 public: 929 explicit LMathClz32(LOperand* value) { 930 inputs_[0] = value; 931 } 932 933 LOperand* value() { return inputs_[0]; } 934 935 DECLARE_CONCRETE_INSTRUCTION(MathClz32, "math-clz32") 936 }; 937 938 939 class LMathExp FINAL : public LTemplateInstruction<1, 1, 2> { 940 public: 941 LMathExp(LOperand* value, LOperand* temp1, LOperand* temp2) { 942 inputs_[0] = value; 943 temps_[0] = temp1; 944 temps_[1] = temp2; 945 ExternalReference::InitializeMathExpData(); 946 } 947 948 LOperand* value() { return inputs_[0]; } 949 LOperand* temp1() { return temps_[0]; } 950 LOperand* temp2() { return temps_[1]; } 951 952 DECLARE_CONCRETE_INSTRUCTION(MathExp, "math-exp") 953 }; 954 955 956 class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 0> { 957 public: 958 explicit LMathSqrt(LOperand* value) { 959 inputs_[0] = value; 960 } 961 962 LOperand* value() { return inputs_[0]; } 963 964 DECLARE_CONCRETE_INSTRUCTION(MathSqrt, "math-sqrt") 965 }; 966 967 968 class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 0> { 969 public: 970 explicit LMathPowHalf(LOperand* value) { 971 inputs_[0] = value; 972 } 973 974 LOperand* value() { return inputs_[0]; } 975 976 DECLARE_CONCRETE_INSTRUCTION(MathPowHalf, "math-pow-half") 977 }; 978 979 980 class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> { 981 public: 982 LCmpObjectEqAndBranch(LOperand* left, LOperand* right) { 983 inputs_[0] = left; 984 inputs_[1] = right; 985 } 986 987 LOperand* left() { return inputs_[0]; } 988 LOperand* right() { return inputs_[1]; } 989 990 DECLARE_CONCRETE_INSTRUCTION(CmpObjectEqAndBranch, "cmp-object-eq-and-branch") 991 }; 992 993 994 class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> { 995 public: 996 explicit LCmpHoleAndBranch(LOperand* object) { 997 inputs_[0] = object; 998 } 999 1000 LOperand* object() { return inputs_[0]; } 1001 1002 DECLARE_CONCRETE_INSTRUCTION(CmpHoleAndBranch, "cmp-hole-and-branch") 1003 DECLARE_HYDROGEN_ACCESSOR(CompareHoleAndBranch) 1004 }; 1005 1006 1007 class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 0> { 1008 public: 1009 explicit LCompareMinusZeroAndBranch(LOperand* value) { 1010 inputs_[0] = value; 1011 } 1012 1013 LOperand* value() { return inputs_[0]; } 1014 1015 DECLARE_CONCRETE_INSTRUCTION(CompareMinusZeroAndBranch, 1016 "cmp-minus-zero-and-branch") 1017 DECLARE_HYDROGEN_ACCESSOR(CompareMinusZeroAndBranch) 1018 }; 1019 1020 1021 1022 class LIsObjectAndBranch FINAL : public LControlInstruction<1, 0> { 1023 public: 1024 explicit LIsObjectAndBranch(LOperand* value) { 1025 inputs_[0] = value; 1026 } 1027 1028 LOperand* value() { return inputs_[0]; } 1029 1030 DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch") 1031 DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch) 1032 1033 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1034 }; 1035 1036 1037 class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> { 1038 public: 1039 explicit LIsStringAndBranch(LOperand* value, LOperand* temp) { 1040 inputs_[0] = value; 1041 temps_[0] = temp; 1042 } 1043 1044 LOperand* value() { return inputs_[0]; } 1045 LOperand* temp() { return temps_[0]; } 1046 1047 DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch") 1048 DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch) 1049 1050 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1051 }; 1052 1053 1054 class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> { 1055 public: 1056 explicit LIsSmiAndBranch(LOperand* value) { 1057 inputs_[0] = value; 1058 } 1059 1060 LOperand* value() { return inputs_[0]; } 1061 1062 DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch") 1063 DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch) 1064 1065 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1066 }; 1067 1068 1069 class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> { 1070 public: 1071 explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) { 1072 inputs_[0] = value; 1073 temps_[0] = temp; 1074 } 1075 1076 LOperand* value() { return inputs_[0]; } 1077 LOperand* temp() { return temps_[0]; } 1078 1079 DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch, 1080 "is-undetectable-and-branch") 1081 DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch) 1082 1083 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1084 }; 1085 1086 1087 class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> { 1088 public: 1089 explicit LStringCompareAndBranch(LOperand* context, 1090 LOperand* left, 1091 LOperand* right) { 1092 inputs_[0] = context; 1093 inputs_[1] = left; 1094 inputs_[2] = right; 1095 } 1096 1097 LOperand* context() { return inputs_[0]; } 1098 LOperand* left() { return inputs_[1]; } 1099 LOperand* right() { return inputs_[2]; } 1100 1101 DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch, 1102 "string-compare-and-branch") 1103 DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch) 1104 1105 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1106 1107 Token::Value op() const { return hydrogen()->token(); } 1108 }; 1109 1110 1111 class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 0> { 1112 public: 1113 explicit LHasInstanceTypeAndBranch(LOperand* value) { 1114 inputs_[0] = value; 1115 } 1116 1117 LOperand* value() { return inputs_[0]; } 1118 1119 DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch, 1120 "has-instance-type-and-branch") 1121 DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch) 1122 1123 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1124 }; 1125 1126 1127 class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> { 1128 public: 1129 explicit LGetCachedArrayIndex(LOperand* value) { 1130 inputs_[0] = value; 1131 } 1132 1133 LOperand* value() { return inputs_[0]; } 1134 1135 DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index") 1136 DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex) 1137 }; 1138 1139 1140 class LHasCachedArrayIndexAndBranch FINAL 1141 : public LControlInstruction<1, 0> { 1142 public: 1143 explicit LHasCachedArrayIndexAndBranch(LOperand* value) { 1144 inputs_[0] = value; 1145 } 1146 1147 LOperand* value() { return inputs_[0]; } 1148 1149 DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch, 1150 "has-cached-array-index-and-branch") 1151 DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch) 1152 1153 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1154 }; 1155 1156 1157 class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 2> { 1158 public: 1159 LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) { 1160 inputs_[0] = value; 1161 temps_[0] = temp; 1162 temps_[1] = temp2; 1163 } 1164 1165 LOperand* value() { return inputs_[0]; } 1166 LOperand* temp() { return temps_[0]; } 1167 LOperand* temp2() { return temps_[1]; } 1168 1169 DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch, 1170 "class-of-test-and-branch") 1171 DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch) 1172 1173 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1174 }; 1175 1176 1177 class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> { 1178 public: 1179 LCmpT(LOperand* context, LOperand* left, LOperand* right) { 1180 inputs_[0] = context; 1181 inputs_[1] = left; 1182 inputs_[2] = right; 1183 } 1184 1185 LOperand* context() { return inputs_[0]; } 1186 LOperand* left() { return inputs_[1]; } 1187 LOperand* right() { return inputs_[2]; } 1188 1189 DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t") 1190 DECLARE_HYDROGEN_ACCESSOR(CompareGeneric) 1191 1192 Token::Value op() const { return hydrogen()->token(); } 1193 }; 1194 1195 1196 class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> { 1197 public: 1198 LInstanceOf(LOperand* context, LOperand* left, LOperand* right) { 1199 inputs_[0] = context; 1200 inputs_[1] = left; 1201 inputs_[2] = right; 1202 } 1203 1204 LOperand* context() { return inputs_[0]; } 1205 LOperand* left() { return inputs_[1]; } 1206 LOperand* right() { return inputs_[2]; } 1207 1208 DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance-of") 1209 }; 1210 1211 1212 class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> { 1213 public: 1214 LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) { 1215 inputs_[0] = context; 1216 inputs_[1] = value; 1217 temps_[0] = temp; 1218 } 1219 1220 LOperand* context() { return inputs_[0]; } 1221 LOperand* value() { return inputs_[1]; } 1222 LOperand* temp() { return temps_[0]; } 1223 1224 DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal, 1225 "instance-of-known-global") 1226 DECLARE_HYDROGEN_ACCESSOR(InstanceOfKnownGlobal) 1227 1228 Handle<JSFunction> function() const { return hydrogen()->function(); } 1229 LEnvironment* GetDeferredLazyDeoptimizationEnvironment() { 1230 return lazy_deopt_env_; 1231 } 1232 virtual void SetDeferredLazyDeoptimizationEnvironment( 1233 LEnvironment* env) OVERRIDE { 1234 lazy_deopt_env_ = env; 1235 } 1236 1237 private: 1238 LEnvironment* lazy_deopt_env_; 1239 }; 1240 1241 1242 class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> { 1243 public: 1244 LBoundsCheck(LOperand* index, LOperand* length) { 1245 inputs_[0] = index; 1246 inputs_[1] = length; 1247 } 1248 1249 LOperand* index() { return inputs_[0]; } 1250 LOperand* length() { return inputs_[1]; } 1251 1252 DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds-check") 1253 DECLARE_HYDROGEN_ACCESSOR(BoundsCheck) 1254 }; 1255 1256 1257 class LBitI FINAL : public LTemplateInstruction<1, 2, 0> { 1258 public: 1259 LBitI(LOperand* left, LOperand* right) { 1260 inputs_[0] = left; 1261 inputs_[1] = right; 1262 } 1263 1264 LOperand* left() { return inputs_[0]; } 1265 LOperand* right() { return inputs_[1]; } 1266 1267 Token::Value op() const { return hydrogen()->op(); } 1268 bool IsInteger32() const { 1269 return hydrogen()->representation().IsInteger32(); 1270 } 1271 1272 DECLARE_CONCRETE_INSTRUCTION(BitI, "bit-i") 1273 DECLARE_HYDROGEN_ACCESSOR(Bitwise) 1274 }; 1275 1276 1277 class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> { 1278 public: 1279 LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt) 1280 : op_(op), can_deopt_(can_deopt) { 1281 inputs_[0] = left; 1282 inputs_[1] = right; 1283 } 1284 1285 Token::Value op() const { return op_; } 1286 LOperand* left() { return inputs_[0]; } 1287 LOperand* right() { return inputs_[1]; } 1288 bool can_deopt() const { return can_deopt_; } 1289 1290 DECLARE_CONCRETE_INSTRUCTION(ShiftI, "shift-i") 1291 1292 private: 1293 Token::Value op_; 1294 bool can_deopt_; 1295 }; 1296 1297 1298 class LSubI FINAL : public LTemplateInstruction<1, 2, 0> { 1299 public: 1300 LSubI(LOperand* left, LOperand* right) { 1301 inputs_[0] = left; 1302 inputs_[1] = right; 1303 } 1304 1305 LOperand* left() { return inputs_[0]; } 1306 LOperand* right() { return inputs_[1]; } 1307 1308 DECLARE_CONCRETE_INSTRUCTION(SubI, "sub-i") 1309 DECLARE_HYDROGEN_ACCESSOR(Sub) 1310 }; 1311 1312 1313 class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> { 1314 public: 1315 DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i") 1316 DECLARE_HYDROGEN_ACCESSOR(Constant) 1317 1318 int32_t value() const { return hydrogen()->Integer32Value(); } 1319 }; 1320 1321 1322 class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> { 1323 public: 1324 DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s") 1325 DECLARE_HYDROGEN_ACCESSOR(Constant) 1326 1327 Smi* value() const { return Smi::FromInt(hydrogen()->Integer32Value()); } 1328 }; 1329 1330 1331 class LConstantD FINAL : public LTemplateInstruction<1, 0, 1> { 1332 public: 1333 explicit LConstantD(LOperand* temp) { 1334 temps_[0] = temp; 1335 } 1336 1337 LOperand* temp() { return temps_[0]; } 1338 1339 DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d") 1340 DECLARE_HYDROGEN_ACCESSOR(Constant) 1341 1342 double value() const { return hydrogen()->DoubleValue(); } 1343 }; 1344 1345 1346 class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> { 1347 public: 1348 DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e") 1349 DECLARE_HYDROGEN_ACCESSOR(Constant) 1350 1351 ExternalReference value() const { 1352 return hydrogen()->ExternalReferenceValue(); 1353 } 1354 }; 1355 1356 1357 class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> { 1358 public: 1359 DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t") 1360 DECLARE_HYDROGEN_ACCESSOR(Constant) 1361 1362 Handle<Object> value(Isolate* isolate) const { 1363 return hydrogen()->handle(isolate); 1364 } 1365 }; 1366 1367 1368 class LBranch FINAL : public LControlInstruction<1, 0> { 1369 public: 1370 explicit LBranch(LOperand* value) { 1371 inputs_[0] = value; 1372 } 1373 1374 LOperand* value() { return inputs_[0]; } 1375 1376 DECLARE_CONCRETE_INSTRUCTION(Branch, "branch") 1377 DECLARE_HYDROGEN_ACCESSOR(Branch) 1378 1379 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1380 }; 1381 1382 1383 class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> { 1384 public: 1385 DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break") 1386 }; 1387 1388 1389 class LCmpMapAndBranch FINAL : public LControlInstruction<1, 0> { 1390 public: 1391 explicit LCmpMapAndBranch(LOperand* value) { 1392 inputs_[0] = value; 1393 } 1394 1395 LOperand* value() { return inputs_[0]; } 1396 1397 DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch") 1398 DECLARE_HYDROGEN_ACCESSOR(CompareMap) 1399 1400 Handle<Map> map() const { return hydrogen()->map().handle(); } 1401 }; 1402 1403 1404 class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> { 1405 public: 1406 explicit LMapEnumLength(LOperand* value) { 1407 inputs_[0] = value; 1408 } 1409 1410 LOperand* value() { return inputs_[0]; } 1411 1412 DECLARE_CONCRETE_INSTRUCTION(MapEnumLength, "map-enum-length") 1413 }; 1414 1415 1416 class LDateField FINAL : public LTemplateInstruction<1, 1, 0> { 1417 public: 1418 LDateField(LOperand* date, Smi* index) : index_(index) { 1419 inputs_[0] = date; 1420 } 1421 1422 LOperand* date() { return inputs_[0]; } 1423 Smi* index() const { return index_; } 1424 1425 DECLARE_CONCRETE_INSTRUCTION(DateField, "date-field") 1426 DECLARE_HYDROGEN_ACCESSOR(DateField) 1427 1428 private: 1429 Smi* index_; 1430 }; 1431 1432 1433 class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> { 1434 public: 1435 LSeqStringGetChar(LOperand* string, LOperand* index) { 1436 inputs_[0] = string; 1437 inputs_[1] = index; 1438 } 1439 1440 LOperand* string() const { return inputs_[0]; } 1441 LOperand* index() const { return inputs_[1]; } 1442 1443 DECLARE_CONCRETE_INSTRUCTION(SeqStringGetChar, "seq-string-get-char") 1444 DECLARE_HYDROGEN_ACCESSOR(SeqStringGetChar) 1445 }; 1446 1447 1448 class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> { 1449 public: 1450 LSeqStringSetChar(LOperand* context, 1451 LOperand* string, 1452 LOperand* index, 1453 LOperand* value) { 1454 inputs_[0] = context; 1455 inputs_[1] = string; 1456 inputs_[2] = index; 1457 inputs_[3] = value; 1458 } 1459 1460 LOperand* string() { return inputs_[1]; } 1461 LOperand* index() { return inputs_[2]; } 1462 LOperand* value() { return inputs_[3]; } 1463 1464 DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar, "seq-string-set-char") 1465 DECLARE_HYDROGEN_ACCESSOR(SeqStringSetChar) 1466 }; 1467 1468 1469 class LAddI FINAL : public LTemplateInstruction<1, 2, 0> { 1470 public: 1471 LAddI(LOperand* left, LOperand* right) { 1472 inputs_[0] = left; 1473 inputs_[1] = right; 1474 } 1475 1476 LOperand* left() { return inputs_[0]; } 1477 LOperand* right() { return inputs_[1]; } 1478 1479 static bool UseLea(HAdd* add) { 1480 return !add->CheckFlag(HValue::kCanOverflow) && 1481 add->BetterLeftOperand()->UseCount() > 1; 1482 } 1483 1484 DECLARE_CONCRETE_INSTRUCTION(AddI, "add-i") 1485 DECLARE_HYDROGEN_ACCESSOR(Add) 1486 }; 1487 1488 1489 class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> { 1490 public: 1491 LMathMinMax(LOperand* left, LOperand* right) { 1492 inputs_[0] = left; 1493 inputs_[1] = right; 1494 } 1495 1496 LOperand* left() { return inputs_[0]; } 1497 LOperand* right() { return inputs_[1]; } 1498 1499 DECLARE_CONCRETE_INSTRUCTION(MathMinMax, "math-min-max") 1500 DECLARE_HYDROGEN_ACCESSOR(MathMinMax) 1501 }; 1502 1503 1504 class LPower FINAL : public LTemplateInstruction<1, 2, 0> { 1505 public: 1506 LPower(LOperand* left, LOperand* right) { 1507 inputs_[0] = left; 1508 inputs_[1] = right; 1509 } 1510 1511 LOperand* left() { return inputs_[0]; } 1512 LOperand* right() { return inputs_[1]; } 1513 1514 DECLARE_CONCRETE_INSTRUCTION(Power, "power") 1515 DECLARE_HYDROGEN_ACCESSOR(Power) 1516 }; 1517 1518 1519 class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> { 1520 public: 1521 LArithmeticD(Token::Value op, LOperand* left, LOperand* right) 1522 : op_(op) { 1523 inputs_[0] = left; 1524 inputs_[1] = right; 1525 } 1526 1527 Token::Value op() const { return op_; } 1528 LOperand* left() { return inputs_[0]; } 1529 LOperand* right() { return inputs_[1]; } 1530 1531 virtual Opcode opcode() const OVERRIDE { 1532 return LInstruction::kArithmeticD; 1533 } 1534 virtual void CompileToNative(LCodeGen* generator) OVERRIDE; 1535 virtual const char* Mnemonic() const OVERRIDE; 1536 1537 private: 1538 Token::Value op_; 1539 }; 1540 1541 1542 class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> { 1543 public: 1544 LArithmeticT(Token::Value op, 1545 LOperand* context, 1546 LOperand* left, 1547 LOperand* right) 1548 : op_(op) { 1549 inputs_[0] = context; 1550 inputs_[1] = left; 1551 inputs_[2] = right; 1552 } 1553 1554 Token::Value op() const { return op_; } 1555 LOperand* context() { return inputs_[0]; } 1556 LOperand* left() { return inputs_[1]; } 1557 LOperand* right() { return inputs_[2]; } 1558 1559 virtual Opcode opcode() const OVERRIDE { 1560 return LInstruction::kArithmeticT; 1561 } 1562 virtual void CompileToNative(LCodeGen* generator) OVERRIDE; 1563 virtual const char* Mnemonic() const OVERRIDE; 1564 1565 private: 1566 Token::Value op_; 1567 }; 1568 1569 1570 class LReturn FINAL : public LTemplateInstruction<0, 3, 0> { 1571 public: 1572 explicit LReturn(LOperand* value, 1573 LOperand* context, 1574 LOperand* parameter_count) { 1575 inputs_[0] = value; 1576 inputs_[1] = context; 1577 inputs_[2] = parameter_count; 1578 } 1579 1580 LOperand* value() { return inputs_[0]; } 1581 LOperand* context() { return inputs_[1]; } 1582 1583 bool has_constant_parameter_count() { 1584 return parameter_count()->IsConstantOperand(); 1585 } 1586 LConstantOperand* constant_parameter_count() { 1587 DCHECK(has_constant_parameter_count()); 1588 return LConstantOperand::cast(parameter_count()); 1589 } 1590 LOperand* parameter_count() { return inputs_[2]; } 1591 1592 DECLARE_CONCRETE_INSTRUCTION(Return, "return") 1593 DECLARE_HYDROGEN_ACCESSOR(Return) 1594 }; 1595 1596 1597 class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> { 1598 public: 1599 explicit LLoadNamedField(LOperand* object) { 1600 inputs_[0] = object; 1601 } 1602 1603 LOperand* object() { return inputs_[0]; } 1604 1605 DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load-named-field") 1606 DECLARE_HYDROGEN_ACCESSOR(LoadNamedField) 1607 }; 1608 1609 1610 class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> { 1611 public: 1612 explicit LLoadNamedGeneric(LOperand* context, LOperand* object, 1613 LOperand* vector) { 1614 inputs_[0] = context; 1615 inputs_[1] = object; 1616 temps_[0] = vector; 1617 } 1618 1619 DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric, "load-named-generic") 1620 DECLARE_HYDROGEN_ACCESSOR(LoadNamedGeneric) 1621 1622 LOperand* context() { return inputs_[0]; } 1623 LOperand* object() { return inputs_[1]; } 1624 LOperand* temp_vector() { return temps_[0]; } 1625 1626 Handle<Object> name() const { return hydrogen()->name(); } 1627 }; 1628 1629 1630 class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 0> { 1631 public: 1632 explicit LLoadFunctionPrototype(LOperand* function) { 1633 inputs_[0] = function; 1634 } 1635 1636 DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype, "load-function-prototype") 1637 DECLARE_HYDROGEN_ACCESSOR(LoadFunctionPrototype) 1638 1639 LOperand* function() { return inputs_[0]; } 1640 }; 1641 1642 1643 class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> { 1644 public: 1645 DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root") 1646 DECLARE_HYDROGEN_ACCESSOR(LoadRoot) 1647 1648 Heap::RootListIndex index() const { return hydrogen()->index(); } 1649 }; 1650 1651 1652 inline static bool ExternalArrayOpRequiresTemp( 1653 Representation key_representation, 1654 ElementsKind elements_kind) { 1655 // Operations that require the key to be divided by two to be converted into 1656 // an index cannot fold the scale operation into a load and need an extra 1657 // temp register to do the work. 1658 return SmiValuesAre31Bits() && key_representation.IsSmi() && 1659 (elements_kind == EXTERNAL_INT8_ELEMENTS || 1660 elements_kind == EXTERNAL_UINT8_ELEMENTS || 1661 elements_kind == EXTERNAL_UINT8_CLAMPED_ELEMENTS || 1662 elements_kind == UINT8_ELEMENTS || 1663 elements_kind == INT8_ELEMENTS || 1664 elements_kind == UINT8_CLAMPED_ELEMENTS); 1665 } 1666 1667 1668 class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> { 1669 public: 1670 LLoadKeyed(LOperand* elements, LOperand* key) { 1671 inputs_[0] = elements; 1672 inputs_[1] = key; 1673 } 1674 1675 DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed") 1676 DECLARE_HYDROGEN_ACCESSOR(LoadKeyed) 1677 1678 bool is_external() const { 1679 return hydrogen()->is_external(); 1680 } 1681 bool is_fixed_typed_array() const { 1682 return hydrogen()->is_fixed_typed_array(); 1683 } 1684 bool is_typed_elements() const { 1685 return is_external() || is_fixed_typed_array(); 1686 } 1687 LOperand* elements() { return inputs_[0]; } 1688 LOperand* key() { return inputs_[1]; } 1689 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1690 uint32_t base_offset() const { return hydrogen()->base_offset(); } 1691 ElementsKind elements_kind() const { 1692 return hydrogen()->elements_kind(); 1693 } 1694 }; 1695 1696 1697 class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> { 1698 public: 1699 LLoadKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key, 1700 LOperand* vector) { 1701 inputs_[0] = context; 1702 inputs_[1] = obj; 1703 inputs_[2] = key; 1704 temps_[0] = vector; 1705 } 1706 1707 DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric, "load-keyed-generic") 1708 DECLARE_HYDROGEN_ACCESSOR(LoadKeyedGeneric) 1709 1710 LOperand* context() { return inputs_[0]; } 1711 LOperand* object() { return inputs_[1]; } 1712 LOperand* key() { return inputs_[2]; } 1713 LOperand* temp_vector() { return temps_[0]; } 1714 }; 1715 1716 1717 class LLoadGlobalCell FINAL : public LTemplateInstruction<1, 0, 0> { 1718 public: 1719 DECLARE_CONCRETE_INSTRUCTION(LoadGlobalCell, "load-global-cell") 1720 DECLARE_HYDROGEN_ACCESSOR(LoadGlobalCell) 1721 }; 1722 1723 1724 class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> { 1725 public: 1726 explicit LLoadGlobalGeneric(LOperand* context, LOperand* global_object, 1727 LOperand* vector) { 1728 inputs_[0] = context; 1729 inputs_[1] = global_object; 1730 temps_[0] = vector; 1731 } 1732 1733 DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load-global-generic") 1734 DECLARE_HYDROGEN_ACCESSOR(LoadGlobalGeneric) 1735 1736 LOperand* context() { return inputs_[0]; } 1737 LOperand* global_object() { return inputs_[1]; } 1738 LOperand* temp_vector() { return temps_[0]; } 1739 1740 Handle<Object> name() const { return hydrogen()->name(); } 1741 bool for_typeof() const { return hydrogen()->for_typeof(); } 1742 }; 1743 1744 1745 class LStoreGlobalCell FINAL : public LTemplateInstruction<0, 1, 1> { 1746 public: 1747 explicit LStoreGlobalCell(LOperand* value, LOperand* temp) { 1748 inputs_[0] = value; 1749 temps_[0] = temp; 1750 } 1751 1752 LOperand* value() { return inputs_[0]; } 1753 LOperand* temp() { return temps_[0]; } 1754 1755 DECLARE_CONCRETE_INSTRUCTION(StoreGlobalCell, "store-global-cell") 1756 DECLARE_HYDROGEN_ACCESSOR(StoreGlobalCell) 1757 }; 1758 1759 1760 class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> { 1761 public: 1762 explicit LLoadContextSlot(LOperand* context) { 1763 inputs_[0] = context; 1764 } 1765 1766 LOperand* context() { return inputs_[0]; } 1767 1768 DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot, "load-context-slot") 1769 DECLARE_HYDROGEN_ACCESSOR(LoadContextSlot) 1770 1771 int slot_index() { return hydrogen()->slot_index(); } 1772 1773 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1774 }; 1775 1776 1777 class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 1> { 1778 public: 1779 LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) { 1780 inputs_[0] = context; 1781 inputs_[1] = value; 1782 temps_[0] = temp; 1783 } 1784 1785 LOperand* context() { return inputs_[0]; } 1786 LOperand* value() { return inputs_[1]; } 1787 LOperand* temp() { return temps_[0]; } 1788 1789 DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot, "store-context-slot") 1790 DECLARE_HYDROGEN_ACCESSOR(StoreContextSlot) 1791 1792 int slot_index() { return hydrogen()->slot_index(); } 1793 1794 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1795 }; 1796 1797 1798 class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> { 1799 public: 1800 explicit LPushArgument(LOperand* value) { 1801 inputs_[0] = value; 1802 } 1803 1804 LOperand* value() { return inputs_[0]; } 1805 1806 DECLARE_CONCRETE_INSTRUCTION(PushArgument, "push-argument") 1807 }; 1808 1809 1810 class LDrop FINAL : public LTemplateInstruction<0, 0, 0> { 1811 public: 1812 explicit LDrop(int count) : count_(count) { } 1813 1814 int count() const { return count_; } 1815 1816 DECLARE_CONCRETE_INSTRUCTION(Drop, "drop") 1817 1818 private: 1819 int count_; 1820 }; 1821 1822 1823 class LStoreCodeEntry FINAL: public LTemplateInstruction<0, 2, 0> { 1824 public: 1825 LStoreCodeEntry(LOperand* function, LOperand* code_object) { 1826 inputs_[0] = function; 1827 inputs_[1] = code_object; 1828 } 1829 1830 LOperand* function() { return inputs_[0]; } 1831 LOperand* code_object() { return inputs_[1]; } 1832 1833 virtual void PrintDataTo(StringStream* stream); 1834 1835 DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry") 1836 DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry) 1837 }; 1838 1839 1840 class LInnerAllocatedObject FINAL: public LTemplateInstruction<1, 2, 0> { 1841 public: 1842 LInnerAllocatedObject(LOperand* base_object, LOperand* offset) { 1843 inputs_[0] = base_object; 1844 inputs_[1] = offset; 1845 } 1846 1847 LOperand* base_object() const { return inputs_[0]; } 1848 LOperand* offset() const { return inputs_[1]; } 1849 1850 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1851 1852 DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object") 1853 }; 1854 1855 1856 class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> { 1857 public: 1858 DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function") 1859 DECLARE_HYDROGEN_ACCESSOR(ThisFunction) 1860 }; 1861 1862 1863 class LContext FINAL : public LTemplateInstruction<1, 0, 0> { 1864 public: 1865 DECLARE_CONCRETE_INSTRUCTION(Context, "context") 1866 DECLARE_HYDROGEN_ACCESSOR(Context) 1867 }; 1868 1869 1870 class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> { 1871 public: 1872 explicit LDeclareGlobals(LOperand* context) { 1873 inputs_[0] = context; 1874 } 1875 1876 LOperand* context() { return inputs_[0]; } 1877 1878 DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals, "declare-globals") 1879 DECLARE_HYDROGEN_ACCESSOR(DeclareGlobals) 1880 }; 1881 1882 1883 class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> { 1884 public: 1885 explicit LCallJSFunction(LOperand* function) { 1886 inputs_[0] = function; 1887 } 1888 1889 LOperand* function() { return inputs_[0]; } 1890 1891 DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function") 1892 DECLARE_HYDROGEN_ACCESSOR(CallJSFunction) 1893 1894 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1895 1896 int arity() const { return hydrogen()->argument_count() - 1; } 1897 }; 1898 1899 1900 class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> { 1901 public: 1902 LCallWithDescriptor(CallInterfaceDescriptor descriptor, 1903 const ZoneList<LOperand*>& operands, Zone* zone) 1904 : inputs_(descriptor.GetRegisterParameterCount() + 1, zone) { 1905 DCHECK(descriptor.GetRegisterParameterCount() + 1 == operands.length()); 1906 inputs_.AddAll(operands, zone); 1907 } 1908 1909 LOperand* target() const { return inputs_[0]; } 1910 1911 DECLARE_HYDROGEN_ACCESSOR(CallWithDescriptor) 1912 1913 private: 1914 DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor") 1915 1916 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1917 1918 int arity() const { return hydrogen()->argument_count() - 1; } 1919 1920 ZoneList<LOperand*> inputs_; 1921 1922 // Iterator support. 1923 virtual int InputCount() FINAL OVERRIDE { return inputs_.length(); } 1924 virtual LOperand* InputAt(int i) FINAL OVERRIDE { return inputs_[i]; } 1925 1926 virtual int TempCount() FINAL OVERRIDE { return 0; } 1927 virtual LOperand* TempAt(int i) FINAL OVERRIDE { return NULL; } 1928 }; 1929 1930 1931 class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> { 1932 public: 1933 LInvokeFunction(LOperand* context, LOperand* function) { 1934 inputs_[0] = context; 1935 inputs_[1] = function; 1936 } 1937 1938 LOperand* context() { return inputs_[0]; } 1939 LOperand* function() { return inputs_[1]; } 1940 1941 DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function") 1942 DECLARE_HYDROGEN_ACCESSOR(InvokeFunction) 1943 1944 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1945 1946 int arity() const { return hydrogen()->argument_count() - 1; } 1947 }; 1948 1949 1950 class LCallFunction FINAL : public LTemplateInstruction<1, 2, 0> { 1951 public: 1952 LCallFunction(LOperand* context, LOperand* function) { 1953 inputs_[0] = context; 1954 inputs_[1] = function; 1955 } 1956 1957 DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function") 1958 DECLARE_HYDROGEN_ACCESSOR(CallFunction) 1959 1960 LOperand* context() { return inputs_[0]; } 1961 LOperand* function() { return inputs_[1]; } 1962 int arity() const { return hydrogen()->argument_count() - 1; } 1963 }; 1964 1965 1966 class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> { 1967 public: 1968 LCallNew(LOperand* context, LOperand* constructor) { 1969 inputs_[0] = context; 1970 inputs_[1] = constructor; 1971 } 1972 1973 LOperand* context() { return inputs_[0]; } 1974 LOperand* constructor() { return inputs_[1]; } 1975 1976 DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new") 1977 DECLARE_HYDROGEN_ACCESSOR(CallNew) 1978 1979 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1980 1981 int arity() const { return hydrogen()->argument_count() - 1; } 1982 }; 1983 1984 1985 class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> { 1986 public: 1987 LCallNewArray(LOperand* context, LOperand* constructor) { 1988 inputs_[0] = context; 1989 inputs_[1] = constructor; 1990 } 1991 1992 LOperand* context() { return inputs_[0]; } 1993 LOperand* constructor() { return inputs_[1]; } 1994 1995 DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array") 1996 DECLARE_HYDROGEN_ACCESSOR(CallNewArray) 1997 1998 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 1999 2000 int arity() const { return hydrogen()->argument_count() - 1; } 2001 }; 2002 2003 2004 class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> { 2005 public: 2006 explicit LCallRuntime(LOperand* context) { 2007 inputs_[0] = context; 2008 } 2009 2010 LOperand* context() { return inputs_[0]; } 2011 2012 DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime") 2013 DECLARE_HYDROGEN_ACCESSOR(CallRuntime) 2014 2015 virtual bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE { 2016 return save_doubles() == kDontSaveFPRegs; 2017 } 2018 2019 const Runtime::Function* function() const { return hydrogen()->function(); } 2020 int arity() const { return hydrogen()->argument_count(); } 2021 SaveFPRegsMode save_doubles() const { return hydrogen()->save_doubles(); } 2022 }; 2023 2024 2025 class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> { 2026 public: 2027 explicit LInteger32ToDouble(LOperand* value) { 2028 inputs_[0] = value; 2029 } 2030 2031 LOperand* value() { return inputs_[0]; } 2032 2033 DECLARE_CONCRETE_INSTRUCTION(Integer32ToDouble, "int32-to-double") 2034 }; 2035 2036 2037 class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> { 2038 public: 2039 explicit LUint32ToDouble(LOperand* value) { 2040 inputs_[0] = value; 2041 } 2042 2043 LOperand* value() { return inputs_[0]; } 2044 2045 DECLARE_CONCRETE_INSTRUCTION(Uint32ToDouble, "uint32-to-double") 2046 }; 2047 2048 2049 class LNumberTagI FINAL : public LTemplateInstruction<1, 1, 2> { 2050 public: 2051 LNumberTagI(LOperand* value, LOperand* temp1, LOperand* temp2) { 2052 inputs_[0] = value; 2053 temps_[0] = temp1; 2054 temps_[1] = temp2; 2055 } 2056 2057 LOperand* value() { return inputs_[0]; } 2058 LOperand* temp1() { return temps_[0]; } 2059 LOperand* temp2() { return temps_[1]; } 2060 2061 DECLARE_CONCRETE_INSTRUCTION(NumberTagI, "number-tag-i") 2062 }; 2063 2064 2065 class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 2> { 2066 public: 2067 LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) { 2068 inputs_[0] = value; 2069 temps_[0] = temp1; 2070 temps_[1] = temp2; 2071 } 2072 2073 LOperand* value() { return inputs_[0]; } 2074 LOperand* temp1() { return temps_[0]; } 2075 LOperand* temp2() { return temps_[1]; } 2076 2077 DECLARE_CONCRETE_INSTRUCTION(NumberTagU, "number-tag-u") 2078 }; 2079 2080 2081 class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 1> { 2082 public: 2083 explicit LNumberTagD(LOperand* value, LOperand* temp) { 2084 inputs_[0] = value; 2085 temps_[0] = temp; 2086 } 2087 2088 LOperand* value() { return inputs_[0]; } 2089 LOperand* temp() { return temps_[0]; } 2090 2091 DECLARE_CONCRETE_INSTRUCTION(NumberTagD, "number-tag-d") 2092 DECLARE_HYDROGEN_ACCESSOR(Change) 2093 }; 2094 2095 2096 // Sometimes truncating conversion from a tagged value to an int32. 2097 class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 0> { 2098 public: 2099 explicit LDoubleToI(LOperand* value) { 2100 inputs_[0] = value; 2101 } 2102 2103 LOperand* value() { return inputs_[0]; } 2104 2105 DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i") 2106 DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) 2107 2108 bool truncating() { return hydrogen()->CanTruncateToInt32(); } 2109 }; 2110 2111 2112 class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> { 2113 public: 2114 explicit LDoubleToSmi(LOperand* value) { 2115 inputs_[0] = value; 2116 } 2117 2118 LOperand* value() { return inputs_[0]; } 2119 2120 DECLARE_CONCRETE_INSTRUCTION(DoubleToSmi, "double-to-smi") 2121 DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) 2122 }; 2123 2124 2125 // Truncating conversion from a tagged value to an int32. 2126 class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 1> { 2127 public: 2128 LTaggedToI(LOperand* value, LOperand* temp) { 2129 inputs_[0] = value; 2130 temps_[0] = temp; 2131 } 2132 2133 LOperand* value() { return inputs_[0]; } 2134 LOperand* temp() { return temps_[0]; } 2135 2136 DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i") 2137 DECLARE_HYDROGEN_ACCESSOR(Change) 2138 2139 bool truncating() { return hydrogen()->CanTruncateToInt32(); } 2140 }; 2141 2142 2143 class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> { 2144 public: 2145 explicit LSmiTag(LOperand* value) { 2146 inputs_[0] = value; 2147 } 2148 2149 LOperand* value() { return inputs_[0]; } 2150 2151 DECLARE_CONCRETE_INSTRUCTION(SmiTag, "smi-tag") 2152 DECLARE_HYDROGEN_ACCESSOR(Change) 2153 }; 2154 2155 2156 class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 0> { 2157 public: 2158 explicit LNumberUntagD(LOperand* value) { 2159 inputs_[0] = value; 2160 } 2161 2162 LOperand* value() { return inputs_[0]; } 2163 2164 DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag") 2165 DECLARE_HYDROGEN_ACCESSOR(Change); 2166 }; 2167 2168 2169 class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> { 2170 public: 2171 LSmiUntag(LOperand* value, bool needs_check) 2172 : needs_check_(needs_check) { 2173 inputs_[0] = value; 2174 } 2175 2176 LOperand* value() { return inputs_[0]; } 2177 bool needs_check() const { return needs_check_; } 2178 2179 DECLARE_CONCRETE_INSTRUCTION(SmiUntag, "smi-untag") 2180 2181 private: 2182 bool needs_check_; 2183 }; 2184 2185 2186 class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 1> { 2187 public: 2188 LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) { 2189 inputs_[0] = object; 2190 inputs_[1] = value; 2191 temps_[0] = temp; 2192 } 2193 2194 LOperand* object() { return inputs_[0]; } 2195 LOperand* value() { return inputs_[1]; } 2196 LOperand* temp() { return temps_[0]; } 2197 2198 DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field") 2199 DECLARE_HYDROGEN_ACCESSOR(StoreNamedField) 2200 2201 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 2202 2203 Representation representation() const { 2204 return hydrogen()->field_representation(); 2205 } 2206 }; 2207 2208 2209 class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> { 2210 public: 2211 LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) { 2212 inputs_[0] = context; 2213 inputs_[1] = object; 2214 inputs_[2] = value; 2215 } 2216 2217 LOperand* context() { return inputs_[0]; } 2218 LOperand* object() { return inputs_[1]; } 2219 LOperand* value() { return inputs_[2]; } 2220 2221 DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic") 2222 DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric) 2223 2224 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 2225 2226 Handle<Object> name() const { return hydrogen()->name(); } 2227 StrictMode strict_mode() { return hydrogen()->strict_mode(); } 2228 }; 2229 2230 2231 class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> { 2232 public: 2233 LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) { 2234 inputs_[0] = object; 2235 inputs_[1] = key; 2236 inputs_[2] = value; 2237 } 2238 2239 bool is_external() const { return hydrogen()->is_external(); } 2240 bool is_fixed_typed_array() const { 2241 return hydrogen()->is_fixed_typed_array(); 2242 } 2243 bool is_typed_elements() const { 2244 return is_external() || is_fixed_typed_array(); 2245 } 2246 LOperand* elements() { return inputs_[0]; } 2247 LOperand* key() { return inputs_[1]; } 2248 LOperand* value() { return inputs_[2]; } 2249 ElementsKind elements_kind() const { return hydrogen()->elements_kind(); } 2250 2251 DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed") 2252 DECLARE_HYDROGEN_ACCESSOR(StoreKeyed) 2253 2254 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 2255 bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); } 2256 uint32_t base_offset() const { return hydrogen()->base_offset(); } 2257 }; 2258 2259 2260 class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> { 2261 public: 2262 LStoreKeyedGeneric(LOperand* context, 2263 LOperand* object, 2264 LOperand* key, 2265 LOperand* value) { 2266 inputs_[0] = context; 2267 inputs_[1] = object; 2268 inputs_[2] = key; 2269 inputs_[3] = value; 2270 } 2271 2272 LOperand* context() { return inputs_[0]; } 2273 LOperand* object() { return inputs_[1]; } 2274 LOperand* key() { return inputs_[2]; } 2275 LOperand* value() { return inputs_[3]; } 2276 2277 DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic") 2278 DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric) 2279 2280 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 2281 2282 StrictMode strict_mode() { return hydrogen()->strict_mode(); } 2283 }; 2284 2285 2286 class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 2> { 2287 public: 2288 LTransitionElementsKind(LOperand* object, 2289 LOperand* context, 2290 LOperand* new_map_temp, 2291 LOperand* temp) { 2292 inputs_[0] = object; 2293 inputs_[1] = context; 2294 temps_[0] = new_map_temp; 2295 temps_[1] = temp; 2296 } 2297 2298 LOperand* object() { return inputs_[0]; } 2299 LOperand* context() { return inputs_[1]; } 2300 LOperand* new_map_temp() { return temps_[0]; } 2301 LOperand* temp() { return temps_[1]; } 2302 2303 DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind, 2304 "transition-elements-kind") 2305 DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind) 2306 2307 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 2308 2309 Handle<Map> original_map() { return hydrogen()->original_map().handle(); } 2310 Handle<Map> transitioned_map() { 2311 return hydrogen()->transitioned_map().handle(); 2312 } 2313 ElementsKind from_kind() { return hydrogen()->from_kind(); } 2314 ElementsKind to_kind() { return hydrogen()->to_kind(); } 2315 }; 2316 2317 2318 class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> { 2319 public: 2320 LTrapAllocationMemento(LOperand* object, 2321 LOperand* temp) { 2322 inputs_[0] = object; 2323 temps_[0] = temp; 2324 } 2325 2326 LOperand* object() { return inputs_[0]; } 2327 LOperand* temp() { return temps_[0]; } 2328 2329 DECLARE_CONCRETE_INSTRUCTION(TrapAllocationMemento, 2330 "trap-allocation-memento") 2331 }; 2332 2333 2334 class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> { 2335 public: 2336 LStringAdd(LOperand* context, LOperand* left, LOperand* right) { 2337 inputs_[0] = context; 2338 inputs_[1] = left; 2339 inputs_[2] = right; 2340 } 2341 2342 LOperand* context() { return inputs_[0]; } 2343 LOperand* left() { return inputs_[1]; } 2344 LOperand* right() { return inputs_[2]; } 2345 2346 DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add") 2347 DECLARE_HYDROGEN_ACCESSOR(StringAdd) 2348 }; 2349 2350 2351 class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> { 2352 public: 2353 LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) { 2354 inputs_[0] = context; 2355 inputs_[1] = string; 2356 inputs_[2] = index; 2357 } 2358 2359 LOperand* context() { return inputs_[0]; } 2360 LOperand* string() { return inputs_[1]; } 2361 LOperand* index() { return inputs_[2]; } 2362 2363 DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt, "string-char-code-at") 2364 DECLARE_HYDROGEN_ACCESSOR(StringCharCodeAt) 2365 }; 2366 2367 2368 class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> { 2369 public: 2370 explicit LStringCharFromCode(LOperand* context, LOperand* char_code) { 2371 inputs_[0] = context; 2372 inputs_[1] = char_code; 2373 } 2374 2375 LOperand* context() { return inputs_[0]; } 2376 LOperand* char_code() { return inputs_[1]; } 2377 2378 DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode, "string-char-from-code") 2379 DECLARE_HYDROGEN_ACCESSOR(StringCharFromCode) 2380 }; 2381 2382 2383 class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> { 2384 public: 2385 explicit LCheckValue(LOperand* value) { 2386 inputs_[0] = value; 2387 } 2388 2389 LOperand* value() { return inputs_[0]; } 2390 2391 DECLARE_CONCRETE_INSTRUCTION(CheckValue, "check-value") 2392 DECLARE_HYDROGEN_ACCESSOR(CheckValue) 2393 }; 2394 2395 2396 class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 0> { 2397 public: 2398 explicit LCheckInstanceType(LOperand* value) { 2399 inputs_[0] = value; 2400 } 2401 2402 LOperand* value() { return inputs_[0]; } 2403 2404 DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType, "check-instance-type") 2405 DECLARE_HYDROGEN_ACCESSOR(CheckInstanceType) 2406 }; 2407 2408 2409 class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 0> { 2410 public: 2411 explicit LCheckMaps(LOperand* value = NULL) { 2412 inputs_[0] = value; 2413 } 2414 2415 LOperand* value() { return inputs_[0]; } 2416 2417 DECLARE_CONCRETE_INSTRUCTION(CheckMaps, "check-maps") 2418 DECLARE_HYDROGEN_ACCESSOR(CheckMaps) 2419 }; 2420 2421 2422 class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> { 2423 public: 2424 explicit LCheckSmi(LOperand* value) { 2425 inputs_[0] = value; 2426 } 2427 2428 LOperand* value() { return inputs_[0]; } 2429 2430 DECLARE_CONCRETE_INSTRUCTION(CheckSmi, "check-smi") 2431 }; 2432 2433 2434 class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 0> { 2435 public: 2436 explicit LClampDToUint8(LOperand* unclamped) { 2437 inputs_[0] = unclamped; 2438 } 2439 2440 LOperand* unclamped() { return inputs_[0]; } 2441 2442 DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8") 2443 }; 2444 2445 2446 class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> { 2447 public: 2448 explicit LClampIToUint8(LOperand* unclamped) { 2449 inputs_[0] = unclamped; 2450 } 2451 2452 LOperand* unclamped() { return inputs_[0]; } 2453 2454 DECLARE_CONCRETE_INSTRUCTION(ClampIToUint8, "clamp-i-to-uint8") 2455 }; 2456 2457 2458 class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> { 2459 public: 2460 LClampTToUint8(LOperand* unclamped, 2461 LOperand* temp_xmm) { 2462 inputs_[0] = unclamped; 2463 temps_[0] = temp_xmm; 2464 } 2465 2466 LOperand* unclamped() { return inputs_[0]; } 2467 LOperand* temp_xmm() { return temps_[0]; } 2468 2469 DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8") 2470 }; 2471 2472 2473 class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> { 2474 public: 2475 explicit LCheckNonSmi(LOperand* value) { 2476 inputs_[0] = value; 2477 } 2478 2479 LOperand* value() { return inputs_[0]; } 2480 2481 DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check-non-smi") 2482 DECLARE_HYDROGEN_ACCESSOR(CheckHeapObject) 2483 }; 2484 2485 2486 class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> { 2487 public: 2488 explicit LDoubleBits(LOperand* value) { 2489 inputs_[0] = value; 2490 } 2491 2492 LOperand* value() { return inputs_[0]; } 2493 2494 DECLARE_CONCRETE_INSTRUCTION(DoubleBits, "double-bits") 2495 DECLARE_HYDROGEN_ACCESSOR(DoubleBits) 2496 }; 2497 2498 2499 class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> { 2500 public: 2501 LConstructDouble(LOperand* hi, LOperand* lo) { 2502 inputs_[0] = hi; 2503 inputs_[1] = lo; 2504 } 2505 2506 LOperand* hi() { return inputs_[0]; } 2507 LOperand* lo() { return inputs_[1]; } 2508 2509 DECLARE_CONCRETE_INSTRUCTION(ConstructDouble, "construct-double") 2510 }; 2511 2512 2513 class LAllocate FINAL : public LTemplateInstruction<1, 2, 1> { 2514 public: 2515 LAllocate(LOperand* context, LOperand* size, LOperand* temp) { 2516 inputs_[0] = context; 2517 inputs_[1] = size; 2518 temps_[0] = temp; 2519 } 2520 2521 LOperand* context() { return inputs_[0]; } 2522 LOperand* size() { return inputs_[1]; } 2523 LOperand* temp() { return temps_[0]; } 2524 2525 DECLARE_CONCRETE_INSTRUCTION(Allocate, "allocate") 2526 DECLARE_HYDROGEN_ACCESSOR(Allocate) 2527 }; 2528 2529 2530 class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> { 2531 public: 2532 explicit LRegExpLiteral(LOperand* context) { 2533 inputs_[0] = context; 2534 } 2535 2536 LOperand* context() { return inputs_[0]; } 2537 2538 DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral, "regexp-literal") 2539 DECLARE_HYDROGEN_ACCESSOR(RegExpLiteral) 2540 }; 2541 2542 2543 class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> { 2544 public: 2545 explicit LFunctionLiteral(LOperand* context) { 2546 inputs_[0] = context; 2547 } 2548 2549 LOperand* context() { return inputs_[0]; } 2550 2551 DECLARE_CONCRETE_INSTRUCTION(FunctionLiteral, "function-literal") 2552 DECLARE_HYDROGEN_ACCESSOR(FunctionLiteral) 2553 }; 2554 2555 2556 class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> { 2557 public: 2558 explicit LToFastProperties(LOperand* value) { 2559 inputs_[0] = value; 2560 } 2561 2562 LOperand* value() { return inputs_[0]; } 2563 2564 DECLARE_CONCRETE_INSTRUCTION(ToFastProperties, "to-fast-properties") 2565 DECLARE_HYDROGEN_ACCESSOR(ToFastProperties) 2566 }; 2567 2568 2569 class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> { 2570 public: 2571 LTypeof(LOperand* context, LOperand* value) { 2572 inputs_[0] = context; 2573 inputs_[1] = value; 2574 } 2575 2576 LOperand* context() { return inputs_[0]; } 2577 LOperand* value() { return inputs_[1]; } 2578 2579 DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof") 2580 }; 2581 2582 2583 class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> { 2584 public: 2585 explicit LTypeofIsAndBranch(LOperand* value) { 2586 inputs_[0] = value; 2587 } 2588 2589 LOperand* value() { return inputs_[0]; } 2590 2591 DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch, "typeof-is-and-branch") 2592 DECLARE_HYDROGEN_ACCESSOR(TypeofIsAndBranch) 2593 2594 Handle<String> type_literal() { return hydrogen()->type_literal(); } 2595 2596 virtual void PrintDataTo(StringStream* stream) OVERRIDE; 2597 }; 2598 2599 2600 class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> { 2601 public: 2602 explicit LIsConstructCallAndBranch(LOperand* temp) { 2603 temps_[0] = temp; 2604 } 2605 2606 LOperand* temp() { return temps_[0]; } 2607 2608 DECLARE_CONCRETE_INSTRUCTION(IsConstructCallAndBranch, 2609 "is-construct-call-and-branch") 2610 DECLARE_HYDROGEN_ACCESSOR(IsConstructCallAndBranch) 2611 }; 2612 2613 2614 class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> { 2615 public: 2616 LOsrEntry() {} 2617 2618 virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { 2619 return false; 2620 } 2621 DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry") 2622 }; 2623 2624 2625 class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> { 2626 public: 2627 explicit LStackCheck(LOperand* context) { 2628 inputs_[0] = context; 2629 } 2630 2631 LOperand* context() { return inputs_[0]; } 2632 2633 DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check") 2634 DECLARE_HYDROGEN_ACCESSOR(StackCheck) 2635 2636 Label* done_label() { return &done_label_; } 2637 2638 private: 2639 Label done_label_; 2640 }; 2641 2642 2643 class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> { 2644 public: 2645 LForInPrepareMap(LOperand* context, LOperand* object) { 2646 inputs_[0] = context; 2647 inputs_[1] = object; 2648 } 2649 2650 LOperand* context() { return inputs_[0]; } 2651 LOperand* object() { return inputs_[1]; } 2652 2653 DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap, "for-in-prepare-map") 2654 }; 2655 2656 2657 class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> { 2658 public: 2659 explicit LForInCacheArray(LOperand* map) { 2660 inputs_[0] = map; 2661 } 2662 2663 LOperand* map() { return inputs_[0]; } 2664 2665 DECLARE_CONCRETE_INSTRUCTION(ForInCacheArray, "for-in-cache-array") 2666 2667 int idx() { 2668 return HForInCacheArray::cast(this->hydrogen_value())->idx(); 2669 } 2670 }; 2671 2672 2673 class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> { 2674 public: 2675 LCheckMapValue(LOperand* value, LOperand* map) { 2676 inputs_[0] = value; 2677 inputs_[1] = map; 2678 } 2679 2680 LOperand* value() { return inputs_[0]; } 2681 LOperand* map() { return inputs_[1]; } 2682 2683 DECLARE_CONCRETE_INSTRUCTION(CheckMapValue, "check-map-value") 2684 }; 2685 2686 2687 class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> { 2688 public: 2689 LLoadFieldByIndex(LOperand* object, LOperand* index) { 2690 inputs_[0] = object; 2691 inputs_[1] = index; 2692 } 2693 2694 LOperand* object() { return inputs_[0]; } 2695 LOperand* index() { return inputs_[1]; } 2696 2697 DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex, "load-field-by-index") 2698 }; 2699 2700 2701 class LStoreFrameContext: public LTemplateInstruction<0, 1, 0> { 2702 public: 2703 explicit LStoreFrameContext(LOperand* context) { 2704 inputs_[0] = context; 2705 } 2706 2707 LOperand* context() { return inputs_[0]; } 2708 2709 DECLARE_CONCRETE_INSTRUCTION(StoreFrameContext, "store-frame-context") 2710 }; 2711 2712 2713 class LAllocateBlockContext: public LTemplateInstruction<1, 2, 0> { 2714 public: 2715 LAllocateBlockContext(LOperand* context, LOperand* function) { 2716 inputs_[0] = context; 2717 inputs_[1] = function; 2718 } 2719 2720 LOperand* context() { return inputs_[0]; } 2721 LOperand* function() { return inputs_[1]; } 2722 2723 Handle<ScopeInfo> scope_info() { return hydrogen()->scope_info(); } 2724 2725 DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext, "allocate-block-context") 2726 DECLARE_HYDROGEN_ACCESSOR(AllocateBlockContext) 2727 }; 2728 2729 2730 class LChunkBuilder; 2731 class LPlatformChunk FINAL : public LChunk { 2732 public: 2733 LPlatformChunk(CompilationInfo* info, HGraph* graph) 2734 : LChunk(info, graph), 2735 dehoisted_key_ids_(graph->GetMaximumValueID(), graph->zone()) { } 2736 2737 int GetNextSpillIndex(RegisterKind kind); 2738 LOperand* GetNextSpillSlot(RegisterKind kind); 2739 BitVector* GetDehoistedKeyIds() { return &dehoisted_key_ids_; } 2740 bool IsDehoistedKey(HValue* value) { 2741 return dehoisted_key_ids_.Contains(value->id()); 2742 } 2743 2744 private: 2745 BitVector dehoisted_key_ids_; 2746 }; 2747 2748 2749 class LChunkBuilder FINAL : public LChunkBuilderBase { 2750 public: 2751 LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator) 2752 : LChunkBuilderBase(info, graph), 2753 current_instruction_(NULL), 2754 current_block_(NULL), 2755 next_block_(NULL), 2756 allocator_(allocator) {} 2757 2758 // Build the sequence for the graph. 2759 LPlatformChunk* Build(); 2760 2761 // Declare methods that deal with the individual node types. 2762 #define DECLARE_DO(type) LInstruction* Do##type(H##type* node); 2763 HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_DO) 2764 #undef DECLARE_DO 2765 2766 LInstruction* DoMathFloor(HUnaryMathOperation* instr); 2767 LInstruction* DoMathRound(HUnaryMathOperation* instr); 2768 LInstruction* DoMathFround(HUnaryMathOperation* instr); 2769 LInstruction* DoMathAbs(HUnaryMathOperation* instr); 2770 LInstruction* DoMathLog(HUnaryMathOperation* instr); 2771 LInstruction* DoMathExp(HUnaryMathOperation* instr); 2772 LInstruction* DoMathSqrt(HUnaryMathOperation* instr); 2773 LInstruction* DoMathPowHalf(HUnaryMathOperation* instr); 2774 LInstruction* DoMathClz32(HUnaryMathOperation* instr); 2775 LInstruction* DoDivByPowerOf2I(HDiv* instr); 2776 LInstruction* DoDivByConstI(HDiv* instr); 2777 LInstruction* DoDivI(HDiv* instr); 2778 LInstruction* DoModByPowerOf2I(HMod* instr); 2779 LInstruction* DoModByConstI(HMod* instr); 2780 LInstruction* DoModI(HMod* instr); 2781 LInstruction* DoFlooringDivByPowerOf2I(HMathFloorOfDiv* instr); 2782 LInstruction* DoFlooringDivByConstI(HMathFloorOfDiv* instr); 2783 LInstruction* DoFlooringDivI(HMathFloorOfDiv* instr); 2784 2785 private: 2786 // Methods for getting operands for Use / Define / Temp. 2787 LUnallocated* ToUnallocated(Register reg); 2788 LUnallocated* ToUnallocated(XMMRegister reg); 2789 2790 // Methods for setting up define-use relationships. 2791 MUST_USE_RESULT LOperand* Use(HValue* value, LUnallocated* operand); 2792 MUST_USE_RESULT LOperand* UseFixed(HValue* value, Register fixed_register); 2793 MUST_USE_RESULT LOperand* UseFixedDouble(HValue* value, 2794 XMMRegister fixed_register); 2795 2796 // A value that is guaranteed to be allocated to a register. 2797 // Operand created by UseRegister is guaranteed to be live until the end of 2798 // instruction. This means that register allocator will not reuse it's 2799 // register for any other operand inside instruction. 2800 // Operand created by UseRegisterAtStart is guaranteed to be live only at 2801 // instruction start. Register allocator is free to assign the same register 2802 // to some other operand used inside instruction (i.e. temporary or 2803 // output). 2804 MUST_USE_RESULT LOperand* UseRegister(HValue* value); 2805 MUST_USE_RESULT LOperand* UseRegisterAtStart(HValue* value); 2806 2807 // An input operand in a register that may be trashed. 2808 MUST_USE_RESULT LOperand* UseTempRegister(HValue* value); 2809 2810 // An input operand in a register that may be trashed or a constant operand. 2811 MUST_USE_RESULT LOperand* UseTempRegisterOrConstant(HValue* value); 2812 2813 // An input operand in a register or stack slot. 2814 MUST_USE_RESULT LOperand* Use(HValue* value); 2815 MUST_USE_RESULT LOperand* UseAtStart(HValue* value); 2816 2817 // An input operand in a register, stack slot or a constant operand. 2818 MUST_USE_RESULT LOperand* UseOrConstant(HValue* value); 2819 MUST_USE_RESULT LOperand* UseOrConstantAtStart(HValue* value); 2820 2821 // An input operand in a register or a constant operand. 2822 MUST_USE_RESULT LOperand* UseRegisterOrConstant(HValue* value); 2823 MUST_USE_RESULT LOperand* UseRegisterOrConstantAtStart(HValue* value); 2824 2825 // An input operand in a constant operand. 2826 MUST_USE_RESULT LOperand* UseConstant(HValue* value); 2827 2828 // An input operand in register, stack slot or a constant operand. 2829 // Will not be moved to a register even if one is freely available. 2830 virtual MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE; 2831 2832 // Temporary operand that must be in a register. 2833 MUST_USE_RESULT LUnallocated* TempRegister(); 2834 MUST_USE_RESULT LOperand* FixedTemp(Register reg); 2835 MUST_USE_RESULT LOperand* FixedTemp(XMMRegister reg); 2836 2837 // Methods for setting up define-use relationships. 2838 // Return the same instruction that they are passed. 2839 LInstruction* Define(LTemplateResultInstruction<1>* instr, 2840 LUnallocated* result); 2841 LInstruction* DefineAsRegister(LTemplateResultInstruction<1>* instr); 2842 LInstruction* DefineAsSpilled(LTemplateResultInstruction<1>* instr, 2843 int index); 2844 LInstruction* DefineSameAsFirst(LTemplateResultInstruction<1>* instr); 2845 LInstruction* DefineFixed(LTemplateResultInstruction<1>* instr, 2846 Register reg); 2847 LInstruction* DefineFixedDouble(LTemplateResultInstruction<1>* instr, 2848 XMMRegister reg); 2849 // Assigns an environment to an instruction. An instruction which can 2850 // deoptimize must have an environment. 2851 LInstruction* AssignEnvironment(LInstruction* instr); 2852 // Assigns a pointer map to an instruction. An instruction which can 2853 // trigger a GC or a lazy deoptimization must have a pointer map. 2854 LInstruction* AssignPointerMap(LInstruction* instr); 2855 2856 enum CanDeoptimize { CAN_DEOPTIMIZE_EAGERLY, CANNOT_DEOPTIMIZE_EAGERLY }; 2857 2858 // Marks a call for the register allocator. Assigns a pointer map to 2859 // support GC and lazy deoptimization. Assigns an environment to support 2860 // eager deoptimization if CAN_DEOPTIMIZE_EAGERLY. 2861 LInstruction* MarkAsCall( 2862 LInstruction* instr, 2863 HInstruction* hinstr, 2864 CanDeoptimize can_deoptimize = CANNOT_DEOPTIMIZE_EAGERLY); 2865 2866 void VisitInstruction(HInstruction* current); 2867 void AddInstruction(LInstruction* instr, HInstruction* current); 2868 2869 void DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block); 2870 LInstruction* DoShift(Token::Value op, HBitwiseBinaryOperation* instr); 2871 LInstruction* DoArithmeticD(Token::Value op, 2872 HArithmeticBinaryOperation* instr); 2873 LInstruction* DoArithmeticT(Token::Value op, 2874 HBinaryOperation* instr); 2875 void FindDehoistedKeyDefinitions(HValue* candidate); 2876 2877 HInstruction* current_instruction_; 2878 HBasicBlock* current_block_; 2879 HBasicBlock* next_block_; 2880 LAllocator* allocator_; 2881 2882 DISALLOW_COPY_AND_ASSIGN(LChunkBuilder); 2883 }; 2884 2885 #undef DECLARE_HYDROGEN_ACCESSOR 2886 #undef DECLARE_CONCRETE_INSTRUCTION 2887 2888 } } // namespace v8::int 2889 2890 #endif // V8_X64_LITHIUM_X64_H_ 2891
