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