Don't assign safepoint at the definition to the definition's live-range.

runtime/vm/flow_graph_allocator.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_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/intermediate_language.h"
 #include "vm/il_printer.h"
 #include "vm/flow_graph.h"
@@ skipping 592 matching lines @@
     slot_index -= flow_graph_.num_non_copied_params();
 
     range->set_assigned_location(Location::StackSlot(slot_index));
     range->set_spill_slot(Location::StackSlot(slot_index));
   } else {
     ConstantInstr* constant = defn->AsConstant();
     ASSERT(constant != NULL);
     range->set_assigned_location(Location::Constant(constant->value()));
     range->set_spill_slot(Location::Constant(constant->value()));
   }
-  AssignSafepoints(range);
+  AssignSafepoints(defn, range);
   range->finger()->Initialize(range);
   UsePosition* use =
       range->finger()->FirstRegisterBeneficialUse(block->start_pos());
   if (use != NULL) {
     LiveRange* tail =
         SplitBetween(range, block->start_pos(), use->pos());
     // Parameters and constants are tagged, so allocated to CPU registers.
     CompleteRange(tail, Location::kRegister);
   }
   ConvertAllUses(range);
@@ skipping 152 matching lines @@
       GotoInstr* goto_instr = pred->last_instruction()->AsGoto();
       ASSERT((goto_instr != NULL) && (goto_instr->HasParallelMove()));
       MoveOperands* move =
           goto_instr->parallel_move()->MoveOperandsAt(move_idx);
       move->set_dest(Location::PrefersRegister());
       range->AddUse(pos, move->dest_slot());
     }
 
     // All phi resolution moves are connected. Phi's live range is
     // complete.
-    AssignSafepoints(range);
+    AssignSafepoints(phi, range);
 
     CompleteRange(range, RegisterKindForResult(phi));
 
     move_idx++;
   }
 }
 
 
 void FlowGraphAllocator::ProcessEnvironmentUses(BlockEntryInstr* block,
                                                 Instruction* current) {
@@ skipping 190 matching lines @@
       range->AddUseInterval(block->start_pos(), pos + 1);
       range->AddUse(pos + 1, in_ref);
     }
   } else {
     ASSERT(in_ref->IsConstant());
   }
 }
 
 
 void FlowGraphAllocator::ProcessOneOutput(BlockEntryInstr* block,
-                                          Instruction* current,
                                           intptr_t pos,
                                           Location* out,
                                           Definition* def,
                                           intptr_t vreg,
                                           bool output_same_as_first_input,
                                           Location* in_ref,
                                           Definition* input,
                                           intptr_t input_vreg,
                                           BitVector* interference_set) {
   ASSERT(out != NULL);
@@ skipping 88 matching lines @@
     //
     ASSERT(out->Equals(Location::RequiresRegister()) ||
            out->Equals(Location::RequiresFpuRegister()));
 
     // Shorten live range to the point of definition and add use to be filled by
     // allocator.
     range->DefineAt(pos);
     range->AddUse(pos, out);
   }
 
-  AssignSafepoints(range);
-  CompleteRange(range, RegisterKindForResult(current));
+  AssignSafepoints(def, range);
+  CompleteRange(range, RegisterKindForResult(def));
 }
 
 
 // Create and update live ranges corresponding to instruction's inputs,
 // temporaries and output.
 void FlowGraphAllocator::ProcessOneInstruction(BlockEntryInstr* block,
                                                Instruction* current,
                                                BitVector* interference_set) {
   LocationSummary* locs = current->locs();
 
@@ skipping 176 matching lines @@
   if (out->IsPairLocation()) {
     ASSERT(def->HasPairRepresentation());
     PairLocation* pair = out->AsPairLocation();
     if (output_same_as_first_input) {
       ASSERT(locs->in_slot(0)->IsPairLocation());
       PairLocation* in_pair = locs->in_slot(0)->AsPairLocation();
       Definition* input = current->InputAt(0)->definition();
       ASSERT(input->HasPairRepresentation());
       // Each element of the pair is assigned it's own virtual register number
       // and is allocated its own LiveRange.
-      ProcessOneOutput(block, current, pos,  // BlockEntry, Instruction, seq.
+      ProcessOneOutput(block, pos,  // BlockEntry, seq.
                        pair->SlotAt(0), def,  // (output) Location, Definition.
                        def->ssa_temp_index(),  // (output) virtual register.
                        true,  // output mapped to first input.
                        in_pair->SlotAt(0), input,  // (input) Location, Def.
                        input->ssa_temp_index(),  // (input) virtual register.
                        interference_set);
-      ProcessOneOutput(block, current, pos,
+      ProcessOneOutput(block, pos,
                        pair->SlotAt(1), def,
                        ToSecondPairVreg(def->ssa_temp_index()),
                        true,
                        in_pair->SlotAt(1), input,
                        ToSecondPairVreg(input->ssa_temp_index()),
                        interference_set);
     } else {
       // Each element of the pair is assigned it's own virtual register number
       // and is allocated its own LiveRange.
-      ProcessOneOutput(block, current, pos,
+      ProcessOneOutput(block, pos,
                        pair->SlotAt(0), def,
                        def->ssa_temp_index(),
                        false,            // output is not mapped to first input.
                        NULL, NULL, -1,   // First input not needed.
                        interference_set);
-      ProcessOneOutput(block, current, pos,
+      ProcessOneOutput(block, pos,
                        pair->SlotAt(1), def,
                        ToSecondPairVreg(def->ssa_temp_index()),
                        false,
                        NULL, NULL, -1,
                        interference_set);
     }
   } else {
     if (output_same_as_first_input) {
       Location* in_ref = locs->in_slot(0);
       Definition* input = current->InputAt(0)->definition();
       ASSERT(!in_ref->IsPairLocation());
-      ProcessOneOutput(block, current, pos,  // BlockEntry, Instruction, seq.
+      ProcessOneOutput(block, pos,  // BlockEntry, Instruction, seq.
                        out, def,  // (output) Location, Definition.
                        def->ssa_temp_index(),  // (output) virtual register.
                        true,  // output mapped to first input.
                        in_ref, input,  // (input) Location, Def.
                        input->ssa_temp_index(),  // (input) virtual register.
                        interference_set);
     } else {
-      ProcessOneOutput(block, current, pos,
+      ProcessOneOutput(block, pos,
                        out, def,
                        def->ssa_temp_index(),
                        false,            // output is not mapped to first input.
                        NULL, NULL, -1,   // First input not needed.
                        interference_set);
     }
   }
 }
 
 
@@ skipping 1098 matching lines @@
        interval = interval->next()) {
     if (interval->Contains(pos)) {
       return true;
     }
   }
 
   return false;
 }
 
 
-void FlowGraphAllocator::AssignSafepoints(LiveRange* range) {
+void FlowGraphAllocator::AssignSafepoints(Definition* defn,
+                                          LiveRange* range) {
   for (intptr_t i = safepoints_.length() - 1; i >= 0; i--) {
-    Instruction* instr = safepoints_[i];
+    Instruction* safepoint_instr = safepoints_[i];
+    if (safepoint_instr == defn) {
+      // The value is not live until after the definition is fully executed,
+      // don't assign the safepoint inside the definition itself to
+      // definition's liverange.
+      continue;
+    }
 
-    const intptr_t pos = instr->lifetime_position();
+    const intptr_t pos = safepoint_instr->lifetime_position();
     if (range->End() <= pos) break;
 
-    if (range->Contains(pos)) range->AddSafepoint(pos, instr->locs());
+    if (range->Contains(pos)) {
+      range->AddSafepoint(pos, safepoint_instr->locs());
+    }
   }
 }
 
 
 static inline bool ShouldBeAllocatedBefore(LiveRange* a, LiveRange* b) {
   // TODO(vegorov): consider first hint position when ordering live ranges.
   return a->Start() <= b->Start();
 }
 
 
@@ skipping 392 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart