Add new files and data structures for the new register allocator.

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/locations.h"
 #include "vm/object.h"
 
 namespace dart {
 
 // TODO(srdjan): Add _ByteArrayBase, get:length.
 
 #define RECOGNIZED_LIST(V)                                                     \
   V(ObjectArray, get:length, ObjectArrayLength)                                \
   V(ImmutableArray, get:length, ImmutableArrayLength)                          \
   V(GrowableObjectArray, get:length, GrowableArrayLength)                      \
@@ skipping 17 matching lines @@
   static Kind RecognizeKind(const Function& function);
   static const char* KindToCString(Kind kind);
 };
 
 
 class BitVector;
 class FlowGraphCompiler;
 class FlowGraphVisitor;
 class Function;
 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 1639 matching lines @@
   M(GraphEntry)                                                                \
   M(JoinEntry)                                                                 \
   M(TargetEntry)                                                               \
   M(Do)                                                                        \
   M(Bind)                                                                      \
   M(Phi)                                                                       \
   M(Return)                                                                    \
   M(Throw)                                                                     \
   M(ReThrow)                                                                   \
   M(Branch)                                                                    \
+  M(ParallelMove)
 
 
 // Forward declarations for Instruction classes.
 class BlockEntryInstr;
 class FlowGraphBuilder;
 
 #define FORWARD_DECLARATION(type) class type##Instr;
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
@@ skipping 637 matching lines @@
  private:
   Value* value_;
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
   bool is_fused_with_comparison_;
   bool is_negated_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
+
+class MoveOperands : public ValueObject {
+ public:
+  MoveOperands(Location dest, Location src) : dest_(dest), src_(src) { }
+
+  Location src() const { return src_; }
+  Location dest() const { return dest_; }
+
+ private:
+  Location dest_;
+  Location src_;
+};
+
+
+class ParallelMoveInstr : public Instruction {
+ public:
+  ParallelMoveInstr() : moves_(1) { }
+
+  DECLARE_INSTRUCTION(ParallelMove)
+
+  void AddMove(Location dest, Location src) {
+    moves_.Add(MoveOperands(dest, src));
+  }
+
+  const GrowableArray<MoveOperands>& moves() { return moves_; }
+
+ private:
+  GrowableArray<MoveOperands> moves_;
+
+  DISALLOW_COPY_AND_ASSIGN(ParallelMoveInstr);
+};
+
 #undef DECLARE_INSTRUCTION
 
 
 // Visitor base class to visit each instruction and computation in a flow
 // graph as defined by a reversed list of basic blocks.
 class FlowGraphVisitor : public ValueObject {
  public:
   explicit FlowGraphVisitor(const GrowableArray<BlockEntryInstr*>& block_order)
       : block_order_(block_order) { }
   virtual ~FlowGraphVisitor() { }
@@ skipping 20 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_