Remove the remaining LOperand-members from concrete LIR instructions....

src/ia32/lithium-ia32.h

 // Copyright 2011 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
@@ skipping 131 matching lines @@
 //     LTaggedToI
 //     LThrow
 //     LTypeof
 //     LTypeofIs
 //     LTypeofIsAndBranch
 //     LUnaryMathOperation
 //     LValueOf
 //   LUnknownOSRValue
 
 #define LITHIUM_ALL_INSTRUCTION_LIST(V)         \
+  V(BinaryControlInstruction)                   \
   V(BinaryOperation)                            \
   V(Constant)                                   \
   V(Call)                                       \
   V(MaterializedLiteral)                        \
   V(StoreKeyed)                                 \
   V(StoreNamed)                                 \
+  V(UnaryControlInstruction)                    \
   V(UnaryOperation)                             \
   LITHIUM_CONCRETE_INSTRUCTION_LIST(V)
 
 
 #define LITHIUM_CONCRETE_INSTRUCTION_LIST(V)    \
   V(AccessArgumentsAt)                          \
   V(AddI)                                       \
   V(ApplyArguments)                             \
   V(ArgumentsElements)                          \
   V(ArgumentsLength)                            \
@@ skipping 125 matching lines @@
   virtual void CompileToNative(LCodeGen* generator) = 0;
   virtual const char* Mnemonic() const = 0;
   virtual void PrintTo(StringStream* stream);
   virtual void PrintDataTo(StringStream* stream) = 0;
   virtual void PrintOutputOperandTo(StringStream* stream) = 0;
 
   // Declare virtual type testers.
 #define DECLARE_DO(type) virtual bool Is##type() const { return false; }
   LITHIUM_ALL_INSTRUCTION_LIST(DECLARE_DO)
 #undef DECLARE_DO
+
   virtual bool IsControl() const { return false; }
+  virtual void SetBranchTargets(int true_block_id, int false_block_id) { }

[Kevin Millikin (Chromium), 2011/01/13 08:45:59]

Does this need to be on LInstruction?  I would expect an LControlInstruction
superclass of LUnaryControlInstruction and LBinaryControlInstruction where this
belongs (and is non-virtual).

[fschneider, 2011/01/13 13:03:25]

The problem is that I can't cast to a LControlInstruction because it is a
template class.

 
   void set_environment(LEnvironment* env) { environment_.set(env); }
   LEnvironment* environment() const { return environment_.get(); }
   bool HasEnvironment() const { return environment_.is_set(); }
 
   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(); }
 
   virtual bool HasResult() const = 0;
@@ skipping 19 matching lines @@
 };
 
 
 template<typename T, int N>
 class OperandContainer {
  public:
   OperandContainer() {
     for (int i = 0; i < N; i++) elems_[i] = NULL;
   }
   int length() const { return N; }
   T at(int i) const { return elems_[i]; }

[Kevin Millikin (Chromium), 2011/01/13 08:45:59]

This seems like a place that you could legitimately have:

T& operator[](int i) { return elems_[i]; }

and get rid of both at and set_at.

You could also assert that i is in bounds.

[fschneider, 2011/01/13 13:03:25]

Done.

   void set_at(int i, T value) { elems_[i] = value; }
+  void PrintOperandsTo(StringStream* stream);
  private:
   T elems_[N];
 };
 
 
 template<typename T>
 class OperandContainer<T, 0> {
  public:
   int length() const { return 0; }
-  T at(int i) const {
-    UNREACHABLE();
-    return NULL;
-  }
-  void set_at(int i, T value) {
-    UNREACHABLE();
-  }
+  void PrintOperandsTo(StringStream* stream) { }
 };
 
 
 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 { return R != 0; }
   void set_result(LOperand* operand) { outputs_.set_at(0, operand); }
   LOperand* result() const { return outputs_.at(0); }
 
   int InputCount() const { return inputs_.length(); }

[Kevin Millikin (Chromium), 2011/01/13 08:45:59]

"return I" seems more direct.

[fschneider, 2011/01/13 13:03:25]

Done.

   LOperand* InputAt(int i) const { return inputs_.at(i); }
   void SetInputAt(int i, LOperand* operand) { inputs_.set_at(i, operand); }
 
   int TempCount() const { return temps_.length(); }

[Kevin Millikin (Chromium), 2011/01/13 08:45:59]

"return T"?

[fschneider, 2011/01/13 13:03:25]

Done.

   LOperand* TempAt(int i) const { return temps_.at(i); }
+  void SetTempAt(int i, LOperand* operand) { temps_.set_at(i, operand); }
 
   virtual void PrintDataTo(StringStream* stream);
   virtual void PrintOutputOperandTo(StringStream* stream);
 
  private:

[Kevin Millikin (Chromium), 2011/01/13 08:45:59]

It also seems legitimate to make these protected so the subclasses can write:

inputs_[0] = input

rather than this->SetInputAt(0, input).

[fschneider, 2011/01/13 13:03:25]

Done.

   OperandContainer<LOperand*, R> outputs_;

[Kevin Millikin (Chromium), 2011/01/13 08:45:59]

Perhaps outputs_ should be results_ (or R should be O, which is worse because it
looks like 0) to keep up the symmetry.

[fschneider, 2011/01/13 13:03:25]

Done.

   OperandContainer<LOperand*, I> inputs_;
   OperandContainer<LOperand*, T> temps_;
 };
 
 
 class LGap: public LTemplateInstruction<0, 0, 0> {
  public:
   explicit LGap(HBasicBlock* block)
       : block_(block) {
     parallel_moves_[BEFORE] = NULL;
@@ skipping 111 matching lines @@
   }
 };
 
 
 class LUnknownOSRValue: public LTemplateInstruction<1, 0, 0> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
 };
 
 
-template<int R>
-class LUnaryOperation: public LTemplateInstruction<R, 1, 0> {
+template<int R, int T = 0>
+class LUnaryOperation: public LTemplateInstruction<R, 1, T> {
  public:
-  explicit LUnaryOperation<R>(LOperand* input) {
+  explicit LUnaryOperation(LOperand* input) {
     this->SetInputAt(0, input);
   }
 
   LOperand* input() const { return this->InputAt(0); }
 
   DECLARE_INSTRUCTION(UnaryOperation)
 };
 
 
-template<int R>
-class LBinaryOperation: public LTemplateInstruction<R, 2, 0> {
+template<int R, int T = 0>

[Kevin Millikin (Chromium), 2011/01/13 08:45:59]

We should strongly consider getting rid of classes LUnaryOperation and
LBinaryOperation. There doesn't seem much reason to use inheritance for the
number of inputs any more.

Here, we're not getting much functionality (aliases left() and right() for
inputs_[0] and inputs_[1], and a constructor so we can write
LBinaryOperation(left, right) instead of inputs_[0] = left; inputs_[1] = right;
in the subclasses.

I'd like to get rid of them because it's confusing to sometimes have one, two,
or three template parameters.  It might be more clear to always have <R,I> with
a default T and sometimes <R,I,T>.

[fschneider, 2011/01/13 13:03:25]

Done.

+class LBinaryOperation: public LTemplateInstruction<R, 2, T> {
  public:
   LBinaryOperation(LOperand* left, LOperand* right) {
     this->SetInputAt(0, left);

[Vitaly Repeshko, 2011/01/13 11:44:07]

We could have a convenience function SetInputs(inputs...) defined for up to
certain number of input operands, so that in all instruction subclasses we could
write:
LSubclass(LOperand* op1, ..., LOperand* opN) {
  this->SetInputs(op1, ..., opN);
}
This could also be done for temps.

[fschneider, 2011/01/13 13:03:25]

For this change I'd like to leave it more verbose - but I'm open for
improvements for the future.

I don't think I can make the number of parameters depend on a template
parameter, so these would need to be virtual? (which I want to avoid) - maybe a
macro would work?

[Vitaly Repeshko, 2011/01/13 13:06:51]

To implement this you define the function N times (for 1 to N arguments) and
rely on the nice property that unused parts of a template are not instantiated
and so their presence won't cause an error.

     this->SetInputAt(1, right);
   }
 
   DECLARE_INSTRUCTION(BinaryOperation)
 
   LOperand* left() const { return this->InputAt(0); }
   LOperand* right() const { return this->InputAt(1); }
 };
 
 
+template<int T = 0>
+class LUnaryControlInstruction: public LUnaryOperation<0, T> {
+ public:
+  explicit LUnaryControlInstruction(LOperand* input)
+      : LUnaryOperation<0, T>(input),
+        true_block_id_(-1),
+        false_block_id_(-1) { }
+
+  DECLARE_INSTRUCTION(UnaryControlInstruction)
+  virtual bool IsControl() const { return true; }
+
+  int true_block_id() const { return true_block_id_; }
+  int false_block_id() const { return false_block_id_; }
+  void SetBranchTargets(int true_block_id, int false_block_id) {
+    true_block_id_ = true_block_id;
+    false_block_id_ = false_block_id;
+  }
+
+ private:
+  int true_block_id_;
+  int false_block_id_;
+};
+
+
+template<int T = 0>
+class LBinaryControlInstruction: public LBinaryOperation<0, T> {
+ public:
+  LBinaryControlInstruction(LOperand* left, LOperand* right)
+      : LBinaryOperation<0, T>(left, right),
+        true_block_id_(-1),
+        false_block_id_(-1) { }
+
+  DECLARE_INSTRUCTION(BinaryControlInstruction)
+  virtual bool IsControl() const { return true; }
+
+  int true_block_id() const { return true_block_id_; }
+  int false_block_id() const { return false_block_id_; }
+  void SetBranchTargets(int true_block_id, int false_block_id) {
+    true_block_id_ = true_block_id;
+    false_block_id_ = false_block_id;
+  }
+
+ private:
+  int true_block_id_;
+  int false_block_id_;
+};
+
+
 class LApplyArguments: public LTemplateInstruction<1, 4, 0> {
  public:
   LApplyArguments(LOperand* function,
                   LOperand* receiver,
                   LOperand* length,
                   LOperand* elements) {
     this->SetInputAt(0, function);
     this->SetInputAt(1, receiver);
     this->SetInputAt(2, length);
     this->SetInputAt(3, elements);
@@ skipping 36 matching lines @@
 
 
 class LArgumentsElements: public LTemplateInstruction<1, 0, 0> {
  public:
   LArgumentsElements() { }
 
   DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
 };
 
 
-class LModI: public LBinaryOperation<1> {
+class LModI: public LBinaryOperation<1, 1> {
  public:
-  LModI(LOperand* left, LOperand* right) : LBinaryOperation<1>(left, right) { }
+  LModI(LOperand* left, LOperand* right, LOperand* temp)
+      : LBinaryOperation<1, 1>(left, right) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(ModI, "mod-i")
   DECLARE_HYDROGEN_ACCESSOR(Mod)
 };
 
 
-class LDivI: public LBinaryOperation<1> {
+class LDivI: public LBinaryOperation<1, 1> {
  public:
-  LDivI(LOperand* left, LOperand* right)
-      : LBinaryOperation<1>(left, right) { }
+  LDivI(LOperand* left, LOperand* right, LOperand* temp)
+      : LBinaryOperation<1, 1>(left, right) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(DivI, "div-i")
   DECLARE_HYDROGEN_ACCESSOR(Div)
 };
 
 
-class LMulI: public LBinaryOperation<1> {
+class LMulI: public LBinaryOperation<1, 1> {
  public:
   LMulI(LOperand* left, LOperand* right, LOperand* temp)
-      : LBinaryOperation<1>(left, right), temp_(temp) { }
+      : LBinaryOperation<1, 1>(left, right) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(MulI, "mul-i")
   DECLARE_HYDROGEN_ACCESSOR(Mul)
-
-  LOperand* temp() const { return temp_; }
-
- private:
-  LOperand* temp_;
 };
 
 
 class LCmpID: public LBinaryOperation<1> {
  public:
   LCmpID(LOperand* left, LOperand* right)
       : LBinaryOperation<1>(left, right) { }
 
+  DECLARE_CONCRETE_INSTRUCTION(CmpID, "cmp-id")
+  DECLARE_HYDROGEN_ACCESSOR(Compare)
+
+  Token::Value op() const { return hydrogen()->token(); }
+  bool is_double() const {
+    return hydrogen()->GetInputRepresentation().IsDouble();
+  }
+};
+
+
+class LCmpIDAndBranch: public LBinaryControlInstruction<> {
+ public:
+  LCmpIDAndBranch(LOperand* left, LOperand* right)
+      : LBinaryControlInstruction<>(left, right) { }
+
+  DECLARE_CONCRETE_INSTRUCTION(CmpIDAndBranch, "cmp-id-and-branch")
+  DECLARE_HYDROGEN_ACCESSOR(Compare)
+
   Token::Value op() const { return hydrogen()->token(); }
   bool is_double() const {
     return hydrogen()->GetInputRepresentation().IsDouble();
   }
 
-  DECLARE_CONCRETE_INSTRUCTION(CmpID, "cmp-id")
-  DECLARE_HYDROGEN_ACCESSOR(Compare)
+  virtual void PrintDataTo(StringStream* stream);
 };
 
 
-class LCmpIDAndBranch: public LCmpID {
- public:
-  LCmpIDAndBranch(LOperand* left,
-                  LOperand* right,
-                  int true_block_id,
-                  int false_block_id)
-      : LCmpID(left, right),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
-
-  DECLARE_CONCRETE_INSTRUCTION(CmpIDAndBranch, "cmp-id-and-branch")
-  virtual void PrintDataTo(StringStream* stream);
-  virtual bool IsControl() const { return true; }
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
- private:
-  int true_block_id_;
-  int false_block_id_;
-};
-
-
 class LUnaryMathOperation: public LUnaryOperation<1> {
  public:
   explicit LUnaryMathOperation(LOperand* value)
       : LUnaryOperation<1>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation, "unary-math-operation")
   DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)
 
   virtual void PrintDataTo(StringStream* stream);
   BuiltinFunctionId op() const { return hydrogen()->op(); }
 };
 
 
 class LCmpJSObjectEq: public LBinaryOperation<1> {
  public:
   LCmpJSObjectEq(LOperand* left, LOperand* right)
       : LBinaryOperation<1>(left, right) {}
 
   DECLARE_CONCRETE_INSTRUCTION(CmpJSObjectEq, "cmp-jsobject-eq")
 };
 
 
-class LCmpJSObjectEqAndBranch: public LCmpJSObjectEq {
+class LCmpJSObjectEqAndBranch: public LBinaryControlInstruction<> {
  public:
-  LCmpJSObjectEqAndBranch(LOperand* left,
-                          LOperand* right,
-                          int true_block_id,
-                          int false_block_id)
-      : LCmpJSObjectEq(left, right),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  LCmpJSObjectEqAndBranch(LOperand* left, LOperand* right)
+      : LBinaryControlInstruction<>(left, right) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CmpJSObjectEqAndBranch,
                                "cmp-jsobject-eq-and-branch")
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
- private:
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
 class LIsNull: public LUnaryOperation<1> {
  public:
   explicit LIsNull(LOperand* value) : LUnaryOperation<1>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(IsNull, "is-null")
   DECLARE_HYDROGEN_ACCESSOR(IsNull)
 
   bool is_strict() const { return hydrogen()->is_strict(); }
 };
 
 
-class LIsNullAndBranch: public LIsNull {
+class LIsNullAndBranch: public LUnaryControlInstruction<1> {
  public:
-  LIsNullAndBranch(LOperand* value,
-                   LOperand* temp,
-                   int true_block_id,
-                   int false_block_id)
-      : LIsNull(value),
-        temp_(temp),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  LIsNullAndBranch(LOperand* value, LOperand* temp)
+      : LUnaryControlInstruction<1>(value) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(IsNullAndBranch, "is-null-and-branch")
+  DECLARE_HYDROGEN_ACCESSOR(IsNull)
+
+  bool is_strict() const { return hydrogen()->is_strict(); }
+
   virtual void PrintDataTo(StringStream* stream);
-  virtual bool IsControl() const { return true; }
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
-  LOperand* temp() const { return temp_; }
-
- private:
-  LOperand* temp_;
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
-class LIsObject: public LUnaryOperation<1> {
+class LIsObject: public LUnaryOperation<1, 1> {
  public:
   LIsObject(LOperand* value, LOperand* temp)
-      : LUnaryOperation<1>(value), temp_(temp) {}
+      : LUnaryOperation<1, 1>(value) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(IsObject, "is-object")
-
-  LOperand* temp() const { return temp_; }
-
- private:
-  LOperand* temp_;
 };
 
 
-class LIsObjectAndBranch: public LIsObject {
+class LIsObjectAndBranch: public LUnaryControlInstruction<2> {
  public:
-  LIsObjectAndBranch(LOperand* value,
-                     LOperand* temp,
-                     LOperand* temp2,
-                     int true_block_id,
-                     int false_block_id)
-      : LIsObject(value, temp),
-        temp2_(temp2),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  LIsObjectAndBranch(LOperand* value, LOperand* temp, LOperand* temp2)
+      : LUnaryControlInstruction<2>(value) {
+    SetTempAt(0, temp);
+    SetTempAt(1, temp2);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
+
   virtual void PrintDataTo(StringStream* stream);
-  virtual bool IsControl() const { return true; }
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
-  LOperand* temp2() const { return temp2_; }
-
- private:
-  LOperand* temp2_;
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
 class LIsSmi: public LUnaryOperation<1> {
  public:
   explicit LIsSmi(LOperand* value) : LUnaryOperation<1>(value) {}
 
   DECLARE_CONCRETE_INSTRUCTION(IsSmi, "is-smi")
   DECLARE_HYDROGEN_ACCESSOR(IsSmi)
 };
 
 
-class LIsSmiAndBranch: public LIsSmi {
+class LIsSmiAndBranch: public LUnaryControlInstruction<> {
  public:
-  LIsSmiAndBranch(LOperand* value,
-                  int true_block_id,
-                  int false_block_id)
-      : LIsSmi(value),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  explicit LIsSmiAndBranch(LOperand* value)
+      : LUnaryControlInstruction<>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
+
   virtual void PrintDataTo(StringStream* stream);
-  virtual bool IsControl() const { return true; }
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
- private:
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
 class LHasInstanceType: public LUnaryOperation<1> {
  public:
   explicit LHasInstanceType(LOperand* value)
       : LUnaryOperation<1>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(HasInstanceType, "has-instance-type")
   DECLARE_HYDROGEN_ACCESSOR(HasInstanceType)
-
-  InstanceType TestType();  // The type to test against when generating code.
-  Condition BranchCondition();  // The branch condition for 'true'.
 };
 
 
-class LHasInstanceTypeAndBranch: public LHasInstanceType {
+class LHasInstanceTypeAndBranch: public LUnaryControlInstruction<1> {
  public:
-  LHasInstanceTypeAndBranch(LOperand* value,
-                            LOperand* temporary,
-                            int true_block_id,
-                            int false_block_id)
-      : LHasInstanceType(value),
-        temp_(temporary),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  LHasInstanceTypeAndBranch(LOperand* value, LOperand* temp)
+      : LUnaryControlInstruction<1>(value) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch,
                                "has-instance-type-and-branch")
+  DECLARE_HYDROGEN_ACCESSOR(HasInstanceType)
+
   virtual void PrintDataTo(StringStream* stream);
-  virtual bool IsControl() const { return true; }
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
-  LOperand* temp() { return temp_; }
-
- private:
-  LOperand* temp_;
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
 class LHasCachedArrayIndex: public LUnaryOperation<1> {
  public:
   explicit LHasCachedArrayIndex(LOperand* value) : LUnaryOperation<1>(value) {}
 
   DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndex, "has-cached-array-index")
   DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndex)
 };
 
 
-class LHasCachedArrayIndexAndBranch: public LHasCachedArrayIndex {
+class LHasCachedArrayIndexAndBranch: public LUnaryControlInstruction<> {
  public:
-  LHasCachedArrayIndexAndBranch(LOperand* value,
-                                int true_block_id,
-                                int false_block_id)
-      : LHasCachedArrayIndex(value),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  explicit LHasCachedArrayIndexAndBranch(LOperand* value)
+      : LUnaryControlInstruction<>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch,
                                "has-cached-array-index-and-branch")
   virtual void PrintDataTo(StringStream* stream);
-  virtual bool IsControl() const { return true; }
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
- private:
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
-class LClassOfTest: public LUnaryOperation<1> {
+class LClassOfTest: public LUnaryOperation<1, 1> {
  public:
-  LClassOfTest(LOperand* value, LOperand* temp)
-      : LUnaryOperation<1>(value), temporary_(temp) {}
+  LClassOfTest(LOperand* value, LOperand* temp) : LUnaryOperation<1, 1>(value) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(ClassOfTest, "class-of-test")
   DECLARE_HYDROGEN_ACCESSOR(ClassOfTest)
 
   virtual void PrintDataTo(StringStream* stream);
-
-  LOperand* temporary() { return temporary_; }
-
- private:
-  LOperand* temporary_;
 };
 
 
-class LClassOfTestAndBranch: public LClassOfTest {
+class LClassOfTestAndBranch: public LUnaryControlInstruction<2> {
  public:
-  LClassOfTestAndBranch(LOperand* value,
-                        LOperand* temporary,
-                        LOperand* temporary2,
-                        int true_block_id,
-                        int false_block_id)
-      : LClassOfTest(value, temporary),
-        temporary2_(temporary2),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2)
+      : LUnaryControlInstruction<2>(value) {
+    SetTempAt(0, temp);
+    SetTempAt(1, temp2);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch,
                                "class-of-test-and-branch")
+  DECLARE_HYDROGEN_ACCESSOR(ClassOfTest)
+
   virtual void PrintDataTo(StringStream* stream);
-  virtual bool IsControl() const { return true; }
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-  LOperand* temporary2() { return temporary2_; }
-
- private:
-  LOperand* temporary2_;
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
 class LCmpT: public LBinaryOperation<1> {
  public:
   LCmpT(LOperand* left, LOperand* right) : LBinaryOperation<1>(left, right) {}
 
   DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t")
   DECLARE_HYDROGEN_ACCESSOR(Compare)
 
   Token::Value op() const { return hydrogen()->token(); }
 };
 
 
-class LCmpTAndBranch: public LCmpT {
+class LCmpTAndBranch: public LBinaryControlInstruction<> {
  public:
-  LCmpTAndBranch(LOperand* left,
-                 LOperand* right,
-                 int true_block_id,
-                 int false_block_id)
-      : LCmpT(left, right),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  LCmpTAndBranch(LOperand* left, LOperand* right)
+      : LBinaryControlInstruction<>(left, right) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CmpTAndBranch, "cmp-t-and-branch")
+  DECLARE_HYDROGEN_ACCESSOR(Compare)
 
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
- private:
-  int true_block_id_;
-  int false_block_id_;
+  Token::Value op() const { return hydrogen()->token(); }
 };
 
 
 class LInstanceOf: public LBinaryOperation<1> {
  public:
   LInstanceOf(LOperand* left, LOperand* right)
       : LBinaryOperation<1>(left, right) { }
 
   DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance-of")
 };
 
 
-class LInstanceOfAndBranch: public LInstanceOf {
+class LInstanceOfAndBranch: public LBinaryControlInstruction<> {
  public:
-  LInstanceOfAndBranch(LOperand* left,
-                       LOperand* right,
-                       int true_block_id,
-                       int false_block_id)
-      : LInstanceOf(left, right),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  LInstanceOfAndBranch(LOperand* left, LOperand* right)
+      : LBinaryControlInstruction<>(left, right) { }
 
   DECLARE_CONCRETE_INSTRUCTION(InstanceOfAndBranch, "instance-of-and-branch")
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
- private:
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
-class LInstanceOfKnownGlobal: public LUnaryOperation<1> {
+class LInstanceOfKnownGlobal: public LUnaryOperation<1, 1> {
  public:
   LInstanceOfKnownGlobal(LOperand* left, LOperand* temp)
-      : LUnaryOperation<1>(left), temp_(temp) { }
+      : LUnaryOperation<1, 1>(left) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal,
                                "instance-of-known-global")
   DECLARE_HYDROGEN_ACCESSOR(InstanceOfKnownGlobal)
 
   Handle<JSFunction> function() const { return hydrogen()->function(); }
-  LOperand* temp() const { return temp_; }
-
- private:
-  LOperand* temp_;
 };
 
 
 class LBoundsCheck: public LBinaryOperation<0> {
  public:
   LBoundsCheck(LOperand* index, LOperand* length)
       : LBinaryOperation<0>(index, length) { }
 
   LOperand* index() const { return left(); }
   LOperand* length() const { return right(); }
@@ skipping 77 matching lines @@
   explicit LConstantT(Handle<Object> value) : value_(value) { }
   Handle<Object> value() const { return value_; }
 
   DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
 
  private:
   Handle<Object> value_;
 };
 
 
-class LBranch: public LUnaryOperation<0> {
+class LBranch: public LUnaryControlInstruction<> {
  public:
-  LBranch(LOperand* input, int true_block_id, int false_block_id)
-      : LUnaryOperation<0>(input),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  explicit LBranch(LOperand* input) : LUnaryControlInstruction<>(input) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
   DECLARE_HYDROGEN_ACCESSOR(Value)
 
   virtual void PrintDataTo(StringStream* stream);
-  virtual bool IsControl() const { return true; }
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
- private:
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
 class LCmpMapAndBranch: public LUnaryOperation<0> {
  public:
   explicit LCmpMapAndBranch(LOperand* value) : LUnaryOperation<0>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch")
   DECLARE_HYDROGEN_ACCESSOR(CompareMapAndBranch)
 
@@ skipping 20 matching lines @@
 
 class LFixedArrayLength: public LUnaryOperation<1> {
  public:
   explicit LFixedArrayLength(LOperand* input) : LUnaryOperation<1>(input) { }
 
   DECLARE_CONCRETE_INSTRUCTION(FixedArrayLength, "fixed-array-length")
   DECLARE_HYDROGEN_ACCESSOR(FixedArrayLength)
 };
 
 
-class LValueOf: public LUnaryOperation<1> {
+class LValueOf: public LUnaryOperation<1, 1> {
  public:
-  LValueOf(LOperand* input, LOperand* temporary)
-      : LUnaryOperation<1>(input), temporary_(temporary) { }
-
-  LOperand* temporary() const { return temporary_; }
+  LValueOf(LOperand* input, LOperand* temp)
+      : LUnaryOperation<1, 1>(input) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(ValueOf, "value-of")
   DECLARE_HYDROGEN_ACCESSOR(ValueOf)
-
- private:
-  LOperand* temporary_;
 };
 
 
 class LThrow: public LUnaryOperation<1> {
  public:
   explicit LThrow(LOperand* value) : LUnaryOperation<1>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Throw, "throw")
 };
 
@@ skipping 78 matching lines @@
   explicit LLoadNamedGeneric(LOperand* object) : LUnaryOperation<1>(object) { }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric, "load-named-generic")
   DECLARE_HYDROGEN_ACCESSOR(LoadNamedGeneric)
 
   LOperand* object() const { return input(); }
   Handle<Object> name() const { return hydrogen()->name(); }
 };
 
 
-class LLoadFunctionPrototype: public LUnaryOperation<1> {
+class LLoadFunctionPrototype: public LUnaryOperation<1, 1> {
  public:
-  LLoadFunctionPrototype(LOperand* function, LOperand* temporary)
-      : LUnaryOperation<1>(function), temporary_(temporary) { }
+  LLoadFunctionPrototype(LOperand* function, LOperand* temp)
+      : LUnaryOperation<1, 1>(function) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype, "load-function-prototype")
   DECLARE_HYDROGEN_ACCESSOR(LoadFunctionPrototype)
 
   LOperand* function() const { return input(); }
-  LOperand* temporary() const { return temporary_; }
-
- private:
-  LOperand* temporary_;
 };
 
 
 class LLoadElements: public LUnaryOperation<1> {
  public:
   explicit LLoadElements(LOperand* obj) : LUnaryOperation<1>(obj) { }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadElements, "load-elements")
 };
 
@@ skipping 64 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(CallConstantFunction, "call-constant-function")
   DECLARE_HYDROGEN_ACCESSOR(CallConstantFunction)
 
   virtual void PrintDataTo(StringStream* stream);
 
   Handle<JSFunction> function() { return hydrogen()->function(); }
   int arity() const { return hydrogen()->argument_count() - 1; }
 };
 
 
-class LCallKeyed: public LTemplateInstruction<1, 0, 0> {
+class LCallKeyed: public LTemplateInstruction<1, 0, 1> {
  public:
+  explicit LCallKeyed(LOperand* temp) {
+    SetTempAt(0, temp);
+  }
+
   DECLARE_CONCRETE_INSTRUCTION(CallKeyed, "call-keyed")
   DECLARE_HYDROGEN_ACCESSOR(CallKeyed)
 
   virtual void PrintDataTo(StringStream* stream);
 
   int arity() const { return hydrogen()->argument_count() - 1; }
 };
 
 
 class LCallNamed: public LTemplateInstruction<1, 0, 0> {
@@ skipping 73 matching lines @@
 
 
 class LNumberTagI: public LUnaryOperation<1> {
  public:
   explicit LNumberTagI(LOperand* use) : LUnaryOperation<1>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(NumberTagI, "number-tag-i")
 };
 
 
-class LNumberTagD: public LUnaryOperation<1> {
+class LNumberTagD: public LUnaryOperation<1, 1> {
  public:
   explicit LNumberTagD(LOperand* value, LOperand* temp)
-      : LUnaryOperation<1>(value), temp_(temp) { }
+      : LUnaryOperation<1, 1>(value) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(NumberTagD, "number-tag-d")
-
-  LOperand* temp() const { return temp_; }
-
- private:
-  LOperand* temp_;
 };
 
 
 // Sometimes truncating conversion from a tagged value to an int32.
-class LDoubleToI: public LUnaryOperation<1> {
+class LDoubleToI: public LUnaryOperation<1, 1> {
  public:
-  LDoubleToI(LOperand* value, LOperand* temporary)
-      : LUnaryOperation<1>(value), temporary_(temporary) { }
+  LDoubleToI(LOperand* value, LOperand* temp) : LUnaryOperation<1, 1>(value) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i")
   DECLARE_HYDROGEN_ACCESSOR(Change)
 
   bool truncating() { return hydrogen()->CanTruncateToInt32(); }
-  LOperand* temporary() const { return temporary_; }
-
- private:
-  LOperand* temporary_;
 };
 
 
 // Truncating conversion from a tagged value to an int32.
-class LTaggedToI: public LUnaryOperation<1> {
+class LTaggedToI: public LUnaryOperation<1, 1> {
  public:
   LTaggedToI(LOperand* value, LOperand* temp)
-      : LUnaryOperation<1>(value), temp_(temp) { }
+      : LUnaryOperation<1, 1>(value) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i")
   DECLARE_HYDROGEN_ACCESSOR(Change)
 
   bool truncating() { return hydrogen()->CanTruncateToInt32(); }
-  LOperand* temp() const { return temp_; }
-
- private:
-  LOperand* temp_;
 };
 
 
 class LSmiTag: public LUnaryOperation<1> {
  public:
   explicit LSmiTag(LOperand* use) : LUnaryOperation<1>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(SmiTag, "smi-tag")
 };
 
@@ skipping 13 matching lines @@
 
   DECLARE_CONCRETE_INSTRUCTION(SmiUntag, "smi-untag")
 
   bool needs_check() const { return needs_check_; }
 
  private:
   bool needs_check_;
 };
 
 
-class LStoreNamed: public LTemplateInstruction<0, 2, 0> {
+class LStoreNamed: public LTemplateInstruction<0, 2, 1> {
  public:
   LStoreNamed(LOperand* obj, LOperand* val) {
     this->SetInputAt(0, obj);
     this->SetInputAt(1, val);
   }
 
   DECLARE_INSTRUCTION(StoreNamed)
   DECLARE_HYDROGEN_ACCESSOR(StoreNamed)
 
   virtual void PrintDataTo(StringStream* stream);
 
   LOperand* object() const { return this->InputAt(0); }
   LOperand* value() const { return this->InputAt(1); }
   Handle<Object> name() const { return hydrogen()->name(); }
 };
 
 
 class LStoreNamedField: public LStoreNamed {
  public:
   LStoreNamedField(LOperand* obj, LOperand* val, LOperand* temp)
-      : LStoreNamed(obj, val), temp_(temp) { }
+      : LStoreNamed(obj, val) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
   DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
 
   bool is_in_object() { return hydrogen()->is_in_object(); }
   int offset() { return hydrogen()->offset(); }
   bool needs_write_barrier() { return hydrogen()->NeedsWriteBarrier(); }
   Handle<Map> transition() const { return hydrogen()->transition(); }
-
-  LOperand* temp() { return temp_; }
-
- private:
-  LOperand* temp_;
 };
 
 
 class LStoreNamedGeneric: public LStoreNamed {
  public:
   LStoreNamedGeneric(LOperand* obj, LOperand* val)
       : LStoreNamed(obj, val) { }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
   DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
@@ skipping 40 matching lines @@
 
 class LCheckFunction: public LUnaryOperation<0> {
  public:
   explicit LCheckFunction(LOperand* use) : LUnaryOperation<0>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckFunction, "check-function")
   DECLARE_HYDROGEN_ACCESSOR(CheckFunction)
 };
 
 
-class LCheckInstanceType: public LUnaryOperation<0> {
+class LCheckInstanceType: public LUnaryOperation<0, 1> {
  public:
   LCheckInstanceType(LOperand* use, LOperand* temp)
-      : LUnaryOperation<0>(use), temp_(temp) { }
+      : LUnaryOperation<0, 1>(use) {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType, "check-instance-type")
   DECLARE_HYDROGEN_ACCESSOR(CheckInstanceType)
-
-  LOperand* temp() const { return temp_; }
-
- private:
-  LOperand* temp_;
 };
 
 
 class LCheckMap: public LUnaryOperation<0> {
  public:
   explicit LCheckMap(LOperand* use) : LUnaryOperation<0>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckMap, "check-map")
   DECLARE_HYDROGEN_ACCESSOR(CheckMap)
 };
 
 
-class LCheckPrototypeMaps: public LTemplateInstruction<0, 0, 0> {
+class LCheckPrototypeMaps: public LTemplateInstruction<0, 0, 1> {
  public:
-  explicit LCheckPrototypeMaps(LOperand* temp) : temp_(temp) { }
+  explicit LCheckPrototypeMaps(LOperand* temp)  {
+    SetTempAt(0, temp);
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckPrototypeMaps, "check-prototype-maps")
   DECLARE_HYDROGEN_ACCESSOR(CheckPrototypeMaps)
 
   Handle<JSObject> holder() const { return hydrogen()->holder(); }
   Handle<Map> receiver_map() const { return hydrogen()->receiver_map(); }
-
-  LOperand* temp() const { return temp_; }
-
- private:
-  LOperand* temp_;
 };
 
 
 class LCheckSmi: public LUnaryOperation<0> {
  public:
   LCheckSmi(LOperand* use, Condition condition)
       : LUnaryOperation<0>(use), condition_(condition) { }
 
   Condition condition() const { return condition_; }
 
@@ skipping 47 matching lines @@
  public:
   explicit LTypeof(LOperand* input) : LUnaryOperation<1>(input) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof")
 };
 
 
 class LTypeofIs: public LUnaryOperation<1> {
  public:
   explicit LTypeofIs(LOperand* input) : LUnaryOperation<1>(input) { }
-  virtual void PrintDataTo(StringStream* stream);
 
   DECLARE_CONCRETE_INSTRUCTION(TypeofIs, "typeof-is")
   DECLARE_HYDROGEN_ACCESSOR(TypeofIs)
 
   Handle<String> type_literal() { return hydrogen()->type_literal(); }
+
+  virtual void PrintDataTo(StringStream* stream);
 };
 
 
-class LTypeofIsAndBranch: public LTypeofIs {
+class LTypeofIsAndBranch: public LUnaryControlInstruction<> {
  public:
-  LTypeofIsAndBranch(LOperand* value,
-                     int true_block_id,
-                     int false_block_id)
-      : LTypeofIs(value),
-        true_block_id_(true_block_id),
-        false_block_id_(false_block_id) { }
+  explicit LTypeofIsAndBranch(LOperand* value)
+      : LUnaryControlInstruction<>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch, "typeof-is-and-branch")
+  DECLARE_HYDROGEN_ACCESSOR(TypeofIs)
+
+  Handle<String> type_literal() { return hydrogen()->type_literal(); }
 
   virtual void PrintDataTo(StringStream* stream);
-  virtual bool IsControl() const { return true; }
-
-  int true_block_id() const { return true_block_id_; }
-  int false_block_id() const { return false_block_id_; }
-
- private:
-  int true_block_id_;
-  int false_block_id_;
 };
 
 
 class LDeleteProperty: public LBinaryOperation<1> {
  public:
   LDeleteProperty(LOperand* obj, LOperand* key)
       : LBinaryOperation<1>(obj, key) { }
 
   DECLARE_CONCRETE_INSTRUCTION(DeleteProperty, "delete-property")
 
@@ skipping 135 matching lines @@
   bool is_aborted() const { return status_ == ABORTED; }
 
   void Abort(const char* format, ...);
 
   // Methods for getting operands for Use / Define / Temp.
   LRegister* ToOperand(Register reg);
   LUnallocated* ToUnallocated(Register reg);
   LUnallocated* ToUnallocated(XMMRegister reg);
 
   // Methods for setting up define-use relationships.
-  LOperand* Use(HValue* value, LUnallocated* operand);
-  LOperand* UseFixed(HValue* value, Register fixed_register);
-  LOperand* UseFixedDouble(HValue* value, XMMRegister fixed_register);
+  MUST_USE_RESULT LOperand* Use(HValue* value, LUnallocated* operand);
+  MUST_USE_RESULT LOperand* UseFixed(HValue* value, Register fixed_register);
+  MUST_USE_RESULT LOperand* UseFixedDouble(HValue* value,
+                                           XMMRegister fixed_register);
 
   // A value that is guaranteed to be allocated to a register.
   // Operand created by UseRegister is guaranteed to be live until the end of
   // instruction. This means that register allocator will not reuse it's
   // register for any other operand inside instruction.
   // Operand created by UseRegisterAtStart is guaranteed to be live only at
   // instruction start. Register allocator is free to assign the same register
   // to some other operand used inside instruction (i.e. temporary or
   // output).
-  LOperand* UseRegister(HValue* value);
-  LOperand* UseRegisterAtStart(HValue* value);
+  MUST_USE_RESULT LOperand* UseRegister(HValue* value);
+  MUST_USE_RESULT LOperand* UseRegisterAtStart(HValue* value);
 
   // A value in a register that may be trashed.
-  LOperand* UseTempRegister(HValue* value);
-  LOperand* Use(HValue* value);
-  LOperand* UseAtStart(HValue* value);
-  LOperand* UseOrConstant(HValue* value);
-  LOperand* UseOrConstantAtStart(HValue* value);
-  LOperand* UseRegisterOrConstant(HValue* value);
-  LOperand* UseRegisterOrConstantAtStart(HValue* value);
+  MUST_USE_RESULT LOperand* UseTempRegister(HValue* value);
+  MUST_USE_RESULT LOperand* Use(HValue* value);
+  MUST_USE_RESULT LOperand* UseAtStart(HValue* value);
+  MUST_USE_RESULT LOperand* UseOrConstant(HValue* value);
+  MUST_USE_RESULT LOperand* UseOrConstantAtStart(HValue* value);
+  MUST_USE_RESULT LOperand* UseRegisterOrConstant(HValue* value);
+  MUST_USE_RESULT LOperand* UseRegisterOrConstantAtStart(HValue* value);
+
+  // Temporary operand that must be in a register.
+  MUST_USE_RESULT LUnallocated* TempRegister();
+  MUST_USE_RESULT LOperand* FixedTemp(Register reg);
+  MUST_USE_RESULT LOperand* FixedTemp(XMMRegister reg);
 
   // Methods for setting up define-use relationships.
   // Return the same instruction that they are passed.
   template<int I, int T>
       LInstruction* Define(LTemplateInstruction<1, I, T>* instr,
                            LUnallocated* result);
   template<int I, int T>
       LInstruction* Define(LTemplateInstruction<1, I, T>* instr);
   template<int I, int T>
       LInstruction* DefineAsRegister(LTemplateInstruction<1, I, T>* instr);
@@ skipping 21 matching lines @@
       HInstruction* hinstr,
       CanDeoptimize can_deoptimize = CANNOT_DEOPTIMIZE_EAGERLY);
   LInstruction* MarkAsSaveDoubles(LInstruction* instr);
 
   LInstruction* SetInstructionPendingDeoptimizationEnvironment(
       LInstruction* instr, int ast_id);
   void ClearInstructionPendingDeoptimizationEnvironment();
 
   LEnvironment* CreateEnvironment(HEnvironment* hydrogen_env);
 
-  // Temporary operand that must be in a register.
-  LUnallocated* TempRegister();
-  LOperand* FixedTemp(Register reg);
-  LOperand* FixedTemp(XMMRegister reg);
-
   void VisitInstruction(HInstruction* current);
 
   void DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block);
   LInstruction* DoBit(Token::Value op, HBitwiseBinaryOperation* instr);
   LInstruction* DoShift(Token::Value op, HBitwiseBinaryOperation* instr);
   LInstruction* DoArithmeticD(Token::Value op,
                               HArithmeticBinaryOperation* instr);
   LInstruction* DoArithmeticT(Token::Value op,
                               HArithmeticBinaryOperation* instr);
 
@@ skipping 12 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_IA32_LITHIUM_IA32_H_