Introduce Definition and Use types.

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 FlowGraphVisitor;
 class LocalVariable;
 
 // M is a two argument macro.  It is applied to each concrete value's
 // typename and classname.
 #define FOR_EACH_VALUE(M)                                                      \
   M(Temp, TempVal)                                                             \
+  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.
 #define FOR_EACH_COMPUTATION(M)                                                \
   FOR_EACH_VALUE(M)                                                            \
   M(AssertAssignable, AssertAssignableComp)                                    \
   M(AssertBoolean, AssertBooleanComp)                                          \
   M(CurrentContext, CurrentContextComp)                                        \
@@ skipping 78 matching lines @@
 
   intptr_t index() const { return index_; }
 
  private:
   const intptr_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(TempVal);
 };
 
 
+// Definitions and uses are mutually recursive.
+class Definition;
+
+class UseVal : public Value {
+ public:
+  explicit UseVal(Definition* definition) : definition_(definition) { }
+
+  DECLARE_VALUE(Use)
+
+  Definition* definition() const { return definition_; }
+
+ private:
+  Definition* const definition_;
+
+  DISALLOW_COPY_AND_ASSIGN(UseVal);
+};
+
+
 class ConstantVal: public Value {
  public:
   explicit ConstantVal(const Object& value) : value_(value) {
     ASSERT(value.IsZoneHandle());
   }
 
   DECLARE_VALUE(Constant)
 
   const Object& value() const { return value_; }
 
@@ skipping 890 matching lines @@
 };
 
 
 #undef DECLARE_COMPUTATION
 
 
 // Instructions.
 //
 // <Instruction> ::= JoinEntry <Instruction>
 //                 | TargetEntry <Instruction>
-//                 | PickTemp <int> <int> <Instruction>
-//                 | TuckTemp <int> <int> <Instruction>
 //                 | Do <Computation> <Instruction>
-//                 | Bind <int> <Computation> <Instruction>
 //                 | Return <Value>
 //                 | Branch <Value> <Instruction> <Instruction>
+// <Definition>  ::= PickTemp <int> <int> <Instruction>
+//                 | TuckTemp <int> <int> <Instruction>
+//                 | 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(JoinEntry)                                                                 \
   M(TargetEntry)                                                               \
+  M(Do)                                                                        \
+  M(Bind)                                                                      \
   M(PickTemp)                                                                  \
   M(TuckTemp)                                                                  \
-  M(Do)                                                                        \
-  M(Bind)                                                                      \
   M(Return)                                                                    \
   M(Throw)                                                                     \
   M(ReThrow)                                                                   \
   M(Branch)                                                                    \
 
 
 // Forward declarations for Instruction classes.
 class BlockEntryInstr;
 #define FORWARD_DECLARATION(type) class type##Instr;
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
@@ skipping 179 matching lines @@
 
  private:
   BlockEntryInstr* predecessor_;
   Instruction* successor_;
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetEntryInstr);
 };
 
 
-// The non-optimizing compiler assumes that there is exactly one use of
-// every temporary so they can be deallocated at their use.  Some AST nodes,
-// e.g., expr0[expr1]++, violate this assumption (there are two uses of each
-// of the values expr0 and expr1).
-//
-// PickTemp is used to name (with 'destination') a copy of a live temporary
-// (named 'source') without counting as the use of the source.
-class PickTempInstr : public Instruction {
- public:
-  PickTempInstr(intptr_t dst, intptr_t src)
-      : destination_(dst), source_(src), successor_(NULL) { }
-
-  DECLARE_INSTRUCTION(PickTemp)
-
-  intptr_t destination() const { return destination_; }
-  intptr_t source() const { return source_; }
-
-  virtual Instruction* StraightLineSuccessor() const {
-    return successor_;
-  }
-  virtual void SetSuccessor(Instruction* instr) {
-    ASSERT(successor_ == NULL && instr != NULL);
-    successor_ = instr;
-  }
-
- private:
-  const intptr_t destination_;
-  const intptr_t source_;
-  Instruction* successor_;
-
-  DISALLOW_COPY_AND_ASSIGN(PickTempInstr);
-};
-
-
-// The non-optimizing compiler assumes that temporary definitions and uses
-// obey a stack discipline, so they can be allocated and deallocated with
-// push and pop.  Some Some AST nodes, e.g., expr++, violate this assumption
-// (the value expr+1 is produced after the value of expr, and also consumed
-// after it).
-//
-// We 'preallocate' temporaries (named with 'destination') such as the one
-// for expr+1 and use TuckTemp to mutate them by overwriting them with a
-// copy of a temporary (named with 'source').
-class TuckTempInstr : public Instruction {
- public:
-  TuckTempInstr(intptr_t dst, intptr_t src)
-      : destination_(dst), source_(src), successor_(NULL) { }
-
-  DECLARE_INSTRUCTION(TuckTemp)
-
-  intptr_t destination() const { return destination_; }
-  intptr_t source() const { return source_; }
-
-  virtual Instruction* StraightLineSuccessor() const {
-    return successor_;
-  }
-  virtual void SetSuccessor(Instruction* instr) {
-    ASSERT(successor_ == NULL && instr != NULL);
-    successor_ = instr;
-  }
-
- private:
-  const intptr_t destination_;
-  const intptr_t source_;
-  Instruction* successor_;
-
-  DISALLOW_COPY_AND_ASSIGN(TuckTempInstr);
-};
-
-
 class DoInstr : public Instruction {
  public:
   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;
   }
 
  private:
   Computation* computation_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(DoInstr);
 };
 
 
-class BindInstr : public Instruction {
+class Definition : public Instruction {
+ public:
+  explicit Definition(intptr_t temp_index) : temp_index_(temp_index) { }
+
+  intptr_t temp_index() const { return temp_index_; }

[srdjan, 2012/04/24 22:02:18]

Why don't you need DECLARE_INSTRUCTION(Definition) ?

[Kevin Millikin (Google), 2012/04/25 08:50:51]

Because it's an abstract, not concrete, instruction class.  We don't want to
have to implement VisitXXX for those.  (It might be nice to get the predicates
etc. automatically, but in that case we might split into DECLARE_INSTRUCTION and
DECLARE_CONCRETE_INSTRUCTION).

+
+ private:
+  const intptr_t temp_index_;
+
+  DISALLOW_COPY_AND_ASSIGN(Definition);
+};
+
+
+class BindInstr : public Definition {
  public:
   BindInstr(intptr_t temp_index, Computation* computation)
-      : temp_index_(temp_index), computation_(computation), successor_(NULL) { }
+      : Definition(temp_index), computation_(computation), successor_(NULL) { }
 
   DECLARE_INSTRUCTION(Bind)
 
-  intptr_t temp_index() const { return temp_index_; }
   Computation* computation() const { return computation_; }
 
   virtual Instruction* StraightLineSuccessor() const {
     return successor_;
   }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
     successor_ = instr;
   }
 
  private:
-  const intptr_t temp_index_;
   Computation* computation_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(BindInstr);
 };
 
 
+// The non-optimizing compiler assumes that there is exactly one use of
+// every temporary so they can be deallocated at their use.  Some AST nodes,
+// e.g., expr0[expr1]++, violate this assumption (there are two uses of each
+// of the values expr0 and expr1).
+//
+// PickTemp is used to name (with 'destination') a copy of a live temporary
+// (named 'source') without counting as the use of the source.
+class PickTempInstr : public Definition {
+ public:
+  PickTempInstr(intptr_t temp_index, intptr_t source)
+      : Definition(temp_index), source_(source), successor_(NULL) { }
+
+  DECLARE_INSTRUCTION(PickTemp)
+
+  intptr_t source() const { return source_; }
+
+  virtual Instruction* StraightLineSuccessor() const {
+    return successor_;
+  }
+  virtual void SetSuccessor(Instruction* instr) {
+    ASSERT(successor_ == NULL && instr != NULL);
+    successor_ = instr;
+  }
+
+ private:
+  const intptr_t source_;
+  Instruction* successor_;
+
+  DISALLOW_COPY_AND_ASSIGN(PickTempInstr);
+};
+
+
+// The non-optimizing compiler assumes that temporary definitions and uses
+// obey a stack discipline, so they can be allocated and deallocated with
+// push and pop.  Some Some AST nodes, e.g., expr++, violate this assumption
+// (the value expr+1 is produced after the value of expr, and also consumed
+// after it).
+//
+// We 'preallocate' temporaries (named with 'destination') such as the one
+// for expr+1 and use TuckTemp to mutate them by overwriting them with a
+// copy of a temporary (named with 'source').
+class TuckTempInstr : public Instruction {
+ public:
+  TuckTempInstr(intptr_t destination, intptr_t source)
+      : destination_(destination), source_(source), successor_(NULL) { }
+
+  DECLARE_INSTRUCTION(TuckTemp)
+
+  intptr_t destination() const { return destination_; }
+  intptr_t source() const { return source_; }
+
+  virtual Instruction* StraightLineSuccessor() const {
+    return successor_;
+  }
+  virtual void SetSuccessor(Instruction* instr) {
+    ASSERT(successor_ == NULL && instr != NULL);
+    successor_ = instr;
+  }
+
+ private:
+  const intptr_t destination_;
+  const intptr_t source_;
+  Instruction* successor_;
+
+  DISALLOW_COPY_AND_ASSIGN(TuckTempInstr);
+};
+
+
 class ReturnInstr : public Instruction {
  public:
   ReturnInstr(intptr_t node_id, intptr_t token_index, Value* value)
       : node_id_(node_id), token_index_(token_index), value_(value) {
     ASSERT(value_ != NULL);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   Value* value() const { return value_; }
@@ skipping 172 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_