Introduce locations based code generation.

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"
 #include "vm/handles_impl.h"
 #include "vm/object.h"
 
 namespace dart {
 
 class BitVector;
+class FlowGraphCompiler;
 class FlowGraphVisitor;
 class LocalVariable;
+class LocationSummary;
 
 // M is a two argument macro.  It is applied to each concrete value's
 // typename and classname.
 #define FOR_EACH_VALUE(M)                                                      \
   M(Use, UseVal)                                                               \
   M(Constant, ConstantVal)                                                     \
 
 
 // M is a two argument macro.  It is applied to each concrete instruction's
 // (including the values) typename and classname.
@@ skipping 72 matching lines @@
   // frame-allocated locals assigned to by the computation.
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
   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 {
+    // TODO(vegorov): This should be pure virtual method.
+    // However we are temporary using NULL for instructions that
+    // were not converted to the location based code generation yet.
+    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;
@@ skipping 15 matching lines @@
 
 
 // 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() const { return N; }
+
   const T& operator[](intptr_t i) const {
     ASSERT(i < length());
     return elements_[i];
   }
+
   T& operator[](intptr_t i) {
     ASSERT(i < length());
     return elements_[i];
   }
 
+  const T& At(intptr_t i) const {
+    return (*this)[i];
+  }
+
+  void SetAt(intptr_t i, const T& val) {
+    (*this)[i] = val;
+  }

[srdjan, 2012/05/21 16:05:22]

Maybe we should get rid of operators (some other CL).

+
  private:
   T elements_[N];
 };
 
 
 template<typename T>
 class EmbeddedArray<T, 0> {
  public:
   intptr_t length() const { return 0; }
   const T& operator[](intptr_t i) const {
@@ skipping 277 matching lines @@
 };
 
 
 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)
 
   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 881 matching lines @@
   virtual type##Instr* As##type() { return NULL; }
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 #undef INSTRUCTION_TYPE_CHECK
 
   // Static type of the instruction.
   virtual RawAbstractType* StaticType() const {
     UNREACHABLE();
     return AbstractType::null();
   }
 
+  // Returns structure describing location constraints required
+  // to emit native code for this instruction.
+  virtual LocationSummary* locs() const {
+    // TODO(vegorov): This should be pure virtual method.
+    // However we are temporary using NULL for instructions that
+    // were not converted to the location based code generation yet.
+    return NULL;
+  }
+
+  virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+    UNIMPLEMENTED();
+  }
+
  private:
   intptr_t cid_;
   ICData* ic_data_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 // Basic block entries are administrative nodes.  There is a distinguished
 // graph entry with no predecessor.  Joins are the only nodes with multiple
 // predecessors.  Targets are all other basic block entries.  The types
@@ skipping 177 matching lines @@
   explicit DoInstr(Computation* comp)
       : computation_(comp), successor_(NULL) { }
 
   DECLARE_INSTRUCTION(Do)
 
   Computation* computation() const { return computation_; }
 
   virtual Instruction* StraightLineSuccessor() const {
     return successor_;
   }
+
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
     successor_ = instr;
   }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
+  virtual LocationSummary* locs() const {
+    return computation()->locs();
+  }
+
+  virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+    computation()->EmitNativeCode(compiler);
+  }
+
  private:
   Computation* computation_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(DoInstr);
 };
 
 
 class Definition : public Instruction {
  public:
@@ skipping 16 matching lines @@
   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);
     successor_ = instr;
   }
 
   // Static type of the underlying computation.
   virtual RawAbstractType* StaticType() const {
     return computation()->StaticType();
   }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
+  virtual LocationSummary* locs() const {
+    return computation()->locs();
+  }
+
+  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
  private:
   Computation* computation_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(BindInstr);
 };
 
 
 class ReturnInstr : public Instruction {
  public:
@@ skipping 170 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_