src/x64/lithium-x64.h

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