Make register allocator to disregard constant computation with no uses.

runtime/vm/flow_graph_allocator.cc

 // 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.
 
 #include "vm/flow_graph_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/intermediate_language.h"
 #include "vm/il_printer.h"
 #include "vm/flow_graph.h"
@@ skipping 744 matching lines @@
     Value* value = values[i];
     locations[i] = Location::Any();
     Definition* def = value->definition();
 
     if (def->IsPushArgument()) {
       // Frame size is unknown until after allocation.
       locations[i] = Location::NoLocation();
       continue;
     }
 
+    ConstantComp* constant = def->AsConstant();
+    if (constant != NULL) {
+      locations[i] = Location::Constant(constant->value());
+      continue;
+    }
+
     const intptr_t vreg = def->ssa_temp_index();
     LiveRange* range = GetLiveRange(vreg);
     range->AddUseInterval(block_start_pos, use_pos);
     range->AddUse(use_pos, &locations[i]);
   }
 
   env->set_locations(locations);
 }
 
 
 // Create and update live ranges corresponding to instruction's inputs,
 // temporaries and output.
 void FlowGraphAllocator::ProcessOneInstruction(BlockEntryInstr* block,
                                                Instruction* current) {
+  LocationSummary* locs = current->locs();
+
+  Definition* def = current->AsDefinition();
+  if ((def != NULL) &&
+      (def->AsConstant() != NULL) &&
+      (GetLiveRange(def->ssa_temp_index())->first_use() == NULL)) {
+    // Drop definitions of constants that have no uses.
+    locs->set_out(Location::NoLocation());
+    return;
+  }
+
   const intptr_t pos = current->lifetime_position();
   ASSERT(IsInstructionStartPosition(pos));
 
-  LocationSummary* locs = current->locs();
-
   // Number of input locations and number of input operands have to agree.
   ASSERT(locs->input_count() == current->InputCount());
 
   // Normalize same-as-first-input output if input is specified as
   // fixed register.
   if (locs->out().IsUnallocated() &&
       (locs->out().policy() == Location::kSameAsFirstInput) &&
       (locs->in(0).IsMachineRegister())) {
     locs->set_out(locs->in(0));
   }
@@ skipping 23 matching lines @@
       //
       //                 j' i  i'
       //      value    --*
       //      register   [-----)
       //
       MoveOperands* move =
           AddMoveAt(pos - 1, *in_ref, Location::Any());
       BlockLocation(*in_ref, pos - 1, pos + 1);
       range->AddUseInterval(block->start_pos(), pos - 1);
       range->AddHintedUse(pos - 1, move->src_slot(), in_ref);
-    } else {
+    } else if (in_ref->IsUnallocated()) {
       // Normal unallocated input. Expected shape of
       // live ranges:
       //
       //                 i  i'
       //      value    -----*
       //
       ASSERT(in_ref->IsUnallocated());
       range->AddUseInterval(block->start_pos(), pos + 1);
       range->AddUse(pos + 1, in_ref);
+    } else {
+      ASSERT(in_ref->IsConstant());
     }
   }
 
   // Process temps.
   for (intptr_t j = 0; j < locs->temp_count(); j++) {
     // Expected shape of live range:
     //
     //              i  i'
     //              [--)
     //
@@ skipping 46 matching lines @@
     }
 
     ASSERT(!locs->out().IsUnallocated());
 #endif
   }
 
   if (locs->can_call()) {
     safepoints_.Add(current);
   }
 
-  Definition* def = current->AsDefinition();
   if (def == NULL) {
     ASSERT(locs->out().IsInvalid());
     return;
   }
 
   if (locs->out().IsInvalid()) {
     ASSERT(def->ssa_temp_index() < 0);
     return;
   }
 
@@ skipping 1244 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart