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

runtime/vm/intermediate_language.cc

 // 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.
 
 #include "vm/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1035 matching lines @@
       }
       break;
     default:
       break;
   }
 
   return NULL;
 }
 
 
-Definition* BinaryDoubleOpInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* BinaryDoubleOpInstr::Canonicalize(FlowGraph* flow_graph) {
   Definition* result = NULL;
 
   result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kDoubleCid,
                                              left(),
                                              right());
   if (result != NULL) {
     return result;
   }
 
   result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kDoubleCid,
                                              right(),
                                              left());
   if (result != NULL) {
     return result;
   }
 
   return this;
 }
 
 
-Definition* BinarySmiOpInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* BinarySmiOpInstr::Canonicalize(FlowGraph* flow_graph) {
   Definition* result = NULL;
 
   result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kSmiCid,
                                              left(),
                                              right());
   if (result != NULL) {
     return result;
   }
 
   result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kSmiCid,
                                              right(),
                                              left());
   if (result != NULL) {
     return result;
   }
 
   return this;
 }
 
 
-Definition* BinaryMintOpInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* BinaryMintOpInstr::Canonicalize(FlowGraph* flow_graph) {
   Definition* result = NULL;
 
   result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kMintCid,
                                              left(),
                                              right());
   if (result != NULL) {
     return result;
   }
 
   result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kMintCid,
                                              right(),
                                              left());
   if (result != NULL) {
     return result;
   }
 
   return this;
 }
 
 
 // Optimizations that eliminate or simplify individual instructions.
-Instruction* Instruction::Canonicalize(FlowGraphOptimizer* optimizer) {
+Instruction* Instruction::Canonicalize(FlowGraph* flow_graph) {
   return this;
 }
 
 
-Definition* Definition::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* Definition::Canonicalize(FlowGraph* flow_graph) {
   return this;
 }
 
 
 bool LoadFieldInstr::IsImmutableLengthLoad() const {
   switch (recognized_kind()) {
     case MethodRecognizer::kObjectArrayLength:
     case MethodRecognizer::kImmutableArrayLength:
     case MethodRecognizer::kTypedDataLength:
     case MethodRecognizer::kStringBaseLength:
@@ skipping 40 matching lines @@
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
       return true;
     default:
       return false;
   }
 }
 
 
-Definition* ConstantInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* ConstantInstr::Canonicalize(FlowGraph* flow_graph) {
   return HasUses() ? this : NULL;
 }
 
 
-Definition* LoadFieldInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* LoadFieldInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!IsImmutableLengthLoad()) return this;
 
   // For fixed length arrays if the array is the result of a known constructor
   // call we can replace the length load with the length argument passed to
   // the constructor.
   StaticCallInstr* call = instance()->definition()->AsStaticCall();
   if ((call != NULL) &&
       call->is_known_list_constructor() &&
       IsFixedLengthArrayCid(call->Type()->ToCid())) {
     return call->ArgumentAt(1);
   }
   return this;
 }
 
 
-Definition* AssertBooleanInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* AssertBooleanInstr::Canonicalize(FlowGraph* flow_graph) {
   if (FLAG_eliminate_type_checks && (value()->Type()->ToCid() == kBoolCid)) {
     return value()->definition();
   }
 
   return this;
 }
 
 
-Definition* AssertAssignableInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* AssertAssignableInstr::Canonicalize(FlowGraph* flow_graph) {
   if (FLAG_eliminate_type_checks &&
       value()->Type()->IsAssignableTo(dst_type())) {
     return value()->definition();
   }
 
   // For uninstantiated target types: If the instantiator type arguments
   // are constant, instantiate the target type here.
   if (dst_type().IsInstantiated()) return this;
 
   ConstantInstr* constant_type_args =
       instantiator_type_arguments()->definition()->AsConstant();
   if (constant_type_args != NULL &&
       !constant_type_args->value().IsNull() &&
       constant_type_args->value().IsTypeArguments()) {
     const TypeArguments& instantiator_type_args =
         TypeArguments::Cast(constant_type_args->value());
     const AbstractType& new_dst_type = AbstractType::Handle(
         dst_type().InstantiateFrom(instantiator_type_args, NULL));
     set_dst_type(AbstractType::ZoneHandle(new_dst_type.Canonicalize()));
-    ConstantInstr* null_constant = new ConstantInstr(Object::ZoneHandle());
-    // It is ok to insert instructions before the current during
-    // forward iteration.
-    optimizer->InsertBefore(this, null_constant, NULL, Definition::kValue);
+    ConstantInstr* null_constant = flow_graph->constant_null();
     instantiator_type_arguments()->BindTo(null_constant);
   }
   return this;
 }
 
 
-Definition* BoxDoubleInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* BoxDoubleInstr::Canonicalize(FlowGraph* flow_graph) {
   if (input_use_list() == NULL) {
     // Environments can accomodate any representation. No need to box.
     return value()->definition();
   }
 
   // Fold away BoxDouble(UnboxDouble(v)) if value is known to be double.
   UnboxDoubleInstr* defn = value()->definition()->AsUnboxDouble();
   if ((defn != NULL) && (defn->value()->Type()->ToCid() == kDoubleCid)) {
     return defn->value()->definition();
   }
 
   return this;
 }
 
 
-Definition* UnboxDoubleInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* UnboxDoubleInstr::Canonicalize(FlowGraph* flow_graph) {
   // Fold away UnboxDouble(BoxDouble(v)).
   BoxDoubleInstr* defn = value()->definition()->AsBoxDouble();
   return (defn != NULL) ? defn->value()->definition() : this;
 }
 
 
-Instruction* BranchInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Instruction* BranchInstr::Canonicalize(FlowGraph* flow_graph) {
   // Only handle strict-compares.
   if (comparison()->IsStrictCompare()) {
-    Definition* replacement = comparison()->Canonicalize(optimizer);
+    Definition* replacement = comparison()->Canonicalize(flow_graph);
     if ((replacement == comparison()) || (replacement == NULL)) {
       return this;
     }
     ComparisonInstr* comp = replacement->AsComparison();
     if ((comp == NULL) || comp->CanDeoptimize()) {
       return this;
     }
 
     // Check that comparison is not serving as a pending deoptimization target
     // for conversions.
@@ skipping 20 matching lines @@
       // value of the comparison is not used outside the branch anymore.
       ASSERT(comp->input_use_list() == NULL);
       comp->ClearSSATempIndex();
       comp->ClearTempIndex();
     }
   }
   return this;
 }
 
 
-Definition* StrictCompareInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Definition* StrictCompareInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!right()->BindsToConstant()) {
     return this;
   }
   const Object& right_constant = right()->BoundConstant();
   Definition* left_defn = left()->definition();
   // TODO(fschneider): Handle other cases: e === false and e !== true/false.
   // Handles e === true.
   if ((kind() == Token::kEQ_STRICT) &&
       (right_constant.raw() == Bool::True().raw()) &&
       (left()->Type()->ToCid() == kBoolCid)) {
     // Return left subexpression as the replacement for this instruction.
     return left_defn;
   }
   // x = (a === b);  y = x !== true; -> y = a !== b.
   // In order to merge two strict comares, 'left_strict' must have only one use.
   // Do not check left's cid as it is required to be a strict compare.
   StrictCompareInstr* left_strict = left_defn->AsStrictCompare();
   if ((kind() == Token::kNE_STRICT) &&
       (right_constant.raw() == Bool::True().raw()) &&
       (left_strict != NULL) &&
       (left_strict->HasOnlyUse(left()))) {
     left_strict->set_kind(Token::NegateComparison(left_strict->kind()));
     return left_strict;
   }
 
   return this;
 }
 
 
-Instruction* CheckClassInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Instruction* CheckClassInstr::Canonicalize(FlowGraph* flow_graph) {
   // TODO(vegorov): Replace class checks with null checks when ToNullableCid
   // matches.
 
   const intptr_t value_cid = value()->Type()->ToCid();
   if (value_cid == kDynamicCid) {
     return this;
   }
 
   return unary_checks().HasReceiverClassId(value_cid) ? NULL : this;
 }
 
 
-Instruction* GuardFieldInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Instruction* GuardFieldInstr::Canonicalize(FlowGraph* flow_graph) {
   if (field().guarded_cid() == kDynamicCid) {
     return NULL;  // Nothing to guard.
   }
 
   if (field().is_nullable() && value()->Type()->IsNull()) {
     return NULL;
   }
 
   const intptr_t cid = field().is_nullable() ? value()->Type()->ToNullableCid()
                                              : value()->Type()->ToCid();
   if (field().guarded_cid() == cid) {
     return NULL;  // Value is guaranteed to have this cid.
   }
 
   return this;
 }
 
 
-Instruction* CheckSmiInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+Instruction* CheckSmiInstr::Canonicalize(FlowGraph* flow_graph) {
   return (value()->Type()->ToCid() == kSmiCid) ?  NULL : this;
 }
 
 
-Instruction* CheckEitherNonSmiInstr::Canonicalize(
-    FlowGraphOptimizer* optimizer) {
+Instruction* CheckEitherNonSmiInstr::Canonicalize(FlowGraph* flow_graph) {
   if ((left()->Type()->ToCid() == kDoubleCid) ||
       (right()->Type()->ToCid() == kDoubleCid)) {
     return NULL;  // Remove from the graph.
   }
   return this;
 }
 
 
 // Shared code generation methods (EmitNativeCode, MakeLocationSummary, and
 // PrepareEntry). Only assembly code that can be shared across all architectures
@@ skipping 1033 matching lines @@
     default:
       UNREACHABLE();
   }
   return kPowRuntimeEntry;
 }
 
 
 #undef __
 
 }  // namespace dart