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

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 288 matching lines @@
     }
   }
   iterator->RemoveCurrentFromGraph();
 }
 
 
 bool FlowGraphOptimizer::Canonicalize() {
   bool changed = false;
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
-    entry->Accept(this);
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
-      Instruction* replacement = current->Canonicalize(this);
+      Instruction* replacement = current->Canonicalize(flow_graph());
       if (replacement != current) {
         // For non-definitions Canonicalize should return either NULL or
         // this.
         ASSERT((replacement == NULL) || current->IsDefinition());
         ReplaceCurrentInstruction(&it, current, replacement, flow_graph_);
         changed = true;
       }
     }
   }
   return changed;
@@ skipping 33 matching lines @@
   } else if ((from == kTagged) && (to == kUnboxedDouble)) {
     ASSERT((deopt_target != NULL) ||
            (use->Type()->ToCid() == kDoubleCid));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     ConstantInstr* constant = use->definition()->AsConstant();
     if ((constant != NULL) && constant->value().IsSmi()) {
       const double dbl_val = Smi::Cast(constant->value()).AsDoubleValue();
       const Double& dbl_obj =
           Double::ZoneHandle(Double::New(dbl_val, Heap::kOld));
-      ConstantInstr* double_const = new ConstantInstr(dbl_obj);
-      InsertBefore(insert_before, double_const, NULL, Definition::kValue);
+      ConstantInstr* double_const = flow_graph()->GetConstant(dbl_obj);
       converted = new UnboxDoubleInstr(new Value(double_const), deopt_id);
     } else {
       converted = new UnboxDoubleInstr(use->CopyWithType(), deopt_id);
     }
   } else if ((from == kTagged) && (to == kUnboxedFloat32x4)) {
     ASSERT((deopt_target != NULL) ||
            (use->Type()->ToCid() == kFloat32x4Cid));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     converted = new UnboxFloat32x4Instr(use->CopyWithType(), deopt_id);
@@ skipping 746 matching lines @@
     const intptr_t value = Smi::Cast(obj).Value();
     if ((value <= 0) || !Utils::IsPowerOfTwo(value)) return false;
 
     // Insert smi check and attach a copy of the original environment
     // because the smi operation can still deoptimize.
     InsertBefore(call,
                  new CheckSmiInstr(new Value(left), call->deopt_id()),
                  call->env(),
                  Definition::kEffect);
     ConstantInstr* constant =
-        new ConstantInstr(Smi::Handle(Smi::New(value - 1)));
-    InsertBefore(call, constant, NULL, Definition::kValue);
+        flow_graph()->GetConstant(Smi::Handle(Smi::New(value - 1)));
     BinarySmiOpInstr* bin_op =
         new BinarySmiOpInstr(Token::kBIT_AND, call,
                              new Value(left),
                              new Value(constant));
     ReplaceCall(call, bin_op);
   } else {
     ASSERT(operands_type == kSmiCid);
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
     AddCheckSmi(left, call->deopt_id(), call->env(), call);
@@ skipping 25 matching lines @@
                  Definition::kEffect);
     unary_op = new UnarySmiOpInstr(op_kind, call, new Value(input));
   } else if ((op_kind == Token::kBIT_NOT) &&
              HasOnlySmiOrMint(*call->ic_data()) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     unary_op = new UnaryMintOpInstr(op_kind, new Value(input), call);
   } else if (HasOnlyOneDouble(*call->ic_data()) &&
              (op_kind == Token::kNEGATE)) {
     AddReceiverCheck(call);
     ConstantInstr* minus_one =
-        new ConstantInstr(Double::ZoneHandle(Double::NewCanonical(-1)));
-    InsertBefore(call, minus_one, NULL, Definition::kValue);
+        flow_graph()->GetConstant(Double::ZoneHandle(Double::NewCanonical(-1)));
     unary_op = new BinaryDoubleOpInstr(Token::kMUL,
                                        new Value(input),
                                        new Value(minus_one),
                                        call);
   }
   if (unary_op == NULL) return false;
 
   ReplaceCall(call, unary_op);
   return true;
 }
@@ skipping 172 matching lines @@
   ReplaceCall(call, load);
 }
 
 
 void FlowGraphOptimizer::InlineStringIsEmptyGetter(InstanceCallInstr* call) {
   AddReceiverCheck(call);
 
   LoadFieldInstr* load = BuildLoadStringLength(call->ArgumentAt(0));
   InsertBefore(call, load, NULL, Definition::kValue);
 
-  ConstantInstr* zero = new ConstantInstr(Smi::Handle(Smi::New(0)));
-  InsertBefore(call, zero, NULL, Definition::kValue);
-
+  ConstantInstr* zero = flow_graph()->GetConstant(Smi::Handle(Smi::New(0)));
   StrictCompareInstr* compare =
       new StrictCompareInstr(Token::kEQ_STRICT,
                              new Value(load),
                              new Value(zero));
   ReplaceCall(call, compare);
 }
 
 
 static intptr_t OffsetForLengthGetter(MethodRecognizer::Kind kind) {
   switch (kind) {
@@ skipping 630 matching lines @@
       Type::ZoneHandle(Type::SmiType()),
       is_immutable);
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(receiver_cid));
   InsertBefore(call, length, NULL, Definition::kValue);
 
   // len_in_bytes = length * kBytesPerElement(receiver)
   intptr_t element_size = FlowGraphCompiler::ElementSizeFor(receiver_cid);
   ConstantInstr* bytes_per_element =
-      new ConstantInstr(Smi::Handle(Smi::New(element_size)));
-  InsertBefore(call, bytes_per_element, NULL, Definition::kValue);
+      flow_graph()->GetConstant(Smi::Handle(Smi::New(element_size)));
   BinarySmiOpInstr* len_in_bytes =
       new BinarySmiOpInstr(Token::kMUL,
                            call,
                            new Value(length),
                            new Value(bytes_per_element));
   InsertBefore(call, len_in_bytes, call->env(), Definition::kValue);
 
     // Check byte_index < len_in_bytes.
   InsertBefore(call,
                new CheckArrayBoundInstr(new Value(len_in_bytes),
@@ skipping 66 matching lines @@
       Bool::Cast(call->ArgumentAt(4)->AsConstant()->value()).value();
   const ICData& unary_checks =
       ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks());
   if (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks) {
     Bool& as_bool = Bool::ZoneHandle(InstanceOfAsBool(unary_checks, type));
     if (!as_bool.IsNull()) {
       AddReceiverCheck(call);
       if (negate) {
         as_bool = Bool::Get(!as_bool.value());
       }
-      ConstantInstr* bool_const = new ConstantInstr(as_bool);
-      ReplaceCall(call, bool_const);
+      ConstantInstr* bool_const = flow_graph()->GetConstant(as_bool);
+      for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
+        PushArgumentInstr* push = call->PushArgumentAt(i);
+        push->ReplaceUsesWith(push->value()->definition());
+        push->RemoveFromGraph();
+      }
+      call->ReplaceUsesWith(bool_const);
+      ASSERT(current_iterator()->Current() == call);
+      current_iterator()->RemoveCurrentFromGraph();
       return;
     }
   }
   InstanceOfInstr* instance_of =
       new InstanceOfInstr(call->token_pos(),
                           new Value(left),
                           new Value(instantiator),
                           new Value(type_args),
                           type,
                           negate,
@@ skipping 544 matching lines @@
 
 void RangeAnalysis::Analyze() {
   CollectSmiValues();
   InsertConstraints();
   InferRanges();
   RemoveConstraints();
 }
 
 
 void RangeAnalysis::CollectSmiValues() {
+  const GrowableArray<Definition*>& initial =
+      *flow_graph_->graph_entry()->initial_definitions();
+  for (intptr_t i = 0; i < initial.length(); ++i) {
+    Definition* current = initial[i];
+    if (current->Type()->ToCid() == kSmiCid) {
+      smi_values_.Add(current);
+    }
+  }
+
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
     for (ForwardInstructionIterator instr_it(block);
          !instr_it.Done();
          instr_it.Advance()) {
       Instruction* current = instr_it.Current();
       Definition* defn = current->AsDefinition();
       if (defn != NULL) {
         if ((defn->Type()->ToCid() == kSmiCid) &&
             (defn->ssa_temp_index() != -1)) {
           smi_values_.Add(defn);
         }
       } else if (current->IsCheckSmi()) {
         smi_checks_.Add(current->AsCheckSmi());
       }
     }
 
     JoinEntryInstr* join = block->AsJoinEntry();
     if (join != NULL) {
       for (PhiIterator phi_it(join); !phi_it.Done(); phi_it.Advance()) {
         PhiInstr* current = phi_it.Current();
-        if ((current->Type()->ToCid() == kSmiCid)) {
+        if (current->Type()->ToCid() == kSmiCid) {
           smi_values_.Add(current);
         }
       }
     }
   }
 }
 
 
 // Returns true if use is dominated by the given instruction.
 // Note: uses that occur at instruction itself are not dominated by it.
@@ skipping 383 matching lines @@
   // Initialize bitvector for quick filtering of smi values.
   smi_definitions_ = new BitVector(flow_graph_->current_ssa_temp_index());
   for (intptr_t i = 0; i < smi_values_.length(); i++) {
     smi_definitions_->Add(smi_values_[i]->ssa_temp_index());
   }
   for (intptr_t i = 0; i < constraints_.length(); i++) {
     smi_definitions_->Add(constraints_[i]->ssa_temp_index());
   }
 
   // Infer initial values of ranges.
+  const GrowableArray<Definition*>& initial =
+      *flow_graph_->graph_entry()->initial_definitions();
+  for (intptr_t i = 0; i < initial.length(); ++i) {
+    Definition* definition = initial[i];
+    if (smi_definitions_->Contains(definition->ssa_temp_index())) {
+      definition->InferRange();
+    }
+  }
   InferRangesRecursive(flow_graph_->graph_entry());
 
   if (FLAG_trace_range_analysis) {
     OS::Print("---- after range analysis -------\n");
     FlowGraphPrinter printer(*flow_graph_);
     printer.PrintBlocks();
   }
 }
 
 
@@ skipping 2233 matching lines @@
           !defn->IsPushArgument() &&
           !defn->IsStoreIndexed() &&
           !defn->IsStoreInstanceField() &&
           !defn->IsStoreStaticField() &&
           !defn->IsStoreVMField()) {
         if (FLAG_trace_constant_propagation) {
           OS::Print("Constant v%"Pd" = %s\n",
                     defn->ssa_temp_index(),
                     defn->constant_value().ToCString());
         }
-        defn->ReplaceWith(new ConstantInstr(defn->constant_value()), &i);
+        ConstantInstr* constant = graph_->GetConstant(defn->constant_value());
+        defn->ReplaceUsesWith(constant);
+        i.RemoveCurrentFromGraph();
       }
     }
 
     // Replace branches where one target is unreachable with jumps.
     BranchInstr* branch = block->last_instruction()->AsBranch();
     if (branch != NULL) {
       TargetEntryInstr* if_true = branch->true_successor();
       TargetEntryInstr* if_false = branch->false_successor();
       JoinEntryInstr* join = NULL;
       Instruction* next = NULL;
@@ skipping 69 matching lines @@
 }
 
 
 bool BranchSimplifier::Match(JoinEntryInstr* block) {
   // Match the pattern of a branch on a comparison whose left operand is a
   // phi from the same block, and whose right operand is a constant.
   //
   //   Branch(Comparison(kind, Phi, Constant))
   //
   // These are the branches produced by inlining in a test context.  Also,
-  // the phi and the constant have no other uses so they can simply be
-  // eliminated.  The block has no other phis and no instructions
-  // intervening between the phi, constant, and branch so the block can
-  // simply be eliminated.
+  // the phi has no other uses so they can simply be eliminated.  The block
+  // has no other phis and no instructions intervening between the phi and
+  // branch so the block can simply be eliminated.
   BranchInstr* branch = block->last_instruction()->AsBranch();
   ASSERT(branch != NULL);
   ComparisonInstr* comparison = branch->comparison();
   Value* left = comparison->left();
   PhiInstr* phi = left->definition()->AsPhi();
   Value* right = comparison->right();
   ConstantInstr* constant = right->definition()->AsConstant();
   return (phi != NULL) &&
       (constant != NULL) &&
       (phi->GetBlock() == block) &&
       PhiHasSingleUse(phi, left) &&
-      constant->HasOnlyUse(right) &&
-      (block->next() == constant) &&
-      (constant->next() == branch) &&
+      (block->next() == branch) &&
       (block->phis()->length() == 1);
 }
 
 
 JoinEntryInstr* BranchSimplifier::ToJoinEntry(TargetEntryInstr* target) {
   // Convert a target block into a join block.  Branches will be duplicated
   // so the former true and false targets become joins of the control flows
   // from all the duplicated branches.
   JoinEntryInstr* join =
       new JoinEntryInstr(target->block_id(), target->try_index());
   join->InheritDeoptTarget(target);
   join->LinkTo(target->next());
   join->set_last_instruction(target->last_instruction());
   target->UnuseAllInputs();
   return join;
 }
 
 
-ConstantInstr* BranchSimplifier::CloneConstant(FlowGraph* flow_graph,
-                                               ConstantInstr* constant) {
-  ConstantInstr* new_constant = new ConstantInstr(constant->value());
-  new_constant->set_ssa_temp_index(flow_graph->alloc_ssa_temp_index());
-  return new_constant;
-}
-
-
 BranchInstr* BranchSimplifier::CloneBranch(BranchInstr* branch,
                                            Value* left,
                                            Value* right) {
   ComparisonInstr* comparison = branch->comparison();
   ComparisonInstr* new_comparison = NULL;
   if (comparison->IsStrictCompare()) {
     new_comparison = new StrictCompareInstr(comparison->kind(), left, right);
   } else if (comparison->IsEqualityCompare()) {
     EqualityCompareInstr* equality_compare = comparison->AsEqualityCompare();
     EqualityCompareInstr* new_equality_compare =
@@ skipping 65 matching lines @@
       ComparisonInstr* comparison = branch->comparison();
       PhiInstr* phi = comparison->left()->definition()->AsPhi();
       ConstantInstr* constant = comparison->right()->definition()->AsConstant();
       ASSERT(constant != NULL);
       // Copy the constant and branch and push it to all the predecessors.
       for (intptr_t i = 0, count = block->PredecessorCount(); i < count; ++i) {
         GotoInstr* old_goto =
             block->PredecessorAt(i)->last_instruction()->AsGoto();
         ASSERT(old_goto != NULL);
 
-        // Insert a copy of the constant in all the predecessors.
-        ConstantInstr* new_constant = CloneConstant(flow_graph, constant);
-        new_constant->InsertBefore(old_goto);
-
         // Replace the goto in each predecessor with a rewritten branch,
         // rewritten to use the corresponding phi input instead of the phi.
         Value* new_left = phi->InputAt(i)->Copy();
-        Value* new_right = new Value(new_constant);
+        Value* new_right = new Value(constant);
         BranchInstr* new_branch = CloneBranch(branch, new_left, new_right);
         if (branch->env() == NULL) {
           new_branch->InheritDeoptTarget(old_goto);
         } else {
           // Take the environment from the branch if it has one.
           new_branch->InheritDeoptTarget(branch);
           // InheritDeoptTarget gave the new branch's comparison the same
           // deopt id that it gave the new branch.  The id should be the
           // deopt id of the original comparison.
           new_branch->comparison()->SetDeoptId(comparison->GetDeoptId());
-          // The phi and constant can be used in the branch's environment.
-          // Rename such uses.
+          // The phi can be used in the branch's environment.  Rename such
+          // uses.
           for (Environment::DeepIterator it(new_branch->env());
                !it.Done();
                it.Advance()) {
             Value* use = it.CurrentValue();
-            Definition* replacement = NULL;
             if (use->definition() == phi) {
-              replacement = phi->InputAt(i)->definition();
-            } else if (use->definition() == constant) {
-              replacement = new_constant;
-            }
-            if (replacement != NULL) {
+              Definition* replacement = phi->InputAt(i)->definition();
               use->RemoveFromUseList();
               use->set_definition(replacement);
               replacement->AddEnvUse(use);
             }
           }
         }
 
         new_branch->InsertBefore(old_goto);
         new_branch->set_next(NULL);  // Detaching the goto from the graph.
         old_goto->UnuseAllInputs();
@@ skipping 25 matching lines @@
         goto_false->InheritDeoptTarget(join_false);
         false_target->LinkTo(goto_false);
         false_target->set_last_instruction(goto_false);
       }
       // When all predecessors have been rewritten, the original block is
       // unreachable from the graph.
       phi->UnuseAllInputs();
       branch->UnuseAllInputs();
       block->UnuseAllInputs();
       ASSERT(!phi->HasUses());
-      ASSERT(!constant->HasUses());
     }
   }
 
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
@@ skipping 122 matching lines @@
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
 
 }  // namespace dart