VM: Store edge counters in one per-function array.

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, 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 592 matching lines @@
 class Instruction : public ZoneAllocated {
  public:
 #define DECLARE_TAG(type) k##type,
   enum Tag {
     FOR_EACH_INSTRUCTION(DECLARE_TAG)
   };
 #undef DECLARE_TAG
 
   explicit Instruction(intptr_t deopt_id = Isolate::kNoDeoptId)
       : deopt_id_(deopt_id),
-        lifetime_position_(-1),
+        lifetime_position_(kNoPlaceId),
         previous_(NULL),
         next_(NULL),
         env_(NULL),
         locs_(NULL),
-        inlining_id_(-1),
-        place_id_(kNoPlaceId) { }
+        inlining_id_(-1) { }
 
   virtual ~Instruction() { }
 
   virtual Tag tag() const = 0;
 
   intptr_t deopt_id() const {
     ASSERT(CanDeoptimize() || CanBecomeDeoptimizationTarget());
     return GetDeoptId();
   }
 
@@ skipping 252 matching lines @@
   }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
 
   enum {
     kNoPlaceId = -1
   };
 
   intptr_t deopt_id_;
-  intptr_t lifetime_position_;  // Position used by register allocator.
+  union {
+    intptr_t lifetime_position_;  // Position used by register allocator.
+    intptr_t place_id_;
+  };
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   LocationSummary* locs_;
   intptr_t inlining_id_;
-  intptr_t place_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 class PureInstruction : public Instruction {
  public:
   explicit PureInstruction(intptr_t deopt_id)
       : Instruction(deopt_id) { }
 
@@ skipping 1242 matching lines @@
   const char* message_;
 
   DISALLOW_COPY_AND_ASSIGN(StopInstr);
 };
 
 
 class GotoInstr : public TemplateInstruction<0, NoThrow> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
     : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      block_(NULL),
       successor_(entry),
       edge_weight_(0.0),
       parallel_move_(NULL) {
   }
 
   DECLARE_INSTRUCTION(Goto)
 
+  BlockEntryInstr* block() const { return block_; }
+  void set_block(BlockEntryInstr* block) { block_ = block; }
+
   JoinEntryInstr* successor() const { return successor_; }
   void set_successor(JoinEntryInstr* successor) { successor_ = successor; }
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   double edge_weight() const { return edge_weight_; }
   void set_edge_weight(double weight) { edge_weight_ = weight; }
   void adjust_edge_weight(double scale_factor) { edge_weight_ *= scale_factor; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
@@ skipping 21 matching lines @@
   ParallelMoveInstr* GetParallelMove() {
     if (parallel_move_ == NULL) {
       parallel_move_ = new ParallelMoveInstr();
     }
     return parallel_move_;
   }
 
   virtual void PrintTo(BufferFormatter* f) const;
 
  private:
+  BlockEntryInstr* block_;
   JoinEntryInstr* successor_;
   double edge_weight_;
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
 // IndirectGotoInstr represents a dynamically computed jump. Only
@@ skipping 5886 matching lines @@
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {    \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_