Automatically assign temporary indices to definitions in the IL.

runtime/vm/intermediate_language.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 61 matching lines @@
   static const int kNoCid = -1;
 
   Computation() : cid_(GetNextCid()) { }
 
   // Unique computation/instruction id, used for deoptimization.
   intptr_t cid() const { return cid_; }
 
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor) = 0;
 
+  virtual intptr_t InputCount() const = 0;
+
  private:
   friend class Instruction;
   static intptr_t GetNextCid() {
     Isolate* isolate = Isolate::Current();
     intptr_t tmp = isolate->computation_id();
     isolate->set_computation_id(tmp + 1);
     return tmp;
   }
 
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(Computation);
 };
 
 
-class Value : public Computation {
+// An embedded container with N elements of type T.  Used (with partial
+// specialization for N=0) because embedded arrays cannot have size 0.
+template<typename T, intptr_t N>
+class EmbeddedArray {
+ public:
+  EmbeddedArray() : elements_() { }
+
+  intptr_t length() { return N; }
+  T& operator[](intptr_t i) {
+    ASSERT(i < length());
+    return elements_[i];
+  }
+
+ private:
+  T elements_[N];
+};
+
+
+template<typename T>
+class EmbeddedArray<T, 0> {
+ public:
+  int length() { return 0; }
+  T& operator[](intptr_t i) {
+    UNREACHABLE();
+    static T sentinel = 0;
+    return sentinel;
+  }
+};
+
+
+class Value;
+
+template<intptr_t N>
+class TemplateComputation : public Computation {
+ public:
+  virtual intptr_t InputCount() const { return N; }
+
+ protected:
+  EmbeddedArray<Value*, N> inputs_;
+};
+
+
+class Value : public TemplateComputation<0> {
  public:
   Value() { }
 
 #define DEFINE_TESTERS(ShortName, ClassName)                                   \
   virtual ClassName* As##ShortName() { return NULL; }                          \
   bool Is##ShortName() { return As##ShortName() != NULL; }
 
   FOR_EACH_VALUE(DEFINE_TESTERS)
 #undef DEFINE_TESTERS
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 
 // Functions defined in all concrete computation classes.
 #define DECLARE_COMPUTATION(ShortName)                                         \
-  virtual void Accept(FlowGraphVisitor* visitor);
+  virtual void Accept(FlowGraphVisitor* visitor);                              \
 
 // Functions defined in all concrete value classes.
 #define DECLARE_VALUE(ShortName)                                               \
   DECLARE_COMPUTATION(ShortName)                                               \
   virtual ShortName##Val* As##ShortName() { return this; }
 
 
 class TempVal : public Value {
  public:
   explicit TempVal(intptr_t index) : index_(index) { }
@@ skipping 69 matching lines @@
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
   Value* value() const { return value_; }
   Value* instantiator_type_arguments() const {
     return instantiator_type_arguments_;
   }
   const AbstractType& dst_type() const { return dst_type_; }
   const String& dst_name() const { return dst_name_; }
 
+  virtual intptr_t InputCount() const;
+
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   Value* value_;
   Value* instantiator_type_arguments_;
   const AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableComp);
 };
 
 
-class AssertBooleanComp : public Computation {
+class AssertBooleanComp : public TemplateComputation<1> {
  public:
   AssertBooleanComp(intptr_t token_index,
                     intptr_t try_index,
                     Value* value)
       : token_index_(token_index),
-        try_index_(try_index),
-        value_(value) {
-    ASSERT(value_ != NULL);
+        try_index_(try_index) {
+    ASSERT(value != NULL);
+    inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(AssertBoolean)
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
-  Value* value() const { return value_; }
+  Value* value() { return inputs_[0]; }
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
-  Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanComp);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
-class CurrentContextComp : public Computation {
+class CurrentContextComp : public TemplateComputation<0> {
  public:
   CurrentContextComp() { }
 
   DECLARE_COMPUTATION(CurrentContext)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextComp);
 };
 
 
-class StoreContextComp : public Computation {
+class StoreContextComp : public TemplateComputation<1> {
  public:
-  explicit StoreContextComp(Value* value) : value_(value) {
-    ASSERT(value_ != NULL);
+  explicit StoreContextComp(Value* value) {
+    ASSERT(value != NULL);
+    inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(StoreContext);
 
-  Value* value() const { return value_; }
+  Value* value() { return inputs_[0]; }
 
  private:
-  Value* value_;
-
   DISALLOW_COPY_AND_ASSIGN(StoreContextComp);
 };
 
 
 class ClosureCallComp : public Computation {
  public:
   ClosureCallComp(ClosureCallNode* node,
                   intptr_t try_index,
                   Value* context,
                   ZoneGrowableArray<Value*>* arguments)
       : ast_node_(*node),
         try_index_(try_index),
         context_(context),
         arguments_(arguments) {
     ASSERT(context->IsTemp() || context->IsUse());
   }
 
   DECLARE_COMPUTATION(ClosureCall)
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
   intptr_t try_index() const { return try_index_; }
 
   Value* context() const { return context_; }
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
 
+  virtual intptr_t InputCount() const;
+
  private:
   const ClosureCallNode& ast_node_;
   const intptr_t try_index_;
   Value* context_;
   ZoneGrowableArray<Value*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallComp);
 };
 
 
@@ skipping 19 matching lines @@
   DECLARE_COMPUTATION(InstanceCall)
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
   const String& function_name() const { return function_name_; }
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
+  virtual intptr_t InputCount() const;
+
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   const String& function_name_;
   ZoneGrowableArray<Value*>* const arguments_;
   const Array& argument_names_;
   const intptr_t checked_argument_count_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallComp);
 };
 
 
-class StrictCompareComp : public Computation {
+class StrictCompareComp : public TemplateComputation<2> {
  public:
   StrictCompareComp(Token::Kind kind, Value* left, Value* right)
-      : kind_(kind), left_(left), right_(right) {
+      : kind_(kind) {
     ASSERT((kind_ == Token::kEQ_STRICT) || (kind_ == Token::kNE_STRICT));
+    inputs_[0] = left;
+    inputs_[1] = right;
   }
 
   DECLARE_COMPUTATION(StrictCompare)
 
   Token::Kind kind() const { return kind_; }
-  Value* left() const { return left_; }
-  Value* right() const { return right_; }
+  Value* left() { return inputs_[0]; }
+  Value* right() { return inputs_[1]; }
 
  private:
   const Token::Kind kind_;
-  Value* left_;
-  Value* right_;
 
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
-class EqualityCompareComp : public Computation {
+class EqualityCompareComp : public TemplateComputation<2> {
  public:
   EqualityCompareComp(intptr_t token_index,
                       intptr_t try_index,
                       Value* left,
                       Value* right)
     : token_index_(token_index),
-      try_index_(try_index),
-      left_(left),
-      right_(right) {
-    ASSERT(left_ != NULL);
-    ASSERT(right_ != NULL);
+      try_index_(try_index) {
+    ASSERT(left != NULL);
+    ASSERT(right != NULL);
+    inputs_[0] = left;
+    inputs_[1] = right;
   }
 
   DECLARE_COMPUTATION(EqualityCompareComp)
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
-  Value* left() const { return left_; }
-  Value* right() const { return right_; }
+  Value* left() { return inputs_[0]; }
+  Value* right() { return inputs_[1]; }
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
-  Value* left_;
-  Value* right_;
 
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareComp);
 };
 
 
 class StaticCallComp : public Computation {
  public:
   StaticCallComp(intptr_t token_index,
                  intptr_t try_index,
                  const Function& function,
@@ skipping 12 matching lines @@
 
   // Accessors forwarded to the AST node.
   const Function& function() const { return function_; }
   const Array& argument_names() const { return argument_names_; }
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
 
+  virtual intptr_t InputCount() const;
+
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<Value*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallComp);
 };
 
 
-class LoadLocalComp : public Computation {
+class LoadLocalComp : public TemplateComputation<0> {
  public:
   LoadLocalComp(const LocalVariable& local, intptr_t context_level)
       : local_(local), context_level_(context_level) { }
 
   DECLARE_COMPUTATION(LoadLocal)
 
   const LocalVariable& local() const { return local_; }
   intptr_t context_level() const { return context_level_; }
 
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalComp);
 };
 
 
-class StoreLocalComp : public Computation {
+class StoreLocalComp : public TemplateComputation<1> {
  public:
   StoreLocalComp(const LocalVariable& local,
                  Value* value,
                  intptr_t context_level)
-      : local_(local), value_(value), context_level_(context_level) { }
+      : local_(local), context_level_(context_level) {
+    inputs_[0] = value;
+  }
 
   DECLARE_COMPUTATION(StoreLocal)
 
   const LocalVariable& local() const { return local_; }
-  Value* value() const { return value_; }
+  Value* value() { return inputs_[0]; }
   intptr_t context_level() const { return context_level_; }
 
  private:
   const LocalVariable& local_;
-  Value* value_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalComp);
 };
 
 
-class NativeCallComp : public Computation {
+class NativeCallComp : public TemplateComputation<0> {
  public:
   NativeCallComp(NativeBodyNode* node, intptr_t try_index)
       : ast_node_(*node), try_index_(try_index) {}
 
   DECLARE_COMPUTATION(NativeCall)
 
   intptr_t token_index() const { return ast_node_.token_index(); }
   intptr_t try_index() const { return try_index_; }
 
   const String& native_name() const {
@@ skipping 11 matching lines @@
   }
 
  private:
   const NativeBodyNode& ast_node_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallComp);
 };
 
 
-class LoadInstanceFieldComp : public Computation {
+class LoadInstanceFieldComp : public TemplateComputation<1> {
  public:
   LoadInstanceFieldComp(LoadInstanceFieldNode* ast_node, Value* instance)
-      : ast_node_(*ast_node), instance_(instance) {
-    ASSERT(instance_ != NULL);
+      : ast_node_(*ast_node) {
+    ASSERT(instance != NULL);
+    inputs_[0] = instance;
   }
 
   DECLARE_COMPUTATION(LoadInstanceField)
 
   const Field& field() const { return ast_node_.field(); }
 
-  Value* instance() const { return instance_; }
+  Value* instance() { return inputs_[0]; }
 
  private:
   const LoadInstanceFieldNode& ast_node_;
-  Value* instance_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadInstanceFieldComp);
 };
 
 
-class StoreInstanceFieldComp : public Computation {
+class StoreInstanceFieldComp : public TemplateComputation<2> {
  public:
   StoreInstanceFieldComp(StoreInstanceFieldNode* ast_node,
                          Value* instance,
                          Value* value)
-      : ast_node_(*ast_node), instance_(instance), value_(value) {
-    ASSERT(instance_ != NULL);
-    ASSERT(value_ != NULL);
+      : ast_node_(*ast_node) {
+    ASSERT(instance != NULL);
+    ASSERT(value != NULL);
+    inputs_[0] = instance;
+    inputs_[1] = value;
   }
 
   DECLARE_COMPUTATION(StoreInstanceField)
 
   intptr_t token_index() const { return ast_node_.token_index(); }
   const Field& field() const { return ast_node_.field(); }
 
-  Value* instance() const { return instance_; }
-  Value* value() const { return value_; }
+  Value* instance() { return inputs_[0]; }
+  Value* value() { return inputs_[1]; }
 
  private:
   const StoreInstanceFieldNode& ast_node_;
-  Value* instance_;
-  Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldComp);
 };
 
 
-class LoadStaticFieldComp : public Computation {
+class LoadStaticFieldComp : public TemplateComputation<0> {
  public:
   explicit LoadStaticFieldComp(const Field& field) : field_(field) {}
 
   DECLARE_COMPUTATION(LoadStaticField);
 
   const Field& field() const { return field_; }
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldComp);
 };
 
 
-class StoreStaticFieldComp : public Computation {
+class StoreStaticFieldComp : public TemplateComputation<1> {
  public:
   StoreStaticFieldComp(const Field& field, Value* value)
-      : field_(field),
-        value_(value) {
+      : field_(field) {
     ASSERT(field.IsZoneHandle());
     ASSERT(value != NULL);
+    inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(StoreStaticField);
 
   const Field& field() const { return field_; }
-  Value* value() const { return value_; }
+  Value* value() { return inputs_[0]; }
 
  private:
   const Field& field_;
-  Value* const value_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldComp);
 };
 
 
 // Not simply an InstanceCall because it has somewhat more complicated
 // semantics: the value operand is preserved before the call.
-class StoreIndexedComp : public Computation {
+class StoreIndexedComp : public TemplateComputation<3> {
  public:
   StoreIndexedComp(intptr_t token_index,
                    intptr_t try_index,
                    Value* array,
                    Value* index,
                    Value* value)
       : token_index_(token_index),
-        try_index_(try_index),
-        array_(array),
-        index_(index),
-        value_(value) { }
+        try_index_(try_index) {
+    inputs_[0] = array;
+    inputs_[1] = index;
+    inputs_[2] = value;
+  }
 
   DECLARE_COMPUTATION(StoreIndexed)
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
-  Value* array() const { return array_; }
-  Value* index() const { return index_; }
-  Value* value() const { return value_; }
+  Value* array() { return inputs_[0]; }
+  Value* index() { return inputs_[1]; }
+  Value* value() { return inputs_[2]; }
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
-  Value* array_;
-  Value* index_;
-  Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedComp);
 };
 
 
 // Not simply an InstanceCall because it has somewhat more complicated
 // semantics: the value operand is preserved before the call.
-class InstanceSetterComp : public Computation {
+class InstanceSetterComp : public TemplateComputation<2> {
  public:
   InstanceSetterComp(intptr_t token_index,
                      intptr_t try_index,
                      const String& field_name,
                      Value* receiver,
                      Value* value)
       : token_index_(token_index),
         try_index_(try_index),
-        field_name_(field_name),
-        receiver_(receiver),
-        value_(value) { }
+        field_name_(field_name) {
+    inputs_[0] = receiver;
+    inputs_[1] = value;
+  }
 
   DECLARE_COMPUTATION(InstanceSetter)
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
   const String& field_name() const { return field_name_; }
-  Value* receiver() const { return receiver_; }
-  Value* value() const { return value_; }
+  Value* receiver() { return inputs_[0]; }
+  Value* value() { return inputs_[1]; }
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   const String& field_name_;
-  Value* const receiver_;
-  Value* const value_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceSetterComp);
 };
 
 
 // Not simply a StaticCall because it has somewhat more complicated
 // semantics: the value operand is preserved before the call.
-class StaticSetterComp : public Computation {
+class StaticSetterComp : public TemplateComputation<1> {
  public:
   StaticSetterComp(intptr_t token_index,
                    intptr_t try_index,
                    const Function& setter_function,
                    Value* value)
       : token_index_(token_index),
         try_index_(try_index),
-        setter_function_(setter_function),
-        value_(value) { }
+        setter_function_(setter_function) {
+    inputs_[0] = value;
+  }
 
   DECLARE_COMPUTATION(StaticSetter)
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
   const Function& setter_function() const { return setter_function_; }
-  Value* value() const { return value_; }
+  Value* value() { return inputs_[0]; }
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   const Function& setter_function_;
-  Value* const value_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSetterComp);
 };
 
 
 // Note overrideable, built-in: value? false : true.
-class BooleanNegateComp : public Computation {
+class BooleanNegateComp : public TemplateComputation<1> {
  public:
-  explicit BooleanNegateComp(Value* value) : value_(value) {}
+  explicit BooleanNegateComp(Value* value) {
+    inputs_[0] = value;
+  }
 
   DECLARE_COMPUTATION(BooleanNegate)
 
-  Value* value() const { return value_; }
+  Value* value() { return inputs_[0]; }
 
  private:
-  Value* value_;
-
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateComp);
 };
 
 
 class InstanceOfComp : public Computation {
  public:
   InstanceOfComp(intptr_t token_index,
                  intptr_t try_index,
                  Value* value,
                  Value* type_arguments,  // Can be NULL.
@@ skipping 11 matching lines @@
 
   DECLARE_COMPUTATION(InstanceOf)
 
   Value* value() const { return value_; }
   Value* type_arguments() const { return type_arguments_; }
   bool negate_result() const { return negate_result_; }
   const AbstractType& type() const { return type_; }
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
 
+  virtual intptr_t InputCount() const;
+
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   Value* value_;
   Value* type_arguments_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfComp);
 };
 
 
 class AllocateObjectComp : public Computation {
  public:
   AllocateObjectComp(ConstructorCallNode* node,
                      intptr_t try_index,
                      ZoneGrowableArray<Value*>* arguments)
       : ast_node_(*node), try_index_(try_index), arguments_(arguments) {
     // Either no arguments or one type-argument and one instantiator.
     ASSERT(arguments->is_empty() || (arguments->length() == 2));
   }
 
   DECLARE_COMPUTATION(AllocateObject)
 
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
   intptr_t try_index() const { return try_index_; }
   const ZoneGrowableArray<Value*>& arguments() const { return *arguments_; }
 
+  virtual intptr_t InputCount() const;
+
  private:
   const ConstructorCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const arguments_;
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectComp);
 };
 
 
 class AllocateObjectWithBoundsCheckComp : public Computation {
  public:
   AllocateObjectWithBoundsCheckComp(ConstructorCallNode* node,
                                     intptr_t try_index,
                                     ZoneGrowableArray<Value*>* arguments)
       : ast_node_(*node), try_index_(try_index), arguments_(arguments) {
     // One type-argument and one instantiator.
     ASSERT(arguments->length() == 2);
   }
 
   DECLARE_COMPUTATION(AllocateObjectWithBoundsCheck)
 
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
   intptr_t try_index() const { return try_index_; }
   const ZoneGrowableArray<Value*>& arguments() const { return *arguments_; }
 
+  virtual intptr_t InputCount() const;
+
  private:
   const ConstructorCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const arguments_;
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckComp);
 };
 
 
 class CreateArrayComp : public Computation {
  public:
@@ skipping 11 matching lines @@
   DECLARE_COMPUTATION(CreateArray)
 
   intptr_t token_index() const { return ast_node_.token_index(); }
   intptr_t try_index() const { return try_index_; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   intptr_t ElementCount() const { return elements_->length(); }
   Value* ElementAt(intptr_t i) const { return (*elements_)[i]; }
 
+  virtual intptr_t InputCount() const;
+
  private:
   const ArrayNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const elements_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayComp);
 };
 
 
 class CreateClosureComp : public Computation {
  public:
   // 'type_arguments' is null if function() does not require type arguments.
   CreateClosureComp(ClosureNode* node,
                     intptr_t try_index,
                     Value* type_arguments)
       : ast_node_(*node),
         try_index_(try_index),
         type_arguments_(type_arguments) {}
 
   DECLARE_COMPUTATION(CreateClosure)
 
   intptr_t token_index() const { return ast_node_.token_index(); }
   intptr_t try_index() const { return try_index_; }
   const Function& function() const { return ast_node_.function(); }
   Value* type_arguments() const { return type_arguments_; }
 
+  virtual intptr_t InputCount() const;
+
  private:
   const ClosureNode& ast_node_;
   const intptr_t try_index_;
   Value* type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureComp);
 };
 
 
-class NativeLoadFieldComp : public Computation {
+class NativeLoadFieldComp : public TemplateComputation<1> {
  public:
   NativeLoadFieldComp(Value* value, intptr_t offset_in_bytes)
-      : value_(value), offset_in_bytes_(offset_in_bytes) {
+      : offset_in_bytes_(offset_in_bytes) {
     ASSERT(value != NULL);
+    inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(NativeLoadField)
 
-  Value* value() const { return value_; }
+  Value* value() { return inputs_[0]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
 
  private:
-  Value* value_;
   intptr_t offset_in_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeLoadFieldComp);
 };
 
 
-class ExtractFactoryTypeArgumentsComp : public Computation {
+class ExtractFactoryTypeArgumentsComp : public TemplateComputation<1> {
  public:
   ExtractFactoryTypeArgumentsComp(ConstructorCallNode* ast_node,
                                   intptr_t try_index,
                                   Value* instantiator)
       : ast_node_(*ast_node),
-        try_index_(try_index),
-        instantiator_(instantiator) {
-    ASSERT(instantiator_ != NULL);
+        try_index_(try_index) {
+    ASSERT(instantiator != NULL);
+    inputs_[0] = instantiator;
   }
 
   DECLARE_COMPUTATION(ExtractFactoryTypeArguments)
 
-  Value* instantiator() const { return instantiator_; }
+  Value* instantiator() { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   const Function& factory() const { return ast_node_.constructor(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
   intptr_t try_index() const { return try_index_; }
 
  private:
   const ConstructorCallNode& ast_node_;
   const intptr_t try_index_;
-  Value* instantiator_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractFactoryTypeArgumentsComp);
 };
 
 
-class ExtractConstructorTypeArgumentsComp : public Computation {
+class ExtractConstructorTypeArgumentsComp : public TemplateComputation<1> {
  public:
   ExtractConstructorTypeArgumentsComp(ConstructorCallNode* ast_node,
                                       Value* instantiator)
-      : ast_node_(*ast_node), instantiator_(instantiator) {
-    ASSERT(instantiator_ != NULL);
+      : ast_node_(*ast_node) {
+    ASSERT(instantiator != NULL);
+    inputs_[0] = instantiator;
   }
 
   DECLARE_COMPUTATION(ExtractConstructorTypeArguments)
 
-  Value* instantiator() const { return instantiator_; }
+  Value* instantiator() { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
 
  private:
   const ConstructorCallNode& ast_node_;
-  Value* instantiator_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsComp);
 };
 
 
-class ExtractConstructorInstantiatorComp : public Computation {
+class ExtractConstructorInstantiatorComp : public TemplateComputation<2> {
  public:
   ExtractConstructorInstantiatorComp(ConstructorCallNode* ast_node,
                                      Value* instantiator,
                                      Value* discard_value)
-      : ast_node_(*ast_node),
-        instantiator_(instantiator),
-        discard_value_(discard_value) {
-    ASSERT(instantiator_ != NULL);
+      : ast_node_(*ast_node) {
+    ASSERT(instantiator != NULL);
+    inputs_[0] = instantiator;
+    inputs_[1] = discard_value;
   }
 
   DECLARE_COMPUTATION(ExtractConstructorInstantiator)
 
-  Value* instantiator() const { return instantiator_; }
-  Value* discard_value() const { return discard_value_; }
+  Value* instantiator() { return inputs_[0]; }
+  Value* discard_value() { return inputs_[1]; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
 
  private:
   const ConstructorCallNode& ast_node_;
-  Value* instantiator_;
-  Value* discard_value_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorInstantiatorComp);
 };
 
 
-class AllocateContextComp : public Computation {
+class AllocateContextComp : public TemplateComputation<0> {
  public:
   AllocateContextComp(intptr_t token_index,
                       intptr_t try_index,
                       intptr_t num_context_variables)
       : token_index_(token_index),
         try_index_(try_index),
         num_context_variables_(num_context_variables) {}
 
   DECLARE_COMPUTATION(AllocateContext);
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextComp);
 };
 
 
-class ChainContextComp : public Computation {
+class ChainContextComp : public TemplateComputation<1> {
  public:
-  explicit ChainContextComp(Value* context_value)
-      : context_value_(context_value) {
-    ASSERT(context_value_ != NULL);
+  explicit ChainContextComp(Value* context_value) {
+    ASSERT(context_value != NULL);
+    inputs_[0] = context_value;
   }
 
   DECLARE_COMPUTATION(ChainContext)
 
-  Value* context_value() const { return context_value_; }
+  Value* context_value() { return inputs_[0]; }
 
  private:
-  Value* context_value_;
-
   DISALLOW_COPY_AND_ASSIGN(ChainContextComp);
 };
 
 
-class CloneContextComp : public Computation {
+class CloneContextComp : public TemplateComputation<1> {
  public:
   CloneContextComp(intptr_t token_index,
                    intptr_t try_index,
                    Value* context_value)
       : token_index_(token_index),
-        try_index_(try_index),
-        context_value_(context_value) {
-    ASSERT(context_value_ != NULL);
+        try_index_(try_index) {
+    ASSERT(context_value != NULL);
+    inputs_[0] = context_value;
   }
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
-  Value* context_value() const { return context_value_; }
+  Value* context_value() { return inputs_[0]; }
 
   DECLARE_COMPUTATION(CloneContext)
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
-  Value* context_value_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextComp);
 };
 
 
-class CatchEntryComp : public Computation {
+class CatchEntryComp : public TemplateComputation<0> {
  public:
   CatchEntryComp(const LocalVariable& exception_var,
                  const LocalVariable& stacktrace_var)
       : exception_var_(exception_var), stacktrace_var_(stacktrace_var) {}
 
   const LocalVariable& exception_var() const { return exception_var_; }
   const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
 
   DECLARE_COMPUTATION(CatchEntry)
 
@@ skipping 40 matching lines @@
 #define FORWARD_DECLARATION(type) class type##Instr;
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   virtual Instruction* Accept(FlowGraphVisitor* visitor);                      \
   virtual bool Is##type() const { return true; }                               \
   virtual type##Instr* As##type() { return this; }                             \
+  virtual intptr_t InputCount() const;                                         \
 
 
 class Instruction : public ZoneAllocated {
  public:
   Instruction() : cid_(Computation::GetNextCid()) { }
 
   // Unique computation/instruction id, used for deoptimization, e.g. for
   // ReturnInstr, ThrowInstr and ReThrowInstr.
   intptr_t cid() const { return cid_; }
 
   virtual bool IsBlockEntry() const { return false; }
   BlockEntryInstr* AsBlockEntry() {
     return IsBlockEntry() ? reinterpret_cast<BlockEntryInstr*>(this) : NULL;
   }
+  virtual bool IsDefinition() const { return false; }
+  Definition* AsDefinition() {
+    return IsDefinition() ? reinterpret_cast<Definition*>(this) : NULL;
+  }
+
+  virtual intptr_t InputCount() const = 0;
 
   // Visiting support.
   virtual Instruction* Accept(FlowGraphVisitor* visitor) = 0;
 
   virtual Instruction* StraightLineSuccessor() const = 0;
   virtual void SetSuccessor(Instruction* instr) = 0;
 
   // Discover basic-block structure by performing a recursive depth first
   // traversal of the instruction graph reachable from this instruction.  As
   // a side effect, the block entry instructions in the graph are assigned
@@ skipping 179 matching lines @@
  private:
   Computation* computation_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(DoInstr);
 };
 
 
 class Definition : public Instruction {
  public:
-  explicit Definition(intptr_t temp_index) : temp_index_(temp_index) { }
+  Definition() : temp_index_(-1) { }
+
+  virtual bool IsDefinition() const { return true; }
 
   intptr_t temp_index() const { return temp_index_; }
+  void set_temp_index(intptr_t index) { temp_index_ = index; }
 
  private:
-  const intptr_t temp_index_;
+  intptr_t temp_index_;
 
   DISALLOW_COPY_AND_ASSIGN(Definition);
 };
 
 
 class BindInstr : public Definition {
  public:
-  BindInstr(intptr_t temp_index, Computation* computation)
-      : Definition(temp_index), computation_(computation), successor_(NULL) { }
+  explicit BindInstr(Computation* computation)
+      : Definition(), computation_(computation), successor_(NULL) { }
 
   DECLARE_INSTRUCTION(Bind)
 
   Computation* computation() const { return computation_; }
 
   virtual Instruction* StraightLineSuccessor() const {
     return successor_;
   }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
@@ skipping 10 matching lines @@
 
 // The non-optimizing compiler assumes that there is exactly one use of
 // every temporary so they can be deallocated at their use.  Some AST nodes,
 // e.g., expr0[expr1]++, violate this assumption (there are two uses of each
 // of the values expr0 and expr1).
 //
 // PickTemp is used to name (with 'destination') a copy of a live temporary
 // (named 'source') without counting as the use of the source.
 class PickTempInstr : public Definition {
  public:
-  PickTempInstr(intptr_t temp_index, intptr_t source)
-      : Definition(temp_index), source_(source), successor_(NULL) { }
+  explicit PickTempInstr(intptr_t source)
+      : Definition(), source_(source), successor_(NULL) { }
 
   DECLARE_INSTRUCTION(PickTemp)
 
   intptr_t source() const { return source_; }
 
   virtual Instruction* StraightLineSuccessor() const {
     return successor_;
   }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL && instr != NULL);
@@ skipping 219 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_