Make Value not a subclass of Computation.

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 41 matching lines @@
 // 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.
 #define FOR_EACH_COMPUTATION(M)                                                \
-  FOR_EACH_VALUE(M)                                                            \
   M(AssertAssignable, AssertAssignableComp)                                    \
   M(AssertBoolean, AssertBooleanComp)                                          \
   M(CurrentContext, CurrentContextComp)                                        \
   M(StoreContext, StoreContextComp)                                            \
   M(ClosureCall, ClosureCallComp)                                              \
   M(InstanceCall, InstanceCallComp)                                            \
   M(PolymorphicInstanceCall, PolymorphicInstanceCallComp)                      \
   M(StaticCall, StaticCallComp)                                                \
   M(LoadLocal, LoadLocalComp)                                                  \
   M(StoreLocal, StoreLocalComp)                                                \
@@ skipping 22 matching lines @@
   M(ChainContext, ChainContextComp)                                            \
   M(CloneContext, CloneContextComp)                                            \
   M(CatchEntry, CatchEntryComp)                                                \
   M(BinaryOp, BinaryOpComp)                                                    \
   M(DoubleBinaryOp, DoubleBinaryOpComp)                                        \
   M(UnarySmiOp, UnarySmiOpComp)                                                \
   M(NumberNegate, NumberNegateComp)                                            \
   M(CheckStackOverflow, CheckStackOverflowComp)                                \
   M(DoubleToDouble, DoubleToDoubleComp)                                        \
   M(SmiToDouble, SmiToDoubleComp)                                              \
-  M(CheckClass, CheckClassComp)
+  M(CheckClass, CheckClassComp)                                                \
+  M(Materialize, MaterializeComp)
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
+FOR_EACH_VALUE(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 // Forward declarations.
 class BindInstr;
 class BranchInstr;
 class BufferFormatter;
 class ComparisonComp;
 class Definition;
 class Instruction;
 class PushArgumentInstr;
@@ skipping 185 matching lines @@
       ASSERT(inputs_[i] != NULL);
       inputs_[i]->RemoveFromUseList();
     }
   }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 };
 
 
-class Value : public TemplateComputation<0> {
+class Value : public ZoneAllocated {
  public:
   Value() { }
 
+  // Declare an enum value used to define kind-test predicates.
+  enum ValueKind {
+#define DECLARE_VALUE_KIND(ShortName, ClassName) k##ShortName,
+  FOR_EACH_VALUE(DECLARE_VALUE_KIND)
+#undef DECLARE_VALUE_KIND
+  };
+
+  // Declare predicate for each value.
+#define DECLARE_PREDICATE(ShortName, ClassName)                                \
+  inline bool Is##ShortName() const;                                           \
+  inline const ClassName* As##ShortName() const;                               \
+  inline ClassName* As##ShortName();
+FOR_EACH_VALUE(DECLARE_PREDICATE)

[srdjan, 2012/08/21 22:14:53]

Is it worth going through all this for just two subclasses: UseVal and Constant?
Do you imagine we can have more subclasses of Value in near future?

[Florian Schneider, 2012/08/22 10:59:00]

Yes, maybe we can get rid of ConstantVal completely and have only one class
UseValue?

+#undef DECLARE_PREDICATE
+
+  virtual ValueKind value_kind() const = 0;
+
+  virtual RawAbstractType* CompileType() const = 0;
+  virtual intptr_t ResultCid() const = 0;
+
+  virtual void PrintTo(BufferFormatter* f) const = 0;
+
   // Returns true if the value represents a constant.
   virtual bool BindsToConstant() const = 0;
 
   // Returns true if the value represents constant null.
   virtual bool BindsToConstantNull() const = 0;
 
   // Assert if BindsToConstant() is false, otherwise returns constant.
   virtual const Object& BoundConstant() const = 0;
 
   // Reminder: The type of the constant null is the bottom type, which is more
   // specific than any type.
   bool CompileTypeIsMoreSpecificThan(const AbstractType& dst_type) const;
 
   virtual void RemoveFromUseList() = 0;
 
+  virtual bool Equals(Value* other) const = 0;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 
 // Functions defined in all concrete computation classes.
 #define DECLARE_COMPUTATION(ShortName)                                         \
   virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr);            \
   virtual ComputationKind computation_kind() const {                           \
     return Computation::k##ShortName;                                          \
   }                                                                            \
   virtual intptr_t ArgumentCount() const { return 0; }                         \
   virtual const char* DebugName() const { return #ShortName; }                 \
   virtual RawAbstractType* CompileType() const;                                \
   virtual LocationSummary* MakeLocationSummary() const;                        \
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
 // Functions defined in all concrete value classes.
 #define DECLARE_VALUE(ShortName)                                               \
-  DECLARE_COMPUTATION(ShortName)                                               \
+  virtual ValueKind value_kind() const {                                       \
+    return Value::k##ShortName;                                                \
+  }                                                                            \
+  virtual const char* DebugName() const { return #ShortName; }                 \
+  virtual RawAbstractType* CompileType() const;                                \
+  virtual bool Equals(Value* other) const;                                     \
   virtual void PrintTo(BufferFormatter* f) const;
 
 
 // Function defined in all call computation classes.
 #define DECLARE_CALL_COMPUTATION(ShortName)                                    \
   virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr);            \
   virtual ComputationKind computation_kind() const {                           \
     return Computation::k##ShortName;                                          \
   }                                                                            \
   virtual const char* DebugName() const { return #ShortName; }                 \
@@ skipping 23 matching lines @@
 
   virtual bool CanDeoptimize() const { return false; }
 
   UseVal* next_use() const { return next_use_; }
   UseVal* previous_use() const { return previous_use_; }
   virtual void RemoveFromUseList();
   virtual void RemoveInputUses() { RemoveFromUseList(); }
 
   virtual intptr_t ResultCid() const;
 
-  virtual bool AttributesEqual(Computation* other) const;
-
  private:
   void AddToUseList();
   Definition* definition_;
   UseVal* next_use_;
   UseVal* previous_use_;
 
   friend class Definition;
 
   DISALLOW_COPY_AND_ASSIGN(UseVal);
 };
@@ skipping 17 matching lines @@
 
   // Returns true if the value represents constant null.
   virtual bool BindsToConstantNull() const { return value().IsNull(); }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void RemoveFromUseList() { }
 
   virtual intptr_t ResultCid() const;
 
-  virtual bool AttributesEqual(Computation* other) const;
-
  private:
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantVal);
 };
 
 #undef DECLARE_VALUE
 
 
+class MaterializeComp : public TemplateComputation<0> {
+ public:
+  explicit MaterializeComp(ConstantVal* constant_val)
+      : constant_val_(constant_val) { }
+
+  DECLARE_COMPUTATION(Materialize)
+
+  virtual void PrintOperandsTo(BufferFormatter* f) const;
+
+  virtual bool CanDeoptimize() const { return false; }
+
+  ConstantVal* constant_val() const { return constant_val_; }
+
+  virtual intptr_t ResultCid() const;
+
+ private:
+  ConstantVal* constant_val_;
+};
+
+
 class AssertAssignableComp : public TemplateComputation<3> {
  public:
   AssertAssignableComp(intptr_t token_pos,
                        intptr_t try_index,
                        Value* value,
                        Value* instantiator,
                        Value* instantiator_type_arguments,
                        const AbstractType& dst_type,
                        const String& dst_name)
       : token_pos_(token_pos),
@@ skipping 1366 matching lines @@
   InstanceCallComp* original_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassComp);
 };
 
 
 #undef DECLARE_COMPUTATION
 
 
 // Implementation of type testers and cast functins.
-#define DEFINE_PREDICATE(ShortName, ClassName)                                 \
+#define DEFINE_COMPUTATION_PREDICATE(ShortName, ClassName)                     \
 bool Computation::Is##ShortName() const {                                      \
   return computation_kind() == k##ShortName;                                   \
 }                                                                              \
 const ClassName* Computation::As##ShortName() const {                          \
   if (!Is##ShortName()) return NULL;                                           \
   return static_cast<const ClassName*>(this);                                  \
 }                                                                              \
 ClassName* Computation::As##ShortName() {                                      \
   if (!Is##ShortName()) return NULL;                                           \
   return static_cast<ClassName*>(this);                                        \
 }
-FOR_EACH_COMPUTATION(DEFINE_PREDICATE)
-#undef DEFINE_PREDICATE
+FOR_EACH_COMPUTATION(DEFINE_COMPUTATION_PREDICATE)
+#undef DEFINE_COMPUTATION_PREDICATE
 
+#define DEFINE_VALUE_PREDICATE(ShortName, ClassName)                           \
+bool Value::Is##ShortName() const {                                            \
+  return value_kind() == k##ShortName;                                         \
+}                                                                              \
+const ClassName* Value::As##ShortName() const {                                \
+  if (!Is##ShortName()) return NULL;                                           \
+  return static_cast<const ClassName*>(this);                                  \
+}                                                                              \
+ClassName* Value::As##ShortName() {                                            \
+  if (!Is##ShortName()) return NULL;                                           \
+  return static_cast<ClassName*>(this);                                        \
+}
+FOR_EACH_VALUE(DEFINE_VALUE_PREDICATE)
+#undef DEFINE_VALUE_PREDICATE
 
 // Instructions.
 
 // 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)                                                               \
@@ skipping 1166 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_