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