Add a global graph entry.

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 1107 matching lines @@
 //                 | TargetEntry <Instruction>
 //                 | Do <Computation> <Instruction>
 //                 | Return <Value>
 //                 | Branch <Value> <Instruction> <Instruction>
 // <Definition>  ::= Bind <int> <Computation> <Instruction>
 
 // M is a single argument macro.  It is applied to each concrete instruction
 // type name.  The concrete instruction classes are the name with Instr
 // concatenated.
 #define FOR_EACH_INSTRUCTION(M)                                                \
+  M(GraphEntry)                                                                \
   M(JoinEntry)                                                                 \
   M(TargetEntry)                                                               \
   M(Do)                                                                        \
   M(Bind)                                                                      \
   M(Return)                                                                    \
   M(Throw)                                                                     \
   M(ReThrow)                                                                   \
   M(Branch)                                                                    \
 
 
@@ skipping 69 matching lines @@
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 #undef INSTRUCTION_TYPE_CHECK
 
  private:
   intptr_t cid_;
   ICData* ic_data_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
-// Basic block entries are administrative nodes.  Joins are the only nodes
-// with multiple predecessors.  Targets are the other basic block entries.
-// The types enforce edge-split form---joins are forbidden as the successors
-// of branches.
+// 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
+// enforce edge-split form---joins are forbidden as the successors of
+// branches.
 class BlockEntryInstr : public Instruction {
  public:
   virtual bool IsBlockEntry() const { return true; }
 
   virtual intptr_t PredecessorCount() const = 0;
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const = 0;
 
   intptr_t preorder_number() const { return preorder_number_; }
   void set_preorder_number(intptr_t number) { preorder_number_ = number; }
 
@@ skipping 16 matching lines @@
  private:
   intptr_t preorder_number_;
   intptr_t postorder_number_;
   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 Instruction* StraightLineSuccessor() const { return NULL; }
+  virtual void SetSuccessor(Instruction* instr) { UNREACHABLE(); }
+
+  virtual void DiscoverBlocks(
+      BlockEntryInstr* current_block,
+      GrowableArray<BlockEntryInstr*>* preorder,
+      GrowableArray<BlockEntryInstr*>* postorder,
+      GrowableArray<intptr_t>* parent);
+
+  void AddCatchEntry(TargetEntryInstr* entry) { catch_entries_.Add(entry); }
+
+ private:
+  TargetEntryInstr* normal_entry_;
+  ZoneGrowableArray<TargetEntryInstr*> catch_entries_;

[srdjan, 2012/05/16 15:20:27]

GrowableArray, since it is a value object.

+
+  DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
+};
+
+
 class JoinEntryInstr : public BlockEntryInstr {
  public:
   JoinEntryInstr()
       : BlockEntryInstr(),
         predecessors_(2),  // Two is the assumed to be the common case.
         successor_(NULL) { }
 
   DECLARE_INSTRUCTION(JoinEntry)
 
   virtual intptr_t PredecessorCount() const { return predecessors_.length(); }
@@ skipping 319 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_