Split LInstruction into multiple variant to make our LIR more compact....

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 291 matching lines @@
   virtual bool IsControl() const { return false; }
 
   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(); }
 
-  void set_result(LOperand* operand) { result_.set(operand); }
-  LOperand* result() const { return result_.get(); }
-  bool HasResult() const { return result_.is_set(); }
+  virtual void set_result(LOperand* operand) = 0;

[Kevin Millikin (Chromium), 2011/01/10 11:41:44]

Maybe we should put these only on the Result=1 specialization as non-virtual
member functions.  We could have a static casting function that checks types in
debug builds but that has no overhead in release builds, rather than incurring a
small overhead for each access.

[fschneider, 2011/01/10 11:55:57]

Done.

+  virtual LOperand* result() const = 0;
+  virtual bool HasResult() const = 0;
 
   void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; }
   HValue* hydrogen_value() const { return hydrogen_value_; }
 
   void set_deoptimization_environment(LEnvironment* env) {
     deoptimization_environment_.set(env);
   }
   LEnvironment* deoptimization_environment() const {
     return deoptimization_environment_.get();
   }
   bool HasDeoptimizationEnvironment() const {
     return deoptimization_environment_.is_set();
   }
 
  private:
   SetOncePointer<LEnvironment> environment_;
   SetOncePointer<LPointerMap> pointer_map_;
-  SetOncePointer<LOperand> result_;
   HValue* hydrogen_value_;
   SetOncePointer<LEnvironment> deoptimization_environment_;
 };
 
 
+template <int Result = 0>

[Kevin Millikin (Chromium), 2011/01/10 11:41:44]

I think I'd rather have two separate specializations than the default parameter.

[fschneider, 2011/01/10 11:55:57]

Done.

+class LTemplateInstruction: public LInstruction {
+  virtual void set_result(LOperand* operand) { UNREACHABLE(); }
+  virtual LOperand* result() const {
+    UNREACHABLE();
+    return NULL;
+  }
+  virtual bool HasResult() const { return false; }
+};
+
+
+template<>
+class LTemplateInstruction<1>: public LInstruction {
+ public:
+  virtual void set_result(LOperand* operand) { result_.set(operand); }
+  virtual LOperand* result() const { return result_.get(); }
+  virtual bool HasResult() const { return result_.is_set(); }
+ private:
+  SetOncePointer<LOperand> result_;
+};
+
+
 class LParallelMove : public ZoneObject {
  public:
   LParallelMove() : move_operands_(4) { }
 
   void AddMove(LOperand* from, LOperand* to) {
     move_operands_.Add(LMoveOperands(from, to));
   }
 
   bool IsRedundant() const;
 
   const ZoneList<LMoveOperands>* move_operands() const {
     return &move_operands_;
   }
 
   void PrintDataTo(StringStream* stream) const;
 
  private:
   ZoneList<LMoveOperands> move_operands_;
 };
 
 
-class LGap: public LInstruction {
+class LGap: public LTemplateInstruction<0> {
  public:
   explicit LGap(HBasicBlock* block)
       : block_(block) {
     parallel_moves_[BEFORE] = NULL;
     parallel_moves_[START] = NULL;
     parallel_moves_[END] = NULL;
     parallel_moves_[AFTER] = NULL;
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Gap, "gap")
@@ skipping 20 matching lines @@
   LParallelMove* GetParallelMove(InnerPosition pos)  {
     return parallel_moves_[pos];
   }
 
  private:
   LParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];
   HBasicBlock* block_;
 };
 
 
-class LGoto: public LInstruction {
+class LGoto: public LTemplateInstruction<0> {
  public:
   LGoto(int block_id, bool include_stack_check = false)
     : block_id_(block_id), include_stack_check_(include_stack_check) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
   virtual void PrintDataTo(StringStream* stream) const;
   virtual bool IsControl() const { return true; }
 
   int block_id() const { return block_id_; }
   bool include_stack_check() const { return include_stack_check_; }
 
  private:
   int block_id_;
   bool include_stack_check_;
 };
 
 
-class LLazyBailout: public LInstruction {
+class LLazyBailout: public LTemplateInstruction<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 LDeoptimize: public LInstruction {
+class LDeoptimize: public LTemplateInstruction<0> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
 };
 
 
 class LLabel: public LGap {
  public:
   explicit LLabel(HBasicBlock* block)
       : LGap(block), replacement_(NULL) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Label, "label")
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   int block_id() const { return block()->block_id(); }
   bool is_loop_header() const { return block()->IsLoopHeader(); }
   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: public LInstruction {
+class LParameter: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
 };
 
 
-class LCallStub: public LInstruction {
+class LCallStub: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(CallStub, "call-stub")
   DECLARE_HYDROGEN_ACCESSOR(CallStub)
 
   TranscendentalCache::Type transcendental_type() {
     return hydrogen()->transcendental_type();
   }
 };
 
 
-class LUnknownOSRValue: public LInstruction {
+class LUnknownOSRValue: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
 };
 
 
-class LUnaryOperation: public LInstruction {
+template<int R>
+class LUnaryOperation: public LTemplateInstruction<R> {
  public:
   explicit LUnaryOperation(LOperand* input) : input_(input) { }
 
   DECLARE_INSTRUCTION(UnaryOperation)
 
   LOperand* input() const { return input_; }
 
   virtual void PrintDataTo(StringStream* stream) const;
 
  private:
   LOperand* input_;
 };
 
 
-class LBinaryOperation: public LInstruction {
+class LBinaryOperation: public LTemplateInstruction<1> {
  public:
   LBinaryOperation(LOperand* left, LOperand* right)
       : left_(left), right_(right) { }
 
   DECLARE_INSTRUCTION(BinaryOperation)
 
   LOperand* left() const { return left_; }
   LOperand* right() const { return right_; }
   virtual void PrintDataTo(StringStream* stream) const;
 
@@ skipping 19 matching lines @@
   LOperand* receiver() const { return right(); }
   LOperand* length() const { return length_; }
   LOperand* elements() const { return elements_; }
 
  private:
   LOperand* length_;
   LOperand* elements_;
 };
 
 
-class LAccessArgumentsAt: public LInstruction {
+class LAccessArgumentsAt: public LTemplateInstruction<1> {
  public:
   LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index)
       : arguments_(arguments), length_(length), index_(index) { }
 
   DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at")
 
   LOperand* arguments() const { return arguments_; }
   LOperand* length() const { return length_; }
   LOperand* index() const { return index_; }
 
   virtual void PrintDataTo(StringStream* stream) const;
 
  private:
   LOperand* arguments_;
   LOperand* length_;
   LOperand* index_;
 };
 
 
-class LArgumentsLength: public LUnaryOperation {
+class LArgumentsLength: public LUnaryOperation<1> {
  public:
-  explicit LArgumentsLength(LOperand* elements) : LUnaryOperation(elements) {}
+  explicit LArgumentsLength(LOperand* elements)
+      : LUnaryOperation<1>(elements) {}
 
   DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength, "arguments-length")
 };
 
 
-class LArgumentsElements: public LInstruction {
+class LArgumentsElements: public LTemplateInstruction<1> {
  public:
   LArgumentsElements() { }
 
   DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
 };
 
 
 class LModI: public LBinaryOperation {
  public:
   LModI(LOperand* left, LOperand* right) : LBinaryOperation(left, right) { }
@@ skipping 62 matching lines @@
 
   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 {
+class LUnaryMathOperation: public LUnaryOperation<1> {
  public:
   explicit LUnaryMathOperation(LOperand* value)
-      : LUnaryOperation(value) { }
+      : LUnaryOperation<1>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation, "unary-math-operation")
   DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)
 
   virtual void PrintDataTo(StringStream* stream) const;
   BuiltinFunctionId op() const { return hydrogen()->op(); }
 };
 
 
 class LCmpJSObjectEq: public LBinaryOperation {
@@ skipping 20 matching lines @@
 
   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 {
+class LIsNull: public LUnaryOperation<1> {
  public:
   LIsNull(LOperand* value, bool is_strict)
-      : LUnaryOperation(value), is_strict_(is_strict) {}
+      : LUnaryOperation<1>(value), is_strict_(is_strict) {}
 
   DECLARE_CONCRETE_INSTRUCTION(IsNull, "is-null")
 
   bool is_strict() const { return is_strict_; }
 
  private:
   bool is_strict_;
 };
 
 
@@ skipping 18 matching lines @@
 
   LOperand* temp() const { return temp_; }
 
  private:
   LOperand* temp_;
   int true_block_id_;
   int false_block_id_;
 };
 
 
-class LIsObject: public LUnaryOperation {
+class LIsObject: public LUnaryOperation<1> {
  public:
   LIsObject(LOperand* value, LOperand* temp)
-      : LUnaryOperation(value), temp_(temp) {}
+      : LUnaryOperation<1>(value), temp_(temp) {}
 
   DECLARE_CONCRETE_INSTRUCTION(IsObject, "is-object")
 
   LOperand* temp() const { return temp_; }
 
  private:
   LOperand* temp_;
 };
 
 
@@ skipping 18 matching lines @@
 
   LOperand* temp2() const { return temp2_; }
 
  private:
   LOperand* temp2_;
   int true_block_id_;
   int false_block_id_;
 };
 
 
-class LIsSmi: public LUnaryOperation {
+class LIsSmi: public LUnaryOperation<1> {
  public:
-  explicit LIsSmi(LOperand* value) : LUnaryOperation(value) {}
+  explicit LIsSmi(LOperand* value) : LUnaryOperation<1>(value) {}
 
   DECLARE_CONCRETE_INSTRUCTION(IsSmi, "is-smi")
   DECLARE_HYDROGEN_ACCESSOR(IsSmi)
 };
 
 
 class LIsSmiAndBranch: public LIsSmi {
  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) { }
 
   DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
   virtual void PrintDataTo(StringStream* stream) const;
   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 {
+class LHasInstanceType: public LUnaryOperation<1> {
  public:
   explicit LHasInstanceType(LOperand* value)
-      : LUnaryOperation(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 {
@@ skipping 17 matching lines @@
 
   LOperand* temp() { return temp_; }
 
  private:
   LOperand* temp_;
   int true_block_id_;
   int false_block_id_;
 };
 
 
-class LHasCachedArrayIndex: public LUnaryOperation {
+class LHasCachedArrayIndex: public LUnaryOperation<1> {
  public:
-  explicit LHasCachedArrayIndex(LOperand* value) : LUnaryOperation(value) {}
+  explicit LHasCachedArrayIndex(LOperand* value) : LUnaryOperation<1>(value) {}
 
   DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndex, "has-cached-array-index")
   DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndex)
 };
 
 
 class LHasCachedArrayIndexAndBranch: public LHasCachedArrayIndex {
  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) { }
 
   DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch,
                                "has-cached-array-index-and-branch")
   virtual void PrintDataTo(StringStream* stream) const;
   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 {
+class LClassOfTest: public LUnaryOperation<1> {
  public:
   LClassOfTest(LOperand* value, LOperand* temp)
-      : LUnaryOperation(value), temporary_(temp) {}
+      : LUnaryOperation<1>(value), temporary_(temp) {}
 
   DECLARE_CONCRETE_INSTRUCTION(ClassOfTest, "class-of-test")
   DECLARE_HYDROGEN_ACCESSOR(ClassOfTest)
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   LOperand* temporary() { return temporary_; }
 
  private:
   LOperand *temporary_;
@@ skipping 83 matching lines @@
 
   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 {
+class LInstanceOfKnownGlobal: public LUnaryOperation<1> {
  public:
   LInstanceOfKnownGlobal(LOperand* left, LOperand* temp)
-      : LUnaryOperation(left), temp_(temp) { }
+      : LUnaryOperation<1>(left), temp_(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_;
@@ skipping 46 matching lines @@
 class LSubI: public LBinaryOperation {
  public:
   LSubI(LOperand* left, LOperand* right)
       : LBinaryOperation(left, right) { }
 
   DECLARE_CONCRETE_INSTRUCTION(SubI, "sub-i")
   DECLARE_HYDROGEN_ACCESSOR(Sub)
 };
 
 
-class LConstant: public LInstruction {
+class LConstant: public LTemplateInstruction<1> {
   DECLARE_INSTRUCTION(Constant)
 };
 
 
 class LConstantI: public LConstant {
  public:
   explicit LConstantI(int32_t value) : value_(value) { }
   int32_t value() const { return value_; }
 
   DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
@@ skipping 20 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 {
+class LBranch: public LUnaryOperation<1> {
  public:
   LBranch(LOperand* input, int true_block_id, int false_block_id)
-      : LUnaryOperation(input),
+      : LUnaryOperation<1>(input),
         true_block_id_(true_block_id),
         false_block_id_(false_block_id) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
   DECLARE_HYDROGEN_ACCESSOR(Value)
 
   virtual void PrintDataTo(StringStream* stream) const;
   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 {
+class LCmpMapAndBranch: public LUnaryOperation<1> {
  public:
-  explicit LCmpMapAndBranch(LOperand* value) : LUnaryOperation(value) { }
+  explicit LCmpMapAndBranch(LOperand* value) : LUnaryOperation<1>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch")
   DECLARE_HYDROGEN_ACCESSOR(CompareMapAndBranch)
 
   virtual bool IsControl() const { return true; }
 
   Handle<Map> map() const { return hydrogen()->map(); }
   int true_block_id() const {
     return hydrogen()->true_destination()->block_id();
   }
   int false_block_id() const {
     return hydrogen()->false_destination()->block_id();
   }
 };
 
 
-class LJSArrayLength: public LUnaryOperation {
+class LJSArrayLength: public LUnaryOperation<1> {
  public:
-  explicit LJSArrayLength(LOperand* input) : LUnaryOperation(input) { }
+  explicit LJSArrayLength(LOperand* input) : LUnaryOperation<1>(input) { }
 
   DECLARE_CONCRETE_INSTRUCTION(JSArrayLength, "js-array-length")
   DECLARE_HYDROGEN_ACCESSOR(JSArrayLength)
 };
 
 
-class LFixedArrayLength: public LUnaryOperation {
+class LFixedArrayLength: public LUnaryOperation<1> {
  public:
-  explicit LFixedArrayLength(LOperand* input) : LUnaryOperation(input) { }
+  explicit LFixedArrayLength(LOperand* input) : LUnaryOperation<1>(input) { }
 
   DECLARE_CONCRETE_INSTRUCTION(FixedArrayLength, "fixed-array-length")
   DECLARE_HYDROGEN_ACCESSOR(FixedArrayLength)
 };
 
 
-class LValueOf: public LUnaryOperation {
+class LValueOf: public LUnaryOperation<1> {
  public:
   LValueOf(LOperand* input, LOperand* temporary)
-      : LUnaryOperation(input), temporary_(temporary) { }
+      : LUnaryOperation<1>(input), temporary_(temporary) { }
 
   LOperand* temporary() const { return temporary_; }
 
   DECLARE_CONCRETE_INSTRUCTION(ValueOf, "value-of")
   DECLARE_HYDROGEN_ACCESSOR(ValueOf)
 
  private:
   LOperand* temporary_;
 };
 
 
-class LThrow: public LUnaryOperation {
+class LThrow: public LUnaryOperation<1> {
  public:
-  explicit LThrow(LOperand* value) : LUnaryOperation(value) { }
+  explicit LThrow(LOperand* value) : LUnaryOperation<1>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Throw, "throw")
 };
 
 
-class LBitNotI: public LUnaryOperation {
+class LBitNotI: public LUnaryOperation<1> {
  public:
-  explicit LBitNotI(LOperand* use) : LUnaryOperation(use) { }
+  explicit LBitNotI(LOperand* use) : LUnaryOperation<1>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(BitNotI, "bit-not-i")
 };
 
 
 class LAddI: public LBinaryOperation {
  public:
   LAddI(LOperand* left, LOperand* right)
       : LBinaryOperation(left, right) { }
 
@@ skipping 35 matching lines @@
   virtual void CompileToNative(LCodeGen* generator);
   virtual const char* Mnemonic() const;
 
   Token::Value op() const { return op_; }
 
  private:
   Token::Value op_;
 };
 
 
-class LReturn: public LUnaryOperation {
+class LReturn: public LUnaryOperation<1> {
  public:
-  explicit LReturn(LOperand* use) : LUnaryOperation(use) { }
+  explicit LReturn(LOperand* use) : LUnaryOperation<1>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Return, "return")
 };
 
 
-class LLoadNamedField: public LUnaryOperation {
+class LLoadNamedField: public LUnaryOperation<1> {
  public:
-  explicit LLoadNamedField(LOperand* object) : LUnaryOperation(object) { }
+  explicit LLoadNamedField(LOperand* object) : LUnaryOperation<1>(object) { }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load-named-field")
   DECLARE_HYDROGEN_ACCESSOR(LoadNamedField)
 };
 
 
-class LLoadNamedGeneric: public LUnaryOperation {
+class LLoadNamedGeneric: public LUnaryOperation<1> {
  public:
-  explicit LLoadNamedGeneric(LOperand* object) : LUnaryOperation(object) { }
+  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 {
+class LLoadFunctionPrototype: public LUnaryOperation<1> {
  public:
   LLoadFunctionPrototype(LOperand* function, LOperand* temporary)
-      : LUnaryOperation(function), temporary_(temporary) { }
+      : LUnaryOperation<1>(function), temporary_(temporary) { }
 
   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 {
+class LLoadElements: public LUnaryOperation<1> {
  public:
-  explicit LLoadElements(LOperand* obj) : LUnaryOperation(obj) { }
+  explicit LLoadElements(LOperand* obj) : LUnaryOperation<1>(obj) { }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadElements, "load-elements")
 };
 
 
 class LLoadKeyedFastElement: public LBinaryOperation {
  public:
   LLoadKeyedFastElement(LOperand* elements,
                         LOperand* key,
                         LOperand* load_result)
@@ skipping 17 matching lines @@
   LLoadKeyedGeneric(LOperand* obj, LOperand* key)
       : LBinaryOperation(obj, key) { }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric, "load-keyed-generic")
 
   LOperand* object() const { return left(); }
   LOperand* key() const { return right(); }
 };
 
 
-class LLoadGlobal: public LInstruction {
+class LLoadGlobal: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(LoadGlobal, "load-global")
   DECLARE_HYDROGEN_ACCESSOR(LoadGlobal)
 };
 
 
-class LStoreGlobal: public LUnaryOperation {
+class LStoreGlobal: public LUnaryOperation<1> {
  public:
-  explicit LStoreGlobal(LOperand* value) : LUnaryOperation(value) {}
+  explicit LStoreGlobal(LOperand* value) : LUnaryOperation<1>(value) {}
 
   DECLARE_CONCRETE_INSTRUCTION(StoreGlobal, "store-global")
   DECLARE_HYDROGEN_ACCESSOR(StoreGlobal)
 };
 
 
-class LPushArgument: public LUnaryOperation {
+class LPushArgument: public LUnaryOperation<1> {
  public:
-  explicit LPushArgument(LOperand* argument) : LUnaryOperation(argument) {}
+  explicit LPushArgument(LOperand* argument) : LUnaryOperation<1>(argument) {}
 
   DECLARE_CONCRETE_INSTRUCTION(PushArgument, "push-argument")
 };
 
 
-class LGlobalObject: public LInstruction {
+class LGlobalObject: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(GlobalObject, "global-object")
 };
 
 
-class LGlobalReceiver: public LInstruction {
+class LGlobalReceiver: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(GlobalReceiver, "global-receiver")
 };
 
 
-class LCallConstantFunction: public LInstruction {
+class LCallConstantFunction: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(CallConstantFunction, "call-constant-function")
   DECLARE_HYDROGEN_ACCESSOR(CallConstantFunction)
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   Handle<JSFunction> function() const { return hydrogen()->function(); }
   int arity() const { return hydrogen()->argument_count() - 1; }
 };
 
 
-class LCallKeyed: public LInstruction {
+class LCallKeyed: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(CallKeyed, "call-keyed")
   DECLARE_HYDROGEN_ACCESSOR(CallKeyed)
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   int arity() const { return hydrogen()->argument_count() - 1; }
 };
 
 
-class LCallNamed: public LInstruction {
+class LCallNamed: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(CallNamed, "call-named")
   DECLARE_HYDROGEN_ACCESSOR(CallNamed)
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   Handle<String> name() const { return hydrogen()->name(); }
   int arity() const { return hydrogen()->argument_count() - 1; }
 };
 
 
-class LCallFunction: public LInstruction {
+class LCallFunction: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function")
   DECLARE_HYDROGEN_ACCESSOR(CallFunction)
 
   int arity() const { return hydrogen()->argument_count() - 2; }
 };
 
 
-class LCallGlobal: public LInstruction {
+class LCallGlobal: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(CallGlobal, "call-global")
   DECLARE_HYDROGEN_ACCESSOR(CallGlobal)
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   Handle<String> name() const {return hydrogen()->name(); }
   int arity() const { return hydrogen()->argument_count() - 1; }
 };
 
 
-class LCallKnownGlobal: public LInstruction {
+class LCallKnownGlobal: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(CallKnownGlobal, "call-known-global")
   DECLARE_HYDROGEN_ACCESSOR(CallKnownGlobal)
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   Handle<JSFunction> target() const { return hydrogen()->target();  }
   int arity() const { return hydrogen()->argument_count() - 1;  }
 };
 
 
-class LCallNew: public LUnaryOperation {
+class LCallNew: public LUnaryOperation<1> {
  public:
-  explicit LCallNew(LOperand* constructor) : LUnaryOperation(constructor) { }
+  explicit LCallNew(LOperand* constructor) : LUnaryOperation<1>(constructor) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
   DECLARE_HYDROGEN_ACCESSOR(CallNew)
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   int arity() const { return hydrogen()->argument_count() - 1; }
 };
 
 
-class LCallRuntime: public LInstruction {
+class LCallRuntime: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
   DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
 
   Runtime::Function* function() const { return hydrogen()->function(); }
   int arity() const { return hydrogen()->argument_count(); }
 };
 
 
-class LInteger32ToDouble: public LUnaryOperation {
+class LInteger32ToDouble: public LUnaryOperation<1> {
  public:
-  explicit LInteger32ToDouble(LOperand* use) : LUnaryOperation(use) { }
+  explicit LInteger32ToDouble(LOperand* use) : LUnaryOperation<1>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Integer32ToDouble, "int32-to-double")
 };
 
 
-class LNumberTagI: public LUnaryOperation {
+class LNumberTagI: public LUnaryOperation<1> {
  public:
-  explicit LNumberTagI(LOperand* use) : LUnaryOperation(use) { }
+  explicit LNumberTagI(LOperand* use) : LUnaryOperation<1>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(NumberTagI, "number-tag-i")
 };
 
 
-class LNumberTagD: public LUnaryOperation {
+class LNumberTagD: public LUnaryOperation<1> {
  public:
   explicit LNumberTagD(LOperand* value, LOperand* temp)
-      : LUnaryOperation(value), temp_(temp) { }
+      : LUnaryOperation<1>(value), temp_(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 {
+class LDoubleToI: public LUnaryOperation<1> {
  public:
-  explicit LDoubleToI(LOperand* value) : LUnaryOperation(value) { }
+  explicit LDoubleToI(LOperand* value) : LUnaryOperation<1>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i")
   DECLARE_HYDROGEN_ACCESSOR(Change)
 
   bool truncating() { return hydrogen()->CanTruncateToInt32(); }
 };
 
 
 // Truncating conversion from a tagged value to an int32.
-class LTaggedToI: public LUnaryOperation {
+class LTaggedToI: public LUnaryOperation<1> {
  public:
   LTaggedToI(LOperand* value, LOperand* temp)
-      : LUnaryOperation(value), temp_(temp) { }
+      : LUnaryOperation<1>(value), temp_(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 {
+class LSmiTag: public LUnaryOperation<1> {
  public:
-  explicit LSmiTag(LOperand* use) : LUnaryOperation(use) { }
+  explicit LSmiTag(LOperand* use) : LUnaryOperation<1>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(SmiTag, "smi-tag")
 };
 
 
-class LNumberUntagD: public LUnaryOperation {
+class LNumberUntagD: public LUnaryOperation<1> {
  public:
-  explicit LNumberUntagD(LOperand* value) : LUnaryOperation(value) { }
+  explicit LNumberUntagD(LOperand* value) : LUnaryOperation<1>(value) { }
 
   DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag")
 };
 
 
-class LSmiUntag: public LUnaryOperation {
+class LSmiUntag: public LUnaryOperation<1> {
  public:
   LSmiUntag(LOperand* use, bool needs_check)
-      : LUnaryOperation(use), needs_check_(needs_check) { }
+      : LUnaryOperation<1>(use), needs_check_(needs_check) { }
 
   DECLARE_CONCRETE_INSTRUCTION(SmiUntag, "smi-untag")
 
   bool needs_check() const { return needs_check_; }
 
  private:
   bool needs_check_;
 };
 
 
-class LStoreNamed: public LInstruction {
+class LStoreNamed: public LTemplateInstruction<0> {
  public:
   LStoreNamed(LOperand* obj, Handle<Object> name, LOperand* val)
       : object_(obj), name_(name), value_(val) { }
 
   DECLARE_INSTRUCTION(StoreNamed)
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   LOperand* object() const { return object_; }
   Handle<Object> name() const { return name_; }
@@ skipping 45 matching lines @@
  public:
   LStoreNamedGeneric(LOperand* obj,
                      Handle<Object> name,
                      LOperand* val)
       : LStoreNamed(obj, name, val) { }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
 };
 
 
-class LStoreKeyed: public LInstruction {
+class LStoreKeyed: public LTemplateInstruction<0> {
  public:
   LStoreKeyed(LOperand* obj, LOperand* key, LOperand* val)
       : object_(obj), key_(key), value_(val) { }
 
   DECLARE_INSTRUCTION(StoreKeyed)
 
   virtual void PrintDataTo(StringStream* stream) const;
 
   LOperand* object() const { return object_; }
   LOperand* key() const { return key_; }
@@ skipping 19 matching lines @@
 
 class LStoreKeyedGeneric: public LStoreKeyed {
  public:
   LStoreKeyedGeneric(LOperand* obj, LOperand* key, LOperand* val)
       : LStoreKeyed(obj, key, val) { }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
 };
 
 
-class LCheckFunction: public LUnaryOperation {
+class LCheckFunction: public LUnaryOperation<0> {
  public:
-  explicit LCheckFunction(LOperand* use) : LUnaryOperation(use) { }
+  explicit LCheckFunction(LOperand* use) : LUnaryOperation<0>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckFunction, "check-function")
   DECLARE_HYDROGEN_ACCESSOR(CheckFunction)
 };
 
 
-class LCheckInstanceType: public LUnaryOperation {
+class LCheckInstanceType: public LUnaryOperation<0> {
  public:
   LCheckInstanceType(LOperand* use, LOperand* temp)
-      : LUnaryOperation(use), temp_(temp) { }
+      : LUnaryOperation<0>(use), temp_(temp) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType, "check-instance-type")
   DECLARE_HYDROGEN_ACCESSOR(CheckInstanceType)
 
   LOperand* temp() const { return temp_; }
 
  private:
   LOperand* temp_;
 };
 
 
-class LCheckMap: public LUnaryOperation {
+class LCheckMap: public LUnaryOperation<0> {
  public:
-  explicit LCheckMap(LOperand* use) : LUnaryOperation(use) { }
+  explicit LCheckMap(LOperand* use) : LUnaryOperation<0>(use) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckMap, "check-map")
   DECLARE_HYDROGEN_ACCESSOR(CheckMap)
 };
 
 
-class LCheckPrototypeMaps: public LInstruction {
+class LCheckPrototypeMaps: public LTemplateInstruction<0> {
  public:
   LCheckPrototypeMaps(LOperand* temp,
                       Handle<JSObject> holder,
                       Handle<Map> receiver_map)
       : temp_(temp),
         holder_(holder),
         receiver_map_(receiver_map) { }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckPrototypeMaps, "check-prototype-maps")
 
   LOperand* temp() const { return temp_; }
   Handle<JSObject> holder() const { return holder_; }
   Handle<Map> receiver_map() const { return receiver_map_; }
 
  private:
   LOperand* temp_;
   Handle<JSObject> holder_;
   Handle<Map> receiver_map_;
 };
 
 
-class LCheckSmi: public LUnaryOperation {
+class LCheckSmi: public LUnaryOperation<0> {
  public:
   LCheckSmi(LOperand* use, Condition condition)
-      : LUnaryOperation(use), condition_(condition) { }
+      : LUnaryOperation<0>(use), condition_(condition) { }
 
   Condition condition() const { return condition_; }
 
   virtual void CompileToNative(LCodeGen* generator);
   virtual const char* Mnemonic() const {
     return (condition_ == zero) ? "check-non-smi" : "check-smi";
   }
 
  private:
   Condition condition_;
 };
 
 
-class LMaterializedLiteral: public LInstruction {
+class LMaterializedLiteral: public LTemplateInstruction<1> {
  public:
   DECLARE_INSTRUCTION(MaterializedLiteral)
 };
 
 
 class LArrayLiteral: public LMaterializedLiteral {
  public:
   DECLARE_CONCRETE_INSTRUCTION(ArrayLiteral, "array-literal")
   DECLARE_HYDROGEN_ACCESSOR(ArrayLiteral)
 };
 
 
 class LObjectLiteral: public LMaterializedLiteral {
  public:
   DECLARE_CONCRETE_INSTRUCTION(ObjectLiteral, "object-literal")
   DECLARE_HYDROGEN_ACCESSOR(ObjectLiteral)
 };
 
 
 class LRegExpLiteral: public LMaterializedLiteral {
  public:
   DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral, "regexp-literal")
   DECLARE_HYDROGEN_ACCESSOR(RegExpLiteral)
 };
 
 
-class LFunctionLiteral: public LInstruction {
+class LFunctionLiteral: public LTemplateInstruction<1> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(FunctionLiteral, "function-literal")
   DECLARE_HYDROGEN_ACCESSOR(FunctionLiteral)
 
   Handle<SharedFunctionInfo> shared_info() { return hydrogen()->shared_info(); }
 };
 
 
-class LTypeof: public LUnaryOperation {
+class LTypeof: public LUnaryOperation<1> {
  public:
-  explicit LTypeof(LOperand* input) : LUnaryOperation(input) { }
+  explicit LTypeof(LOperand* input) : LUnaryOperation<1>(input) { }
 
   DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof")
 };
 
 
-class LTypeofIs: public LUnaryOperation {
+class LTypeofIs: public LUnaryOperation<1> {
  public:
-  explicit LTypeofIs(LOperand* input) : LUnaryOperation(input) { }
+  explicit LTypeofIs(LOperand* input) : LUnaryOperation<1>(input) { }
   virtual void PrintDataTo(StringStream* stream) const;
 
   DECLARE_CONCRETE_INSTRUCTION(TypeofIs, "typeof-is")
   DECLARE_HYDROGEN_ACCESSOR(TypeofIs)
 
   Handle<String> type_literal() { return hydrogen()->type_literal(); }
 };
 
 
 class LTypeofIsAndBranch: public LTypeofIs {
@@ skipping 23 matching lines @@
  public:
   LDeleteProperty(LOperand* obj, LOperand* key) : LBinaryOperation(obj, key) {}
 
   DECLARE_CONCRETE_INSTRUCTION(DeleteProperty, "delete-property")
 
   LOperand* object() const { return left(); }
   LOperand* key() const { return right(); }
 };
 
 
-class LOsrEntry: public LInstruction {
+class LOsrEntry: public LTemplateInstruction<0> {
  public:
   LOsrEntry();
 
   DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
 
   LOperand** SpilledRegisterArray() { return register_spills_; }
   LOperand** SpilledDoubleRegisterArray() { return double_register_spills_; }
 
   void MarkSpilledRegister(int allocation_index, LOperand* spill_operand);
   void MarkSpilledDoubleRegister(int allocation_index,
                                  LOperand* spill_operand);
 
  private:
   // Arrays of spill slot operands for registers with an assigned spill
   // slot, i.e., that must also be restored to the spill slot on OSR entry.
   // NULL if the register has no assigned spill slot.  Indexed by allocation
   // index.
   LOperand* register_spills_[Register::kNumAllocatableRegisters];
   LOperand* double_register_spills_[DoubleRegister::kNumAllocatableRegisters];
 };
 
 
-class LStackCheck: public LInstruction {
+class LStackCheck: public LTemplateInstruction<0> {
  public:
   DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check")
 };
 
 
 class LPointerMap: public ZoneObject {
  public:
   explicit LPointerMap(int position)
       : pointer_operands_(8), position_(position), lithium_position_(-1) { }
 
@@ skipping 226 matching lines @@
   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);
 
   // Methods for setting up define-use relationships.
   // Return the same instruction that they are passed.
-  LInstruction* Define(LInstruction* instr, LUnallocated* result);
-  LInstruction* Define(LInstruction* instr);
-  LInstruction* DefineAsRegister(LInstruction* instr);
-  LInstruction* DefineAsSpilled(LInstruction* instr, int index);
-  LInstruction* DefineSameAsFirst(LInstruction* instr);
-  LInstruction* DefineFixed(LInstruction* instr, Register reg);
-  LInstruction* DefineFixedDouble(LInstruction* instr, XMMRegister reg);
+  LInstruction* Define(LTemplateInstruction<1>* instr, LUnallocated* result);

[Kevin Millikin (Chromium), 2011/01/10 11:41:44]

This is nice.

+  LInstruction* Define(LTemplateInstruction<1>* instr);
+  LInstruction* DefineAsRegister(LTemplateInstruction<1>* instr);
+  LInstruction* DefineAsSpilled(LTemplateInstruction<1>* instr, int index);
+  LInstruction* DefineSameAsFirst(LTemplateInstruction<1>* instr);
+  LInstruction* DefineFixed(LTemplateInstruction<1>* instr, Register reg);
+  LInstruction* DefineFixedDouble(LTemplateInstruction<1>* instr,
+                                  XMMRegister reg);
   LInstruction* AssignEnvironment(LInstruction* instr);
   LInstruction* AssignPointerMap(LInstruction* instr);
 
   enum CanDeoptimize { CAN_DEOPTIMIZE_EAGERLY, CANNOT_DEOPTIMIZE_EAGERLY };
 
   // By default we assume that instruction sequences generated for calls
   // cannot deoptimize eagerly and we do not attach environment to this
   // instruction.
   LInstruction* MarkAsCall(
       LInstruction* instr,
@@ skipping 39 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_