Make it less verbose to declare instructions that use LocationSummary-based code generation.

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 @@
 
 // Forward declarations.
 class BufferFormatter;
 class Value;
 
 
 class Computation : public ZoneAllocated {
  public:
   static const int kNoCid = -1;
 
-  Computation() : cid_(-1), ic_data_(NULL) {
+  Computation() : cid_(-1), ic_data_(NULL), locs_(NULL) {
     Isolate* isolate = Isolate::Current();
     cid_ = GetNextCid(isolate);
     ic_data_ = GetICDataForCid(cid_, isolate);
   }
 
   // Unique computation/instruction id, used for deoptimization.
   intptr_t cid() const { return cid_; }
 
   const ICData* ic_data() const { return ic_data_; }
 
@@ skipping 12 matching lines @@
 
   virtual const char* DebugName() const = 0;
 
   // Printing support. These functions are sometimes overridden for custom
   // formatting. Otherwise, it prints in the format "opcode(op1, op2, op3)".
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   // Returns structure describing location constraints required
   // to emit native code for this computation.
-  virtual LocationSummary* locs() const {
+  LocationSummary* locs() {
     // TODO(vegorov): This should be pure virtual method.

[Ivan Posva, 2012/05/22 22:19:49]

This comment is out of date, as it should just be an accessor to the locs_
field.

[Florian Schneider, 2012/05/22 23:01:06]

Done.

     // However we are temporary using NULL for instructions that
     // were not converted to the location based code generation yet.
+    if (locs_ == NULL) locs_ = MakeLocationSummary();
+    return locs_;
+  }
+
+  // Create a location summary for this computation.
+  // TODO(fschneider): Temporarily returns NULL for instructions
+  // that are not yet converted to the location based code generation.
+  virtual LocationSummary* MakeLocationSummary() const {

[Ivan Posva, 2012/05/22 22:19:49]

This one here and the one below should be pure virtual.

[Florian Schneider, 2012/05/22 23:01:06]

Done.

     return NULL;
   }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     UNIMPLEMENTED();
   }
 
  private:
   friend class Instruction;
   static intptr_t GetNextCid(Isolate* isolate) {
     intptr_t tmp = isolate->computation_id();
     isolate->set_computation_id(tmp + 1);
     return tmp;
   }
   static ICData* GetICDataForCid(intptr_t cid, Isolate* isolate) {
     if (isolate->ic_data_array() == Array::null()) {
       return NULL;
     } else {
       const Array& array_handle = Array::Handle(isolate->ic_data_array());
       ICData& ic_data_handle = ICData::ZoneHandle();
       if (cid < array_handle.Length()) {
         ic_data_handle ^= array_handle.At(cid);
       }
       return &ic_data_handle;
     }
   }
 
   intptr_t cid_;
   ICData* ic_data_;
+  LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(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:
@@ skipping 76 matching lines @@
   virtual const char* DebugName() const { return #ShortName; }                 \
   virtual RawAbstractType* StaticType() const;
 
 // Functions defined in all concrete value classes.
 #define DECLARE_VALUE(ShortName)                                               \
   DECLARE_COMPUTATION(ShortName)                                               \
   virtual ShortName##Val* As##ShortName() { return this; }                     \
   virtual void PrintTo(BufferFormatter* f) const;
 
 
+// TODO(fschneider): Remove duplicate macro definitions once all instruction
+// have a LocationSummary.
+#define DECLARE_COMPUTATION_WITH_LOCATION(ShortName)                           \
+  DECLARE_COMPUTATION(ShortName)                                               \
+  virtual LocationSummary* MakeLocationSummary() const;                        \

[Ivan Posva, 2012/05/22 22:19:49]

Then these two can just move into the general macro. And the .cc files will have
to have empty implementations for all instructions. => No boilerplate in the
future as we port.

+  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
+// Functions defined in all concrete value classes.
+#define DECLARE_VALUE_WITH_LOCATION(ShortName)                                 \
+  DECLARE_COMPUTATION_WITH_LOCATION(ShortName)                                 \
+  virtual ShortName##Val* As##ShortName() { return this; }                     \
+  virtual void PrintTo(BufferFormatter* f) const;
+
+
 // Definitions and uses are mutually recursive.
 class Definition;
 
 class UseVal : public Value {
  public:
   explicit UseVal(Definition* definition) : definition_(definition) { }
 
   DECLARE_VALUE(Use)
 
   Definition* definition() const { return definition_; }
 
  private:
   Definition* const definition_;
 
   DISALLOW_COPY_AND_ASSIGN(UseVal);
 };
 
 
 class ConstantVal: public Value {
  public:
   explicit ConstantVal(const Object& value)
-      : value_(value),
-        location_summary_(MakeLocationSummary()) {
+      : value_(value) {
     ASSERT(value.IsZoneHandle());
   }
 
-  DECLARE_VALUE(Constant)
+  DECLARE_VALUE_WITH_LOCATION(Constant)
 
   const Object& value() const { return value_; }
 
-  virtual LocationSummary* locs() const {
-    return location_summary_;
-  }
-
-  // Platform specific summary factory for this instruction.
-  LocationSummary* MakeLocationSummary();
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
-
  private:
   const Object& value_;
-  LocationSummary* location_summary_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantVal);
 };
 
 #undef DECLARE_VALUE
 
 
 class AssertAssignableComp : public Computation {
  public:
   AssertAssignableComp(intptr_t token_index,
@@ skipping 71 matching lines @@
   const intptr_t try_index_;
 
   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 TemplateComputation<0> {
  public:
-  CurrentContextComp() : location_summary_(MakeLocationSummary()) { }
+  CurrentContextComp() { }
 
-  DECLARE_COMPUTATION(CurrentContext)
-
-  virtual LocationSummary* locs() const {
-    return location_summary_;
-  }
-
-  static LocationSummary* MakeLocationSummary();
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+  DECLARE_COMPUTATION_WITH_LOCATION(CurrentContext)
 
  private:
-  LocationSummary* location_summary_;
   DISALLOW_COPY_AND_ASSIGN(CurrentContextComp);
 };
 
 
 class StoreContextComp : public TemplateComputation<1> {
  public:
-  explicit StoreContextComp(Value* value)
-      : location_summary_(MakeLocationSummary()) {
+  explicit StoreContextComp(Value* value) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
-  DECLARE_COMPUTATION(StoreContext);
-
-  virtual LocationSummary* locs() const {
-    return location_summary_;
-  }
-
-  static LocationSummary* MakeLocationSummary();
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+  DECLARE_COMPUTATION_WITH_LOCATION(StoreContext);
 
   Value* value() const { return inputs_[0]; }
 
  private:
-  LocationSummary* location_summary_;
   DISALLOW_COPY_AND_ASSIGN(StoreContextComp);
 };
 
 
 class ClosureCallComp : public Computation {
  public:
   ClosureCallComp(ClosureCallNode* node,
                   intptr_t try_index,
                   ZoneGrowableArray<Value*>* arguments)
       : ast_node_(*node),
         try_index_(try_index),
-        arguments_(arguments),
-        location_summary_(MakeLocationSummary()) { }
+        arguments_(arguments) { }
 
-  DECLARE_COMPUTATION(ClosureCall)
+  DECLARE_COMPUTATION_WITH_LOCATION(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_; }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
 
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const { return ArgumentAt(i); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual LocationSummary* locs() const {
-    return location_summary_;
-  }
-
-  // Platform specific summary factory for this instruction.
-  LocationSummary* MakeLocationSummary();
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
-
  private:
   const ClosureCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* arguments_;
-  LocationSummary* location_summary_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallComp);
 };
 
 
 class InstanceCallComp : public Computation {
  public:
   InstanceCallComp(intptr_t token_index,
                    intptr_t try_index,
                    const String& function_name,
                    ZoneGrowableArray<Value*>* arguments,
                    const Array& argument_names,
                    intptr_t checked_argument_count)
       : token_index_(token_index),
         try_index_(try_index),
         function_name_(function_name),
         arguments_(arguments),
         argument_names_(argument_names),
-        checked_argument_count_(checked_argument_count),
-        location_summary_(MakeLocationSummary()) {
+        checked_argument_count_(checked_argument_count) {
     ASSERT(function_name.IsZoneHandle());
     ASSERT(!arguments->is_empty());
     ASSERT(argument_names.IsZoneHandle());
   }
 
-  DECLARE_COMPUTATION(InstanceCall)
+  DECLARE_COMPUTATION_WITH_LOCATION(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;
   virtual Value* InputAt(intptr_t i) const { return ArgumentAt(i); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual LocationSummary* locs() const {
-    return location_summary_;
-  }
-
-  // Platform specific summary factory for this instruction.
-  LocationSummary* MakeLocationSummary();
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
-
  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_;
-  LocationSummary* location_summary_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallComp);
 };
 
 
 class StrictCompareComp : public TemplateComputation<2> {
  public:
   StrictCompareComp(Token::Kind kind, Value* left, Value* right)
       : kind_(kind) {
     ASSERT((kind_ == Token::kEQ_STRICT) || (kind_ == Token::kNE_STRICT));
     inputs_[0] = left;
     inputs_[1] = right;
-    location_summary_ = MakeLocationSummary();
   }
 
-  DECLARE_COMPUTATION(StrictCompare)
+  DECLARE_COMPUTATION_WITH_LOCATION(StrictCompare)
 
   Token::Kind kind() const { return kind_; }
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual LocationSummary* locs() const {
-    return location_summary_;
-  }
-
-  // Platform specific summary factory for this instruction.
-  LocationSummary* MakeLocationSummary();
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
-
  private:
   const Token::Kind kind_;
 
-  LocationSummary* location_summary_;
-
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 class EqualityCompareComp : public TemplateComputation<2> {
  public:
   EqualityCompareComp(intptr_t token_index,
                       intptr_t try_index,
                       Value* left,
                       Value* right)
@@ skipping 26 matching lines @@
  public:
   StaticCallComp(intptr_t token_index,
                  intptr_t try_index,
                  const Function& function,
                  const Array& argument_names,
                  ZoneGrowableArray<Value*>* arguments)
       : token_index_(token_index),
         try_index_(try_index),
         function_(function),
         argument_names_(argument_names),
-        arguments_(arguments),
-        location_summary_(MakeLocationSummary()) {
+        arguments_(arguments) {
     ASSERT(function.IsZoneHandle());
     ASSERT(argument_names.IsZoneHandle());
   }
 
-  DECLARE_COMPUTATION(StaticCall)
+  DECLARE_COMPUTATION_WITH_LOCATION(StaticCall)
 
   // 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;
   virtual Value* InputAt(intptr_t i) const { return ArgumentAt(i); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual LocationSummary* locs() const {
-    return location_summary_;
-  }
-
-  // Platform specific summary factory for this instruction.
-  LocationSummary* MakeLocationSummary();
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
-
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<Value*>* arguments_;
-  LocationSummary* location_summary_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallComp);
 };
 
 
 class LoadLocalComp : public TemplateComputation<0> {
  public:
   LoadLocalComp(const LocalVariable& local, intptr_t context_level)
       : local_(local),
-        context_level_(context_level),
-        location_summary_(MakeLocationSummary()) { }
+        context_level_(context_level) { }
 
-  DECLARE_COMPUTATION(LoadLocal)
+  DECLARE_COMPUTATION_WITH_LOCATION(LoadLocal)
 
   const LocalVariable& local() const { return local_; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual LocationSummary* locs() const {
-    return location_summary_;
-  }
-
-  // Platform specific summary factory for this instruction.
-  LocationSummary* MakeLocationSummary();
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
-
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
-  LocationSummary* location_summary_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalComp);
 };
 
 
 class StoreLocalComp : public TemplateComputation<1> {
  public:
   StoreLocalComp(const LocalVariable& local,
                  Value* value,
                  intptr_t context_level)
       : local_(local),
-        context_level_(context_level),
-        location_summary_(MakeLocationSummary()) {
+        context_level_(context_level) {
     inputs_[0] = value;
   }
 
-  DECLARE_COMPUTATION(StoreLocal)
+  DECLARE_COMPUTATION_WITH_LOCATION(StoreLocal)
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual LocationSummary* locs() const {
-    return location_summary_;
-  }
-
-  // Platform specific summary factory for this instruction.
-  LocationSummary* MakeLocationSummary();
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
-
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
-  LocationSummary* location_summary_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalComp);
 };
 
 
 class NativeCallComp : public TemplateComputation<0> {
  public:
   NativeCallComp(NativeBodyNode* node, intptr_t try_index)
       : ast_node_(*node), try_index_(try_index) {}
 
@@ skipping 1236 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_