src/x64/lithium-x64.h

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