Make constants computations instead of values.

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 35 matching lines @@
 class FlowGraphAllocator;
 class FlowGraphCompiler;
 class FlowGraphVisitor;
 class Function;
 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(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)                                                \
   M(AssertAssignable, AssertAssignableComp)                                    \
   M(AssertBoolean, AssertBooleanComp)                                          \
   M(CurrentContext, CurrentContextComp)                                        \
   M(StoreContext, StoreContextComp)                                            \
   M(ClosureCall, ClosureCallComp)                                              \
@@ skipping 30 matching lines @@
   M(BinarySmiOp, BinarySmiOpComp)                                              \
   M(BinaryMintOp, BinaryMintOpComp)                                            \
   M(BinaryDoubleOp, BinaryDoubleOpComp)                                        \
   M(UnarySmiOp, UnarySmiOpComp)                                                \
   M(NumberNegate, NumberNegateComp)                                            \
   M(CheckStackOverflow, CheckStackOverflowComp)                                \
   M(DoubleToDouble, DoubleToDoubleComp)                                        \
   M(SmiToDouble, SmiToDoubleComp)                                              \
   M(CheckClass, CheckClassComp)                                                \
   M(CheckSmi, CheckSmiComp)                                                    \
-  M(Materialize, MaterializeComp)                                              \
+  M(Constant, ConstantComp)                                                    \
   M(CheckEitherNonSmi, CheckEitherNonSmiComp)                                  \
   M(UnboxedDoubleBinaryOp, UnboxedDoubleBinaryOpComp)                          \
   M(UnboxDouble, UnboxDoubleComp)                                              \
   M(BoxDouble, BoxDoubleComp)
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 FOR_EACH_VALUE(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
@@ skipping 335 matching lines @@
  private:
   Definition* definition_;
   UseVal* next_use_;
   Instruction* instruction_;
   intptr_t use_index_;
 
   DISALLOW_COPY_AND_ASSIGN(UseVal);
 };
 
 
-class ConstantVal : public Value {
+#undef DECLARE_VALUE
+
+
+class ConstantComp : public TemplateComputation<0> {
  public:
-  explicit ConstantVal(const Object& value)
-      : value_(value) {
-    ASSERT(value.IsZoneHandle());
-    ASSERT(value.IsSmi() || value.IsOld());
-  }
+  explicit ConstantComp(const Object& value) : value_(value) { }
 
-  DECLARE_VALUE(Constant)
+  DECLARE_COMPUTATION(Constant)
 
   const Object& value() const { return value_; }
 
-  // Returns true if the value represents a constant.
-  virtual bool BindsToConstant() const { return true; }
-  virtual const Object& BoundConstant() const { return value(); }
-
-  // Returns true if the value represents constant null.
-  virtual bool BindsToConstantNull() const { return value().IsNull(); }
+  virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t ResultCid() const;
 
-  virtual Value* CopyValue() { return this; }
+  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_;
+  DISALLOW_COPY_AND_ASSIGN(ConstantComp);
 };
 
 
 class AssertAssignableComp : public TemplateComputation<3> {
  public:
   AssertAssignableComp(intptr_t token_pos,
                        intptr_t try_index,
                        Value* value,
                        Value* instantiator,
                        Value* instantiator_type_arguments,
@@ skipping 2081 matching lines @@
   Instruction* Current() const { return current_; }
 
  private:
   BlockEntryInstr* block_entry_;
   Instruction* current_;
 };
 
 
 class GraphEntryInstr : public BlockEntryInstr {
  public:
-  explicit GraphEntryInstr(TargetEntryInstr* normal_entry)
-      : BlockEntryInstr(),
-        normal_entry_(normal_entry),
-        catch_entries_(),
-        start_env_(NULL),
-        spill_slot_count_(0) { }
+  explicit GraphEntryInstr(TargetEntryInstr* normal_entry);
 
   DECLARE_INSTRUCTION(GraphEntry)
 
   virtual intptr_t PredecessorCount() const { return 0; }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
   }
   virtual void AddPredecessor(BlockEntryInstr* predecessor) { UNREACHABLE(); }
 
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
       GrowableArray<BlockEntryInstr*>* preorder,
       GrowableArray<BlockEntryInstr*>* postorder,
       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count,
       intptr_t fixed_parameter_count);
 
   void AddCatchEntry(TargetEntryInstr* entry) { catch_entries_.Add(entry); }
 
   virtual void PrepareEntry(FlowGraphCompiler* compiler);
 
   Environment* start_env() const { return start_env_; }
   void set_start_env(Environment* env) { start_env_ = env; }
 
+  Definition* constant_null() const { return constant_null_; }
+
   intptr_t spill_slot_count() const { return spill_slot_count_; }
   void set_spill_slot_count(intptr_t count) {
     ASSERT(count >= 0);
     spill_slot_count_ = count;
   }
 
  private:
   TargetEntryInstr* normal_entry_;
   GrowableArray<TargetEntryInstr*> catch_entries_;
   Environment* start_env_;
+  Definition* constant_null_;
   intptr_t spill_slot_count_;
 
   DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
 };
 
 
 class JoinEntryInstr : public BlockEntryInstr {
  public:
   JoinEntryInstr()
       : BlockEntryInstr(),
@@ skipping 728 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_