Use the constant pool for all constants, not just null.

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"
 #include "vm/handles_impl.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 
 namespace dart {
 
 class BitVector;
 class BlockEntryInstr;
 class BufferFormatter;
 class CatchBlockEntryInstr;
 class ComparisonInstr;
 class ControlInstruction;
 class Definition;
 class Environment;
+class FlowGraph;
 class FlowGraphCompiler;
-class FlowGraphOptimizer;
 class FlowGraphVisitor;
 class Instruction;
 class LocalVariable;
 class ParsedFunction;
 class Range;
 
 
 // TODO(srdjan): Unify with INTRINSIC_LIST.
 // (class-name, function-name, recognized enum, fingerprint).
 // See intrinsifier for fingerprint computation.
@@ skipping 722 matching lines @@
   // that input operands conversions inserted for this instruction can jump
   // to.
   virtual intptr_t DeoptimizationTarget() const {
     UNREACHABLE();
     return Isolate::kNoDeoptId;
   }
 
   // Returns a replacement for the instruction or NULL if the instruction can
   // be eliminated.  By default returns the this instruction which means no
   // change.
-  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   // Insert this instruction before 'next' after use lists are computed.
   // Instructions cannot be inserted before a block entry or any other
   // instruction without a previous instruction.
   void InsertBefore(Instruction* next) { InsertAfter(next->previous()); }
 
   // Insert this instruction after 'prev' after use lists are computed.
   void InsertAfter(Instruction* prev);
 
   // Returns true if CSE and LICM are allowed for this instruction.
@@ skipping 764 matching lines @@
   //    - unknown sentinel
   Object& constant_value() const { return constant_value_; }
 
   virtual void InferRange();
 
   Range* range() const { return range_; }
 
   // Definitions can be canonicalized only into definitions to ensure
   // this check statically we override base Canonicalize with a Canonicalize
   // returning Definition (return type is covariant).
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   static const intptr_t kReplacementMarker = -2;
 
   Definition* Replacement() {
     if (ssa_temp_index_ == kReplacementMarker) {
       return reinterpret_cast<Definition*>(temp_index_);
     }
     return this;
   }
 
@@ skipping 391 matching lines @@
   virtual Representation RequiredInputRepresentation(intptr_t i) const;
 
   // A misleadingly named function for use in template functions that also
   // replace definitions.  In this case, leave the branch intact and replace
   // its comparison with another comparison that has been removed from the
   // graph but still has uses properly linked into their definition's use
   // list.
   void ReplaceWith(ComparisonInstr* other,
                    ForwardInstructionIterator* ignored);
 
-  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual void PrintTo(BufferFormatter* f) const;
 
   // Set compile type constrained by the comparison of this branch.
   // FlowGraphPropagator propagates it downwards into either true or false
   // successor.
   void set_constrained_type(ConstrainedCompileType* type) {
     constrained_type_ = type;
   }
 
@@ skipping 322 matching lines @@
 
 
 class ConstantInstr : public TemplateDefinition<0> {
  public:
   explicit ConstantInstr(const Object& value)
       : value_(value) { }
 
   DECLARE_INSTRUCTION(Constant)
   virtual CompileType ComputeType() const;
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   const Object& value() const { return value_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void InferRange();
 
   virtual bool AllowsCSE() const { return true; }
@@ skipping 38 matching lines @@
   const AbstractType& dst_type() const { return dst_type_; }
   void set_dst_type(const AbstractType& dst_type) {
     dst_type_ = dst_type.raw();
   }
   const String& dst_name() const { return dst_name_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   const intptr_t token_pos_;
   AbstractType& dst_type_;
   const String& dst_name_;
@@ skipping 12 matching lines @@
   DECLARE_INSTRUCTION(AssertBoolean)
   virtual CompileType ComputeType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
@@ skipping 288 matching lines @@
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanBeDeoptimizationTarget() const {
     // StrictCompare can be merged into Branch and thus needs an environment.
     return true;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   bool needs_number_check() const { return needs_number_check_; }
   void set_needs_number_check(bool value) { needs_number_check_ = value; }
   void set_kind(Token::Kind value) { kind_ = value; }
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
@@ skipping 436 matching lines @@
   Value* value() const { return inputs_[0]; }
 
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(GuardField)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   const Field& field_;
@@ skipping 527 matching lines @@
   virtual CompileType ComputeType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void InferRange();
 
   bool IsImmutableLengthLoad() const;
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   static MethodRecognizer::Kind RecognizedKindFromArrayCid(intptr_t cid);
 
   static bool IsFixedLengthArrayCid(intptr_t cid);
 
   virtual bool AllowsCSE() const { return immutable_; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
@@ skipping 262 matching lines @@
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
 };
 
@@ skipping 14 matching lines @@
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
-  Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
 };
 
 
 class BoxFloat32x4Instr : public TemplateDefinition<1> {
  public:
   explicit BoxFloat32x4Instr(Value* value) {
     SetInputAt(0, value);
@@ skipping 96 matching lines @@
   }
 
   DECLARE_INSTRUCTION(UnboxDouble)
   virtual CompileType ComputeType() const;
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
-  Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
 class UnboxFloat32x4Instr : public TemplateDefinition<1> {
  public:
   UnboxFloat32x4Instr(Value* value, intptr_t deopt_id) {
     SetInputAt(0, value);
@@ skipping 156 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(BinaryDoubleOp)
   virtual CompileType ComputeType() const;
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryDoubleOp()->op_kind();
   }
 
  private:
   const Token::Kind op_kind_;
@@ skipping 666 matching lines @@
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedMint;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DECLARE_INSTRUCTION(BinaryMintOp)
   virtual CompileType ComputeType() const;
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     ASSERT(other->IsBinaryMintOp());
     return op_kind() == other->AsBinaryMintOp()->op_kind();
@@ skipping 151 matching lines @@
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
   void PrintTo(BufferFormatter* f) const;
 
   virtual void InferRange();
 
-  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   // Returns true if right is a non-zero Smi constant which absolute value is
   // a power of two.
   bool RightIsPowerOfTwoConstant() const;
 
  private:
   const Token::Kind op_kind_;
   InstanceCallInstr* instance_call_;
   bool overflow_;
   bool is_truncating_;
@@ skipping 268 matching lines @@
   DECLARE_INSTRUCTION(CheckClass)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
-  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   void set_null_check(bool flag) { null_check_ = flag; }
 
   bool null_check() const { return null_check_; }
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
@@ skipping 17 matching lines @@
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CheckSmi)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
+  virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
@@ skipping 257 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_