Use constants from the frame at OSR entry.

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 562 matching lines @@
   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);
   if (defn->IsParameter() && (range->spill_slot().stack_index() >= 0)) {
-    // Parameters above the frame pointer consume spill slots and are marked
-    // in stack maps.
-    spill_slots_.Add(range_end);
-    quad_spill_slots_.Add(false);
+    // Parameters above the frame pointer occupy (allocatable) spill slots
+    // and are marked in stack maps.  There are multiple non-interfering
+    // live ranges occupying the same spill slot (e.g., those for different
+    // catch blocks).  Block the spill slot until the latest such live range
+    // endpoint.
+    intptr_t index = range->spill_slot().stack_index();
+    while (index > (spill_slots_.length() - 1)) {
+      spill_slots_.Add(-1);
+      quad_spill_slots_.Add(false);
+    }
+    spill_slots_[index] = Utils::Maximum(spill_slots_[index], range_end);
+    ASSERT(!quad_spill_slots_[index]);
     MarkAsObjectAtSafepoints(range);
-  } else if (defn->IsConstant() && block->IsCatchBlockEntry()) {
-    // Constants at catch block entries consume spill slots.
-    spill_slots_.Add(range_end);
-    quad_spill_slots_.Add(false);
   }
 }
 
 
 static Location::Kind RegisterKindFromPolicy(Location loc) {
   if (loc.policy() == Location::kRequiresFpuRegister) {
     return Location::kFpuRegister;
   } else {
     return Location::kRegister;
   }
@@ skipping 998 matching lines @@
   // Special care is taken to never allocate the same index to both
   // double and quad spill slots as it complicates disambiguation during
   // parallel move resolution.
   const bool need_quad = (register_kind_ == Location::kFpuRegister) &&
       ((range->representation() == kUnboxedFloat32x4) ||
        (range->representation() == kUnboxedInt32x4));
 
   // Search for a free spill slot among allocated: the value in it should be
   // dead and its type should match (e.g. it should not be a part of the quad if
   // we are allocating normal double slot).
-  // For CPU registers we need to take reserved slots for try-catch into
-  // account.
-  intptr_t idx = register_kind_ == Location::kRegister
-      ? flow_graph_.graph_entry()->fixed_slot_count()
-      : 0;
+  intptr_t idx = 0;
   for (; idx < spill_slots_.length(); idx++) {
     if ((need_quad == quad_spill_slots_[idx]) &&
         (spill_slots_[idx] <= start)) {
       break;
     }
   }
 
   if (idx == spill_slots_.length()) {
     // No free spill slot found. Allocate a new one.
     spill_slots_.Add(0);
@@ skipping 977 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart