Add IR printing into a supplied buffer.

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 50 matching lines @@
   M(AllocateContext, AllocateContextComp)                                      \
   M(ChainContext, ChainContextComp)                                            \
   M(CloneContext, CloneContextComp)                                            \
   M(CatchEntry, CatchEntryComp)                                                \
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
+// Forward declarations.
+class BufferFormatter;
+class Value;
+
+
 class Computation : public ZoneAllocated {
  public:
   static const int kNoCid = -1;
 
   Computation() : cid_(-1), ic_data_(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_; }
 
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor) = 0;
 
   virtual intptr_t InputCount() const = 0;
+  virtual Value* InputAt(intptr_t i) = 0;

[srdjan, 2012/05/17 22:59:22]

const (and in all overriden methods)

[Florian Schneider, 2012/05/18 00:28:38]

Done.

 
   // Mutate assigned_vars to add the local variable index for all
   // 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);
+  virtual void PrintOperandsTo(BufferFormatter* f);

[srdjan, 2012/05/17 22:59:22]

Can they both be const?

[Florian Schneider, 2012/05/18 00:28:38]

Done.

+
  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 37 matching lines @@
  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; }
+  virtual Value* InputAt(intptr_t i) { return inputs_[i]; }
 
  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 const char* DebugName() const { return #ShortName; }                 \
 
 // Functions defined in all concrete value classes.
 #define DECLARE_VALUE(ShortName)                                               \
   DECLARE_COMPUTATION(ShortName)                                               \
-  virtual ShortName##Val* As##ShortName() { return this; }
+  virtual ShortName##Val* As##ShortName() { return this; }                     \
+  virtual void PrintTo(BufferFormatter* f);                                    \
 
 
 // Definitions and uses are mutually recursive.
 class Definition;
 
 class UseVal : public Value {
  public:
   explicit UseVal(Definition* definition) : definition_(definition) { }
 
   DECLARE_VALUE(Use)
@@ skipping 50 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;
+  virtual Value* InputAt(intptr_t i) {
+    if (i == 0) return value();
+    if (i == 1) return instantiator_type_arguments();
+    return NULL;
+  }
+
+  virtual void PrintOperandsTo(BufferFormatter* f);
 
  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);
@@ skipping 71 matching lines @@
 
   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;
+  virtual Value* InputAt(intptr_t i) {
+    return i == 0 ? context() : ArgumentAt(i - 1);
+  }
+
+  virtual void PrintOperandsTo(BufferFormatter* f);
 
  private:
   const ClosureCallNode& ast_node_;
   const intptr_t try_index_;
   Value* context_;
   ZoneGrowableArray<Value*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallComp);
 };
 
@@ skipping 21 matching lines @@
 
   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) { return ArgumentAt(i); }
+
+  virtual void PrintOperandsTo(BufferFormatter* f);
 
  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 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;
   }
 
   DECLARE_COMPUTATION(StrictCompare)
 
   Token::Kind kind() const { return kind_; }
   Value* left() { return inputs_[0]; }
   Value* right() { return inputs_[1]; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const Token::Kind kind_;
 
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 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) {
     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() { return inputs_[0]; }
   Value* right() { return inputs_[1]; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareComp);
 };
 
 
 class StaticCallComp : public Computation {
  public:
@@ skipping 16 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;
+  virtual Value* InputAt(intptr_t i) { return ArgumentAt(i); }
+
+  virtual void PrintOperandsTo(BufferFormatter* f);
 
  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 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_; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   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) {
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(StoreLocal)
 
   const LocalVariable& local() const { return local_; }
   Value* value() { return inputs_[0]; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalComp);
 };
 
 
 class NativeCallComp : public TemplateComputation<0> {
  public:
@@ skipping 12 matching lines @@
   NativeFunction native_c_function() const {
     return ast_node_.native_c_function();
   }
 
   intptr_t argument_count() const { return ast_node_.argument_count(); }
 
   bool has_optional_parameters() const {
     return ast_node_.has_optional_parameters();
   }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const NativeBodyNode& ast_node_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallComp);
 };
 
 
 class LoadInstanceFieldComp : public TemplateComputation<1> {
  public:
   LoadInstanceFieldComp(LoadInstanceFieldNode* ast_node, Value* instance)
       : ast_node_(*ast_node) {
     ASSERT(instance != NULL);
     inputs_[0] = instance;
   }
 
   DECLARE_COMPUTATION(LoadInstanceField)
 
   const Field& field() const { return ast_node_.field(); }
 
   Value* instance() { return inputs_[0]; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const LoadInstanceFieldNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadInstanceFieldComp);
 };
 
 
 class StoreInstanceFieldComp : public TemplateComputation<2> {
  public:
   StoreInstanceFieldComp(StoreInstanceFieldNode* ast_node,
                          Value* instance,
                          Value* value)
       : 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() { return inputs_[0]; }
   Value* value() { return inputs_[1]; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const StoreInstanceFieldNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldComp);
 };
 
 
 class LoadStaticFieldComp : public TemplateComputation<0> {
  public:
   explicit LoadStaticFieldComp(const Field& field) : field_(field) {}
 
   DECLARE_COMPUTATION(LoadStaticField);
 
   const Field& field() const { return field_; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldComp);
 };
 
 
 class StoreStaticFieldComp : public TemplateComputation<1> {
  public:
   StoreStaticFieldComp(const 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() { return inputs_[0]; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const Field& field_;
 
   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 TemplateComputation<3> {
@@ skipping 126 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;
+  virtual Value* InputAt(intptr_t i) {
+    if (i == 0) return value();
+    if (i == 1) return type_arguments();
+    return NULL;
+  }
+
+  virtual void PrintOperandsTo(BufferFormatter* f);
 
  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);
@@ skipping 11 matching lines @@
   }
 
   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;
+  virtual Value* InputAt(intptr_t i) { return arguments()[i]; }
+
+  virtual void PrintOperandsTo(BufferFormatter* f);
 
  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;
+  virtual Value* InputAt(intptr_t i) { return arguments()[i]; }
+
+  virtual void PrintOperandsTo(BufferFormatter* f);
 
  private:
   const ConstructorCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const arguments_;
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckComp);
 };
 
 
 class CreateArrayComp : public Computation {
@@ skipping 16 matching lines @@
 
   DECLARE_COMPUTATION(CreateArray)
 
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
   intptr_t ElementCount() const { return elements_->length(); }
   Value* ElementAt(intptr_t i) const { return (*elements_)[i]; }
   Value* element_type() const { return element_type_; }
 
   virtual intptr_t InputCount() const;
+  virtual Value* InputAt(intptr_t i) { return ElementAt(i); }
+
+  virtual void PrintOperandsTo(BufferFormatter* f);
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const elements_;
   Value* element_type_;
 
   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;
+  virtual Value* InputAt(intptr_t i) {
+    return i == 0 ? type_arguments() : NULL;
+  }
+
+  virtual void PrintOperandsTo(BufferFormatter* f);
 
  private:
   const ClosureNode& ast_node_;
   const intptr_t try_index_;
   Value* type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureComp);
 };
 
 
 class NativeLoadFieldComp : public TemplateComputation<1> {
  public:
   NativeLoadFieldComp(Value* value, intptr_t offset_in_bytes)
       : offset_in_bytes_(offset_in_bytes) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(NativeLoadField)
 
   Value* value() { return inputs_[0]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const intptr_t offset_in_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeLoadFieldComp);
 };
 
 
 class NativeStoreFieldComp : public TemplateComputation<2> {
  public:
   NativeStoreFieldComp(Value* dest, intptr_t offset_in_bytes, Value* value)
       : offset_in_bytes_(offset_in_bytes) {
     ASSERT(value != NULL);
     inputs_[0] = dest;
     inputs_[1] = value;
   }
 
   DECLARE_COMPUTATION(NativeStoreField)
 
   Value* dest() { return inputs_[0]; }
   Value* value() { return inputs_[1]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const intptr_t offset_in_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeStoreFieldComp);
 };
 
 
 class InstantiateTypeArgumentsComp : public TemplateComputation<1> {
  public:
   InstantiateTypeArgumentsComp(intptr_t token_index,
                                intptr_t try_index,
                                const AbstractTypeArguments& type_arguments,
                                Value* instantiator)
       : token_index_(token_index),
         try_index_(try_index),
         type_arguments_(type_arguments) {
     ASSERT(instantiator != NULL);
     inputs_[0] = instantiator;
   }
 
   DECLARE_COMPUTATION(InstantiateTypeArguments)
 
   Value* instantiator() { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsComp);
 };
 
 
 class ExtractConstructorTypeArgumentsComp : public TemplateComputation<1> {
@@ skipping 12 matching lines @@
 
   DECLARE_COMPUTATION(ExtractConstructorTypeArguments)
 
   Value* instantiator() { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsComp);
 };
 
 
 class ExtractConstructorInstantiatorComp : public TemplateComputation<1> {
@@ skipping 29 matching lines @@
       : 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_; }
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  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 TemplateComputation<1> {
@@ skipping 41 matching lines @@
  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)
 
+  virtual void PrintOperandsTo(BufferFormatter* f);
+
  private:
   const LocalVariable& exception_var_;
   const LocalVariable& stacktrace_var_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchEntryComp);
 };
 
 
 #undef DECLARE_COMPUTATION
 
@@ skipping 17 matching lines @@
   M(Do)                                                                        \
   M(Bind)                                                                      \
   M(Return)                                                                    \
   M(Throw)                                                                     \
   M(ReThrow)                                                                   \
   M(Branch)                                                                    \
 
 
 // Forward declarations for Instruction classes.
 class BlockEntryInstr;
+class FlowGraphBuilder;
+
 #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;                                         \
+  virtual const char* DebugName() const { return #type; }                      \
+  virtual void PrintTo(BufferFormatter* f);
 
 
 class Instruction : public ZoneAllocated {
  public:
   Instruction() : cid_(-1), ic_data_(NULL) {
     Isolate* isolate = Isolate::Current();
     cid_ = Computation::GetNextCid(isolate);
     ic_data_ = Computation::GetICDataForCid(cid_, isolate);
   }
 
@@ skipping 28 matching lines @@
   // and analogously for the array 'postorder'.  The depth first spanning
   // tree is recorded in the array 'parent', which maps preorder block
   // numbers to the preorder number of the block's spanning-tree parent.
   // The array 'assigned_vars' maps preorder block numbers to the set of
   // assigned frame-allocated local variables in the block.  As a side
   // effect of this function, the set of basic block predecessors (e.g.,
   // block entry instructions of predecessor blocks) and also the last
   // instruction in the block is recorded in each entry instruction.
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
-      GrowableArray<BlockEntryInstr*>* preorder,
-      GrowableArray<BlockEntryInstr*>* postorder,
+      FlowGraphBuilder* builder,
       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count) {
     // Never called for instructions except block entries and branches.
     UNREACHABLE();
   }
 
   // Mutate assigned_vars to add the local variable index for all
   // frame-allocated locals assigned to by the instruction.
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
+  // Printing support.
+  virtual void PrintTo(BufferFormatter* f) = 0;
+
 #define INSTRUCTION_TYPE_CHECK(type)                                           \
   virtual bool Is##type() const { return false; }                              \
   virtual type##Instr* As##type() { return NULL; }
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 #undef INSTRUCTION_TYPE_CHECK
 
  private:
   intptr_t cid_;
   ICData* ic_data_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
@@ skipping 12 matching lines @@
   virtual intptr_t PredecessorCount() const = 0;
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const = 0;
   virtual void AddPredecessor(BlockEntryInstr* predecessor) = 0;
 
   intptr_t preorder_number() const { return preorder_number_; }
   void set_preorder_number(intptr_t number) { preorder_number_ = number; }
 
   intptr_t postorder_number() const { return postorder_number_; }
   void set_postorder_number(intptr_t number) { postorder_number_ = number; }
 
+  intptr_t block_id() const { return block_id_; }
+  void set_block_id(intptr_t number) { block_id_ = number; }

[srdjan, 2012/05/17 22:59:22]

intptr_t value

[Florian Schneider, 2012/05/18 00:28:38]

Done.

+
   BlockEntryInstr* dominator() const { return dominator_; }
   void set_dominator(BlockEntryInstr* instr) { dominator_ = instr; }
 
   Instruction* last_instruction() const { return last_instruction_; }
   void set_last_instruction(Instruction* instr) { last_instruction_ = instr; }
 
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
-      GrowableArray<BlockEntryInstr*>* preorder,
-      GrowableArray<BlockEntryInstr*>* postorder,
+      FlowGraphBuilder* builder,

[srdjan, 2012/05/17 22:59:22]

It seems that you can revert this change and pass preorder and postorder instead
of FlowGraphBuilder.

[Florian Schneider, 2012/05/18 00:28:38]

Done.

       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count);
 
  protected:
   BlockEntryInstr()
       : preorder_number_(-1),
         postorder_number_(-1),
+        block_id_(-1),
         dominator_(NULL),
         last_instruction_(NULL) { }
 
  private:
   intptr_t preorder_number_;
   intptr_t postorder_number_;
+  intptr_t block_id_;
   BlockEntryInstr* dominator_;  // Immediate dominator, NULL for graph entry.
   Instruction* last_instruction_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockEntryInstr);
 };
 
 
 class GraphEntryInstr : public BlockEntryInstr {
  public:
   explicit GraphEntryInstr(TargetEntryInstr* normal_entry)
       : BlockEntryInstr(), normal_entry_(normal_entry), catch_entries_() { }
 
   DECLARE_INSTRUCTION(GraphEntry)
 
   virtual intptr_t PredecessorCount() const { return 0; }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
   }
   virtual void AddPredecessor(BlockEntryInstr* predecessor) { UNREACHABLE(); }
 
   virtual Instruction* StraightLineSuccessor() const { return NULL; }
   virtual void SetSuccessor(Instruction* instr) { UNREACHABLE(); }
 
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
-      GrowableArray<BlockEntryInstr*>* preorder,
-      GrowableArray<BlockEntryInstr*>* postorder,
+      FlowGraphBuilder* builder,
       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count);
 
   void AddCatchEntry(TargetEntryInstr* entry) { catch_entries_.Add(entry); }
 
  private:
   TargetEntryInstr* normal_entry_;
   GrowableArray<TargetEntryInstr*> catch_entries_;
 
@@ skipping 273 matching lines @@
   TargetEntryInstr* false_successor() const { return false_successor_; }
 
   TargetEntryInstr** true_successor_address() { return &true_successor_; }
   TargetEntryInstr** false_successor_address() { return &false_successor_; }
 
   virtual Instruction* StraightLineSuccessor() const { return NULL; }
   virtual void SetSuccessor(Instruction* instr) { UNREACHABLE(); }
 
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
-      GrowableArray<BlockEntryInstr*>* preorder,
-      GrowableArray<BlockEntryInstr*>* postorder,
+      FlowGraphBuilder* builder,
       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count);
 
  private:
   Value* value_;
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
@@ skipping 39 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_