CSE2410 Fall 2014 Bounce

// Copyright 2012 the V8 project authors. All rights reserved.

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

//       notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

//       copyright notice, this list of conditions and the following

//       disclaimer in the documentation and/or other materials provided

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef V8_MIPS_LITHIUM_MIPS_H_

#define V8_MIPS_LITHIUM_MIPS_H_

#include "hydrogen.h"

#include "lithium-allocator.h"

#include "lithium.h"

#include "safepoint-table.h"

#include "utils.h"

namespace v8 {

namespace internal {

// Forward declarations.

class LCodeGen;

#define LITHIUM_CONCRETE_INSTRUCTION_LIST(V)    \

  V(AccessArgumentsAt)                          \

  V(AddI)                                       \

  V(Allocate)                                   \

  V(ApplyArguments)                             \

  V(ArgumentsElements)                          \

  V(ArgumentsLength)                            \

  V(ArithmeticD)                                \

  V(ArithmeticT)                                \

  V(BitI)                                       \

  V(BoundsCheck)                                \

  V(Branch)                                     \

  V(CallConstantFunction)                       \

  V(CallFunction)                               \

  V(CallGlobal)                                 \

  V(CallKeyed)                                  \

  V(CallKnownGlobal)                            \

  V(CallNamed)                                  \

  V(CallNew)                                    \

  V(CallNewArray)                               \

  V(CallRuntime)                                \

  V(CallStub)                                   \

  V(CheckInstanceType)                          \

  V(CheckMaps)                                  \

  V(CheckMapValue)                              \

  V(CheckNonSmi)                                \

  V(CheckSmi)                                   \

  V(CheckValue)                                 \

  V(ClampDToUint8)                              \

  V(ClampIToUint8)                              \

  V(ClampTToUint8)                              \

  V(ClassOfTestAndBranch)                       \

  V(CompareNumericAndBranch)                    \

  V(CmpObjectEqAndBranch)                       \

  V(CmpHoleAndBranch)                           \

  V(CmpMapAndBranch)                            \

  V(CmpT)                                       \

  V(ConstantD)                                  \

  V(ConstantE)                                  \

  V(ConstantI)                                  \

  V(ConstantS)                                  \

  V(ConstantT)                                  \

  V(Context)                                    \

  V(DateField)                                  \

  V(DebugBreak)                                 \

  V(DeclareGlobals)                             \

  V(Deoptimize)                                 \

  V(DivI)                                       \

  V(DoubleToI)                                  \

  V(DoubleToSmi)                                \

  V(Drop)                                       \

  V(DummyUse)                                   \

  V(ElementsKind)                               \

  V(ForInCacheArray)                            \

  V(ForInPrepareMap)                            \

  V(FunctionLiteral)                            \

  V(GetCachedArrayIndex)                        \

  V(GlobalObject)                               \

  V(GlobalReceiver)                             \

  V(Goto)                                       \

  V(HasCachedArrayIndexAndBranch)               \

  V(HasInstanceTypeAndBranch)                   \

  V(InnerAllocatedObject)                       \

  V(InstanceOf)                                 \

  V(InstanceOfKnownGlobal)                      \

  V(InstructionGap)                             \

  V(Integer32ToDouble)                          \

  V(Integer32ToSmi)                             \

  V(InvokeFunction)                             \

  V(IsConstructCallAndBranch)                   \

  V(IsObjectAndBranch)                          \

  V(IsStringAndBranch)                          \

  V(IsSmiAndBranch)                             \

  V(IsUndetectableAndBranch)                    \

  V(Label)                                      \

  V(LazyBailout)                                \

  V(LoadContextSlot)                            \

  V(LoadExternalArrayPointer)                   \

  V(LoadRoot)                                   \

  V(LoadFieldByIndex)                           \

  V(LoadFunctionPrototype)                      \

  V(LoadGlobalCell)                             \

  V(LoadGlobalGeneric)                          \

  V(LoadKeyed)                                  \

  V(LoadKeyedGeneric)                           \

  V(LoadNamedField)                             \

  V(LoadNamedGeneric)                           \

  V(MapEnumLength)                              \

  V(MathAbs)                                    \

  V(MathCos)                                    \

  V(MathExp)                                    \

  V(MathFloor)                                  \

  V(MathFloorOfDiv)                             \

  V(MathLog)                                    \

  V(MathMinMax)                                 \

  V(MathPowHalf)                                \

  V(MathRound)                                  \

  V(MathSin)                                    \

  V(MathSqrt)                                   \

  V(MathTan)                                    \

  V(ModI)                                       \

  V(MulI)                                       \

  V(MultiplyAddD)                               \

  V(NumberTagD)                                 \

  V(NumberTagI)                                 \

  V(NumberTagU)                                 \

  V(NumberUntagD)                               \

  V(OsrEntry)                                   \

  V(OuterContext)                               \

  V(Parameter)                                  \

  V(Power)                                      \

  V(PushArgument)                               \

  V(Random)                                     \

  V(RegExpLiteral)                              \

  V(Return)                                     \

  V(SeqStringSetChar)                           \

  V(ShiftI)                                     \

  V(SmiTag)                                     \

  V(SmiUntag)                                   \

  V(StackCheck)                                 \

  V(StoreCodeEntry)                             \

  V(StoreContextSlot)                           \

  V(StoreGlobalCell)                            \

  V(StoreGlobalGeneric)                         \

  V(StoreKeyed)                                 \

  V(StoreKeyedGeneric)                          \

  V(StoreNamedField)                            \

  V(StoreNamedGeneric)                          \

  V(StringAdd)                                  \

  V(StringCharCodeAt)                           \

  V(StringCharFromCode)                         \

  V(StringCompareAndBranch)                     \

  V(SubI)                                       \

  V(TaggedToI)                                  \

  V(ThisFunction)                               \

  V(Throw)                                      \

  V(ToFastProperties)                           \

  V(TransitionElementsKind)                     \

  V(TrapAllocationMemento)                      \

  V(Typeof)                                     \

  V(TypeofIsAndBranch)                          \

  V(Uint32ToDouble)                             \

  V(UnknownOSRValue)                            \

  V(ValueOf)                                    \

  V(WrapReceiver)

#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic)                        \

  virtual Opcode opcode() const V8_FINAL V8_OVERRIDE {                      \

    return LInstruction::k##type;                                           \

  }                                                                         \

  virtual void CompileToNative(LCodeGen* generator) V8_FINAL V8_OVERRIDE;   \

  virtual const char* Mnemonic() const V8_FINAL V8_OVERRIDE {               \

    return mnemonic;                                                        \

  }                                                                         \

  static L##type* cast(LInstruction* instr) {                               \

    ASSERT(instr->Is##type());                                              \

    return reinterpret_cast<L##type*>(instr);                               \

  }

#define DECLARE_HYDROGEN_ACCESSOR(type)     \

  H##type* hydrogen() const {               \

    return H##type::cast(hydrogen_value()); \

  }

class LInstruction : public ZoneObject {

 public:

  LInstruction()

      : environment_(NULL),

        hydrogen_value_(NULL),

        bit_field_(IsCallBits::encode(false)) {

  }

  virtual ~LInstruction() {}

  virtual void CompileToNative(LCodeGen* generator) = 0;

  virtual const char* Mnemonic() const = 0;

  virtual void PrintTo(StringStream* stream);

  virtual void PrintDataTo(StringStream* stream);

  virtual void PrintOutputOperandTo(StringStream* stream);

  enum Opcode {

    // Declare a unique enum value for each instruction.

#define DECLARE_OPCODE(type) k##type,

    LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE)

    kNumberOfInstructions

#undef DECLARE_OPCODE

  };

  virtual Opcode opcode() const = 0;

  // Declare non-virtual type testers for all leaf IR classes.

#define DECLARE_PREDICATE(type) \

  bool Is##type() const { return opcode() == k##type; }

  LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_PREDICATE)

#undef DECLARE_PREDICATE

  // Declare virtual predicates for instructions that don't have

  // an opcode.

  virtual bool IsGap() const { return false; }

  virtual bool IsControl() const { return false; }

  void set_environment(LEnvironment* env) { environment_ = env; }

  LEnvironment* environment() const { return environment_; }

  bool HasEnvironment() const { return environment_ != NULL; }

  void set_pointer_map(LPointerMap* p) { pointer_map_.set(p); }

  LPointerMap* pointer_map() const { return pointer_map_.get(); }

  bool HasPointerMap() const { return pointer_map_.is_set(); }

  void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; }

  HValue* hydrogen_value() const { return hydrogen_value_; }

  virtual void SetDeferredLazyDeoptimizationEnvironment(LEnvironment* env) { }

  void MarkAsCall() { bit_field_ = IsCallBits::update(bit_field_, true); }

  bool IsCall() const { return IsCallBits::decode(bit_field_); }

  // Interface to the register allocator and iterators.

  bool ClobbersTemps() const { return IsCall(); }

  bool ClobbersRegisters() const { return IsCall(); }

  virtual bool ClobbersDoubleRegisters() const { return IsCall(); }

  // Interface to the register allocator and iterators.

  bool IsMarkedAsCall() const { return IsCall(); }

  virtual bool HasResult() const = 0;

  virtual LOperand* result() const = 0;

  LOperand* FirstInput() { return InputAt(0); }

  LOperand* Output() { return HasResult() ? result() : NULL; }

  virtual bool HasInterestingComment(LCodeGen* gen) const { return true; }

#ifdef DEBUG

  void VerifyCall();

#endif

 private:

  // Iterator interface.

  friend class InputIterator;

  virtual int InputCount() = 0;

  virtual LOperand* InputAt(int i) = 0;

  friend class TempIterator;

  virtual int TempCount() = 0;

  virtual LOperand* TempAt(int i) = 0;

  class IsCallBits: public BitField<bool, 0, 1> {};

  LEnvironment* environment_;

  SetOncePointer<LPointerMap> pointer_map_;

  HValue* hydrogen_value_;

  int bit_field_;

};

// R = number of result operands (0 or 1).

// I = number of input operands.

// T = number of temporary operands.

template<int R, int I, int T>

class LTemplateInstruction : public LInstruction {

 public:

  // Allow 0 or 1 output operands.

  STATIC_ASSERT(R == 0 || R == 1);

  virtual bool HasResult() const V8_FINAL V8_OVERRIDE {

    return R != 0 && result() != NULL;

  }

  void set_result(LOperand* operand) { results_[0] = operand; }

  LOperand* result() const { return results_[0]; }

 protected:

  EmbeddedContainer<LOperand*, R> results_;

  EmbeddedContainer<LOperand*, I> inputs_;

  EmbeddedContainer<LOperand*, T> temps_;

 private:

  virtual int InputCount() V8_FINAL V8_OVERRIDE { return I; }

  virtual LOperand* InputAt(int i) V8_FINAL V8_OVERRIDE { return inputs_[i]; }

  virtual int TempCount() V8_FINAL V8_OVERRIDE { return T; }

  virtual LOperand* TempAt(int i) V8_FINAL V8_OVERRIDE { return temps_[i]; }

};

class LGap : public LTemplateInstruction<0, 0, 0> {

 public:

  explicit LGap(HBasicBlock* block)

      : block_(block) {

    parallel_moves_[BEFORE] = NULL;

    parallel_moves_[START] = NULL;

    parallel_moves_[END] = NULL;

    parallel_moves_[AFTER] = NULL;

  }

  // Can't use the DECLARE-macro here because of sub-classes.

  virtual bool IsGap() const V8_FINAL V8_OVERRIDE { return true; }

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

  static LGap* cast(LInstruction* instr) {

    ASSERT(instr->IsGap());

    return reinterpret_cast<LGap*>(instr);

  }

  bool IsRedundant() const;

  HBasicBlock* block() const { return block_; }

  enum InnerPosition {

    BEFORE,

    START,

    END,

    AFTER,

    FIRST_INNER_POSITION = BEFORE,

    LAST_INNER_POSITION = AFTER

  };

  LParallelMove* GetOrCreateParallelMove(InnerPosition pos, Zone* zone)  {

    if (parallel_moves_[pos] == NULL) {

      parallel_moves_[pos] = new(zone) LParallelMove(zone);

    }

    return parallel_moves_[pos];

  }

  LParallelMove* GetParallelMove(InnerPosition pos)  {

    return parallel_moves_[pos];

  }

 private:

  LParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];

  HBasicBlock* block_;

};

class LInstructionGap V8_FINAL : public LGap {

 public:

  explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }

  virtual bool HasInterestingComment(LCodeGen* gen) const V8_OVERRIDE {

    return !IsRedundant();

  }

  DECLARE_CONCRETE_INSTRUCTION(InstructionGap, "gap")

};

class LGoto V8_FINAL : public LTemplateInstruction<0, 0, 0> {

 public:

  explicit LGoto(HBasicBlock* block) : block_(block) { }

  virtual bool HasInterestingComment(LCodeGen* gen) const V8_OVERRIDE;

  DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

  virtual bool IsControl() const V8_OVERRIDE { return true; }

  int block_id() const { return block_->block_id(); }

 private:

  HBasicBlock* block_;

};

class LLazyBailout V8_FINAL : public LTemplateInstruction<0, 0, 0> {

 public:

  LLazyBailout() : gap_instructions_size_(0) { }

  DECLARE_CONCRETE_INSTRUCTION(LazyBailout, "lazy-bailout")

  void set_gap_instructions_size(int gap_instructions_size) {

    gap_instructions_size_ = gap_instructions_size;

  }

  int gap_instructions_size() { return gap_instructions_size_; }

 private:

  int gap_instructions_size_;

};

class LDummyUse V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LDummyUse(LOperand* value) {

    inputs_[0] = value;

  }

  DECLARE_CONCRETE_INSTRUCTION(DummyUse, "dummy-use")

};

class LDeoptimize V8_FINAL : public LTemplateInstruction<0, 0, 0> {

 public:

  DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")

  DECLARE_HYDROGEN_ACCESSOR(Deoptimize)

};

class LLabel V8_FINAL : public LGap {

 public:

  explicit LLabel(HBasicBlock* block)

      : LGap(block), replacement_(NULL) { }

  virtual bool HasInterestingComment(LCodeGen* gen) const V8_OVERRIDE {

    return false;

  }

  DECLARE_CONCRETE_INSTRUCTION(Label, "label")

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

  int block_id() const { return block()->block_id(); }

  bool is_loop_header() const { return block()->IsLoopHeader(); }

  bool is_osr_entry() const { return block()->is_osr_entry(); }

  Label* label() { return &label_; }

  LLabel* replacement() const { return replacement_; }

  void set_replacement(LLabel* label) { replacement_ = label; }

  bool HasReplacement() const { return replacement_ != NULL; }

 private:

  Label label_;

  LLabel* replacement_;

};

class LParameter V8_FINAL : public LTemplateInstruction<1, 0, 0> {

 public:

  virtual bool HasInterestingComment(LCodeGen* gen) const V8_OVERRIDE {

    return false;

  }

  DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")

};

class LCallStub V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LCallStub(LOperand* context) {

    inputs_[0] = context;

  }

  LOperand* context() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(CallStub, "call-stub")

  DECLARE_HYDROGEN_ACCESSOR(CallStub)

  TranscendentalCache::Type transcendental_type() {

    return hydrogen()->transcendental_type();

  }

};

class LUnknownOSRValue V8_FINAL : public LTemplateInstruction<1, 0, 0> {

 public:

  virtual bool HasInterestingComment(LCodeGen* gen) const V8_OVERRIDE {

    return false;

  }

  DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")

};

template<int I, int T>

class LControlInstruction : public LTemplateInstruction<0, I, T> {

 public:

  LControlInstruction() : false_label_(NULL), true_label_(NULL) { }

  virtual bool IsControl() const V8_FINAL V8_OVERRIDE { return true; }

  int SuccessorCount() { return hydrogen()->SuccessorCount(); }

  HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }

  int TrueDestination(LChunk* chunk) {

    return chunk->LookupDestination(true_block_id());

  }

  int FalseDestination(LChunk* chunk) {

    return chunk->LookupDestination(false_block_id());

  }

  Label* TrueLabel(LChunk* chunk) {

    if (true_label_ == NULL) {

      true_label_ = chunk->GetAssemblyLabel(TrueDestination(chunk));

    }

    return true_label_;

  }

  Label* FalseLabel(LChunk* chunk) {

    if (false_label_ == NULL) {

      false_label_ = chunk->GetAssemblyLabel(FalseDestination(chunk));

    }

    return false_label_;

  }

 protected:

  int true_block_id() { return SuccessorAt(0)->block_id(); }

  int false_block_id() { return SuccessorAt(1)->block_id(); }

 private:

  HControlInstruction* hydrogen() {

    return HControlInstruction::cast(this->hydrogen_value());

  }

  Label* false_label_;

  Label* true_label_;

};

class LWrapReceiver V8_FINAL : public LTemplateInstruction<1, 2, 0> {

 public:

  LWrapReceiver(LOperand* receiver, LOperand* function) {

    inputs_[0] = receiver;

    inputs_[1] = function;

  }

  DECLARE_CONCRETE_INSTRUCTION(WrapReceiver, "wrap-receiver")

  LOperand* receiver() { return inputs_[0]; }

  LOperand* function() { return inputs_[1]; }

};

class LApplyArguments V8_FINAL : public LTemplateInstruction<1, 4, 0> {

 public:

  LApplyArguments(LOperand* function,

                  LOperand* receiver,

                  LOperand* length,

                  LOperand* elements) {

    inputs_[0] = function;

    inputs_[1] = receiver;

    inputs_[2] = length;

    inputs_[3] = elements;

  }

  DECLARE_CONCRETE_INSTRUCTION(ApplyArguments, "apply-arguments")

  LOperand* function() { return inputs_[0]; }

  LOperand* receiver() { return inputs_[1]; }

  LOperand* length() { return inputs_[2]; }

  LOperand* elements() { return inputs_[3]; }

};

class LAccessArgumentsAt V8_FINAL : public LTemplateInstruction<1, 3, 0> {

 public:

  LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {

    inputs_[0] = arguments;

    inputs_[1] = length;

    inputs_[2] = index;

  }

  DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at")

  LOperand* arguments() { return inputs_[0]; }

  LOperand* length() { return inputs_[1]; }

  LOperand* index() { return inputs_[2]; }

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LArgumentsLength V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LArgumentsLength(LOperand* elements) {

    inputs_[0] = elements;

  }

  LOperand* elements() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength, "arguments-length")

};

class LArgumentsElements V8_FINAL : public LTemplateInstruction<1, 0, 0> {

 public:

  DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")

  DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)

};

class LModI V8_FINAL : public LTemplateInstruction<1, 2, 3> {

 public:

  // Used when the right hand is a constant power of 2.

  LModI(LOperand* left,

        LOperand* right) {

    inputs_[0] = left;

    inputs_[1] = right;

    temps_[0] = NULL;

    temps_[1] = NULL;

    temps_[2] = NULL;

  }

  // Used for the standard case.

  LModI(LOperand* left,

        LOperand* right,

        LOperand* temp,

        LOperand* temp2,

        LOperand* temp3) {

    inputs_[0] = left;

    inputs_[1] = right;

    temps_[0] = temp;

    temps_[1] = temp2;

    temps_[2] = temp3;

  }

  LOperand* left() { return inputs_[0]; }

  LOperand* right() { return inputs_[1]; }

  LOperand* temp() { return temps_[0]; }

  LOperand* temp2() { return temps_[1]; }

  LOperand* temp3() { return temps_[2]; }

  DECLARE_CONCRETE_INSTRUCTION(ModI, "mod-i")

  DECLARE_HYDROGEN_ACCESSOR(Mod)

};

class LDivI V8_FINAL : public LTemplateInstruction<1, 2, 0> {

 public:

  LDivI(LOperand* left, LOperand* right) {

    inputs_[0] = left;

    inputs_[1] = right;

  }

  LOperand* left() { return inputs_[0]; }

  LOperand* right() { return inputs_[1]; }

  DECLARE_CONCRETE_INSTRUCTION(DivI, "div-i")

  DECLARE_HYDROGEN_ACCESSOR(Div)

};

class LMathFloorOfDiv V8_FINAL : public LTemplateInstruction<1, 2, 1> {

 public:

  LMathFloorOfDiv(LOperand* left,

                  LOperand* right,

                  LOperand* temp = NULL) {

    inputs_[0] = left;

    inputs_[1] = right;

    temps_[0] = temp;

  }

  LOperand* left() { return inputs_[0]; }

  LOperand* right() { return inputs_[1]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathFloorOfDiv, "math-floor-of-div")

  DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)

};

class LMulI V8_FINAL : public LTemplateInstruction<1, 2, 0> {

 public:

  LMulI(LOperand* left, LOperand* right) {

    inputs_[0] = left;

    inputs_[1] = right;

  }

  LOperand* left() { return inputs_[0]; }

  LOperand* right() { return inputs_[1]; }

  DECLARE_CONCRETE_INSTRUCTION(MulI, "mul-i")

  DECLARE_HYDROGEN_ACCESSOR(Mul)

};

// Instruction for computing multiplier * multiplicand + addend.

class LMultiplyAddD V8_FINAL : public LTemplateInstruction<1, 3, 0> {

 public:

  LMultiplyAddD(LOperand* addend, LOperand* multiplier,

                LOperand* multiplicand) {

    inputs_[0] = addend;

    inputs_[1] = multiplier;

    inputs_[2] = multiplicand;

  }

  LOperand* addend() { return inputs_[0]; }

  LOperand* multiplier() { return inputs_[1]; }

  LOperand* multiplicand() { return inputs_[2]; }

  DECLARE_CONCRETE_INSTRUCTION(MultiplyAddD, "multiply-add-d")

};

class LDebugBreak V8_FINAL : public LTemplateInstruction<0, 0, 0> {

 public:

  DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")

};

class LCompareNumericAndBranch V8_FINAL : public LControlInstruction<2, 0> {

 public:

  LCompareNumericAndBranch(LOperand* left, LOperand* right) {

    inputs_[0] = left;

    inputs_[1] = right;

  }

  LOperand* left() { return inputs_[0]; }

  LOperand* right() { return inputs_[1]; }

  DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch,

                               "compare-numeric-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(CompareNumericAndBranch)

  Token::Value op() const { return hydrogen()->token(); }

  bool is_double() const {

    return hydrogen()->representation().IsDouble();

  }

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LMathFloor V8_FINAL : public LTemplateInstruction<1, 1, 1> {

 public:

  LMathFloor(LOperand* value, LOperand* temp) {

    inputs_[0] = value;

    temps_[0] = temp;

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathFloor, "math-floor")

  DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)

};

class LMathRound V8_FINAL : public LTemplateInstruction<1, 1, 1> {

 public:

  LMathRound(LOperand* value, LOperand* temp) {

    inputs_[0] = value;

    temps_[0] = temp;

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathRound, "math-round")

  DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)

};

class LMathAbs V8_FINAL : public LTemplateInstruction<1, 2, 0> {

 public:

  LMathAbs(LOperand* context, LOperand* value) {

    inputs_[1] = context;

    inputs_[0] = value;

  }

  LOperand* context() { return inputs_[1]; }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathAbs, "math-abs")

  DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)

};

class LMathLog V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LMathLog(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathLog, "math-log")

};

class LMathSin V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LMathSin(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathSin, "math-sin")

};

class LMathCos V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LMathCos(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathCos, "math-cos")

};

class LMathTan V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LMathTan(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathTan, "math-tan")

};

class LMathExp V8_FINAL : public LTemplateInstruction<1, 1, 3> {

 public:

  LMathExp(LOperand* value,

           LOperand* double_temp,

           LOperand* temp1,

           LOperand* temp2) {

    inputs_[0] = value;

    temps_[0] = temp1;

    temps_[1] = temp2;

    temps_[2] = double_temp;

    ExternalReference::InitializeMathExpData();

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp1() { return temps_[0]; }

  LOperand* temp2() { return temps_[1]; }

  LOperand* double_temp() { return temps_[2]; }

  DECLARE_CONCRETE_INSTRUCTION(MathExp, "math-exp")

};

class LMathSqrt V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LMathSqrt(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathSqrt, "math-sqrt")

};

class LMathPowHalf V8_FINAL : public LTemplateInstruction<1, 1, 1> {

 public:

  LMathPowHalf(LOperand* value, LOperand* temp) {

    inputs_[0] = value;

    temps_[0] = temp;

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MathPowHalf, "math-pow-half")

};

class LCmpObjectEqAndBranch V8_FINAL : public LControlInstruction<2, 0> {

 public:

  LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {

    inputs_[0] = left;

    inputs_[1] = right;

  }

  LOperand* left() { return inputs_[0]; }

  LOperand* right() { return inputs_[1]; }

  DECLARE_CONCRETE_INSTRUCTION(CmpObjectEqAndBranch, "cmp-object-eq-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(CompareObjectEqAndBranch)

};

class LCmpHoleAndBranch V8_FINAL : public LControlInstruction<1, 0> {

 public:

  explicit LCmpHoleAndBranch(LOperand* object) {

    inputs_[0] = object;

  }

  LOperand* object() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(CmpHoleAndBranch, "cmp-hole-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(CompareHoleAndBranch)

};

class LIsObjectAndBranch V8_FINAL : public LControlInstruction<1, 1> {

 public:

  LIsObjectAndBranch(LOperand* value, LOperand* temp) {

    inputs_[0] = value;

    temps_[0] = temp;

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch)

  virtual void PrintDataTo(StringStream* stream);

};

class LIsStringAndBranch V8_FINAL : public LControlInstruction<1, 1> {

 public:

  LIsStringAndBranch(LOperand* value, LOperand* temp) {

    inputs_[0] = value;

    temps_[0] = temp;

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LIsSmiAndBranch V8_FINAL : public LControlInstruction<1, 0> {

 public:

  explicit LIsSmiAndBranch(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LIsUndetectableAndBranch V8_FINAL : public LControlInstruction<1, 1> {

 public:

  explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {

    inputs_[0] = value;

    temps_[0] = temp;

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch,

                               "is-undetectable-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LStringCompareAndBranch V8_FINAL : public LControlInstruction<3, 0> {

 public:

  LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {

    inputs_[0] = context;

    inputs_[1] = left;

    inputs_[2] = right;

  }

  LOperand* context() { return inputs_[0]; }

  LOperand* left() { return inputs_[1]; }

  LOperand* right() { return inputs_[2]; }

  DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch,

                               "string-compare-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch)

  Token::Value op() const { return hydrogen()->token(); }

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LHasInstanceTypeAndBranch V8_FINAL : public LControlInstruction<1, 0> {

 public:

  explicit LHasInstanceTypeAndBranch(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch,

                               "has-instance-type-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LGetCachedArrayIndex V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LGetCachedArrayIndex(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index")

  DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex)

};

class LHasCachedArrayIndexAndBranch V8_FINAL

    : public LControlInstruction<1, 0> {

 public:

  explicit LHasCachedArrayIndexAndBranch(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch,

                               "has-cached-array-index-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch)

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LClassOfTestAndBranch V8_FINAL : public LControlInstruction<1, 1> {

 public:

  LClassOfTestAndBranch(LOperand* value, LOperand* temp) {

    inputs_[0] = value;

    temps_[0] = temp;

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch,

                               "class-of-test-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LCmpT V8_FINAL : public LTemplateInstruction<1, 3, 0> {

 public:

  LCmpT(LOperand* context, LOperand* left, LOperand* right) {

    inputs_[0] = context;

    inputs_[1] = left;

    inputs_[2] = right;

  }

  LOperand* context() { return inputs_[0]; }

  LOperand* left() { return inputs_[1]; }

  LOperand* right() { return inputs_[2]; }

  DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t")

  DECLARE_HYDROGEN_ACCESSOR(CompareGeneric)

  Token::Value op() const { return hydrogen()->token(); }

};

class LInstanceOf V8_FINAL : public LTemplateInstruction<1, 3, 0> {

 public:

  LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {

    inputs_[0] = context;

    inputs_[1] = left;

    inputs_[2] = right;

  }

  LOperand* context() { return inputs_[0]; }

  LOperand* left() { return inputs_[1]; }

  LOperand* right() { return inputs_[2]; }

  DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance-of")

};

class LInstanceOfKnownGlobal V8_FINAL : public LTemplateInstruction<1, 2, 1> {

 public:

  LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {

    inputs_[0] = context;

    inputs_[1] = value;

    temps_[0] = temp;

  }

  LOperand* context() { return inputs_[0]; }

  LOperand* value() { return inputs_[1]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal,

                               "instance-of-known-global")

  DECLARE_HYDROGEN_ACCESSOR(InstanceOfKnownGlobal)

  Handle<JSFunction> function() const { return hydrogen()->function(); }

  LEnvironment* GetDeferredLazyDeoptimizationEnvironment() {

    return lazy_deopt_env_;

  }

  virtual void SetDeferredLazyDeoptimizationEnvironment(

      LEnvironment* env) V8_OVERRIDE {

    lazy_deopt_env_ = env;

  }

 private:

  LEnvironment* lazy_deopt_env_;

};

class LBoundsCheck V8_FINAL : public LTemplateInstruction<0, 2, 0> {

 public:

  LBoundsCheck(LOperand* index, LOperand* length) {

    inputs_[0] = index;

    inputs_[1] = length;

  }

  LOperand* index() { return inputs_[0]; }

  LOperand* length() { return inputs_[1]; }

  DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds-check")

  DECLARE_HYDROGEN_ACCESSOR(BoundsCheck)

};

class LBitI V8_FINAL : public LTemplateInstruction<1, 2, 0> {

 public:

  LBitI(LOperand* left, LOperand* right) {

    inputs_[0] = left;

    inputs_[1] = right;

  }

  LOperand* left() { return inputs_[0]; }

  LOperand* right() { return inputs_[1]; }

  Token::Value op() const { return hydrogen()->op(); }

  DECLARE_CONCRETE_INSTRUCTION(BitI, "bit-i")

  DECLARE_HYDROGEN_ACCESSOR(Bitwise)

};

class LShiftI V8_FINAL : public LTemplateInstruction<1, 2, 0> {

 public:

  LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)

      : op_(op), can_deopt_(can_deopt) {

    inputs_[0] = left;

    inputs_[1] = right;

  }

  Token::Value op() const { return op_; }

  LOperand* left() { return inputs_[0]; }

  LOperand* right() { return inputs_[1]; }

  bool can_deopt() const { return can_deopt_; }

  DECLARE_CONCRETE_INSTRUCTION(ShiftI, "shift-i")

 private:

  Token::Value op_;

  bool can_deopt_;

};

class LSubI V8_FINAL : public LTemplateInstruction<1, 2, 0> {

 public:

  LSubI(LOperand* left, LOperand* right) {

    inputs_[0] = left;

    inputs_[1] = right;

  }

  LOperand* left() { return inputs_[0]; }

  LOperand* right() { return inputs_[1]; }

  DECLARE_CONCRETE_INSTRUCTION(SubI, "sub-i")

  DECLARE_HYDROGEN_ACCESSOR(Sub)

};

class LConstantI V8_FINAL : public LTemplateInstruction<1, 0, 0> {

 public:

  DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")

  DECLARE_HYDROGEN_ACCESSOR(Constant)

  int32_t value() const { return hydrogen()->Integer32Value(); }

};

class LConstantS V8_FINAL : public LTemplateInstruction<1, 0, 0> {

 public:

  DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")

  DECLARE_HYDROGEN_ACCESSOR(Constant)

  Smi* value() const { return Smi::FromInt(hydrogen()->Integer32Value()); }

};

class LConstantD V8_FINAL : public LTemplateInstruction<1, 0, 0> {

 public:

  DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")

  DECLARE_HYDROGEN_ACCESSOR(Constant)

  double value() const { return hydrogen()->DoubleValue(); }

};

class LConstantE V8_FINAL : public LTemplateInstruction<1, 0, 0> {

 public:

  DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")

  DECLARE_HYDROGEN_ACCESSOR(Constant)

  ExternalReference value() const {

    return hydrogen()->ExternalReferenceValue();

  }

};

class LConstantT V8_FINAL : public LTemplateInstruction<1, 0, 0> {

 public:

  DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")

  DECLARE_HYDROGEN_ACCESSOR(Constant)

  Handle<Object> value(Isolate* isolate) const {

    return hydrogen()->handle(isolate);

  }

};

class LBranch V8_FINAL : public LControlInstruction<1, 0> {

 public:

  explicit LBranch(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")

  DECLARE_HYDROGEN_ACCESSOR(Branch)

  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;

};

class LCmpMapAndBranch V8_FINAL : public LControlInstruction<1, 1> {

 public:

  LCmpMapAndBranch(LOperand* value, LOperand* temp) {

    inputs_[0] = value;

    temps_[0] = temp;

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch")

  DECLARE_HYDROGEN_ACCESSOR(CompareMap)

  Handle<Map> map() const { return hydrogen()->map().handle(); }

};

class LMapEnumLength V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LMapEnumLength(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(MapEnumLength, "map-enum-length")

};

class LElementsKind V8_FINAL : public LTemplateInstruction<1, 1, 0> {

 public:

  explicit LElementsKind(LOperand* value) {

    inputs_[0] = value;

  }

  LOperand* value() { return inputs_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(ElementsKind, "elements-kind")

  DECLARE_HYDROGEN_ACCESSOR(ElementsKind)

};

class LValueOf V8_FINAL : public LTemplateInstruction<1, 1, 1> {

 public:

  LValueOf(LOperand* value, LOperand* temp) {

    inputs_[0] = value;

    temps_[0] = temp;

  }

  LOperand* value() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  DECLARE_CONCRETE_INSTRUCTION(ValueOf, "value-of")

  DECLARE_HYDROGEN_ACCESSOR(ValueOf)

};

class LDateField V8_FINAL : public LTemplateInstruction<1, 1, 1> {

 public:

  LDateField(LOperand* date, LOperand* temp, Smi* index) : index_(index) {

    inputs_[0] = date;

    temps_[0] = temp;

  }

  LOperand* date() { return inputs_[0]; }

  LOperand* temp() { return temps_[0]; }

  Smi* index() const { return index_; }

  DECLARE_CONCRETE_INSTRUCTION(DateField, "date-field")

  DECLARE_HYDROGEN_ACCESSOR(DateField)

 private:

  Smi* index_;

};

class LSeqStringSetChar V8_FINAL : public LTemplateInstruction<1, 3, 0> {

 public:

  LSeqStringSetChar(String::Encoding encoding,

                    LOperand* string,

                    LOperand* index,

                    LOperand* value) : encoding_(encoding) {

    inputs_[0] = string;

    inputs_[1] = index;

    inputs_[2] = value;

  }

  String::Encoding encoding() { return encoding_; }

  LOperand* string() { return inputs_[0]; }

  LOperand* index() { return inputs_[1]; }

  LOperand* value() { return inputs_[2]; }

  DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar, "seq-string-set-char")

  DECLARE_HYDROGEN_ACCESSOR(SeqStringSetChar)