Initial implementation of on-stack replacement (OSR).

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 492 matching lines @@
       ConnectIncomingPhiMoves(block->AsJoinEntry());
     } else if (block->IsCatchBlockEntry()) {
       // Process initial definitions.
       CatchBlockEntryInstr* catch_entry = block->AsCatchBlockEntry();
       for (intptr_t i = 0;
            i < catch_entry->initial_definitions()->length();
            i++) {
         Definition* defn = (*catch_entry->initial_definitions())[i];
         LiveRange* range = GetLiveRange(defn->ssa_temp_index());
         range->DefineAt(catch_entry->start_pos());  // Defined at block entry.
-
-        // Save range->End() because it may change in ProcessInitialDefinition.
-        intptr_t range_end = range->End();
         ProcessInitialDefinition(defn, range, catch_entry);
-        spill_slots_.Add(range_end);
-        quad_spill_slots_.Add(false);
-
-        if (defn->IsParameter() && range->spill_slot().stack_index() >= 0) {
-          MarkAsObjectAtSafepoints(range);
-        }
       }
     }
   }
 
   // Process incoming parameters and constants.  Do this after all other
   // instructions so that safepoints for all calls have already been found.
   GraphEntryInstr* graph_entry = flow_graph_.graph_entry();
   for (intptr_t i = 0; i < graph_entry->initial_definitions()->length(); i++) {
     Definition* defn = (*graph_entry->initial_definitions())[i];
     LiveRange* range = GetLiveRange(defn->ssa_temp_index());
     range->AddUseInterval(graph_entry->start_pos(), graph_entry->end_pos());
     range->DefineAt(graph_entry->start_pos());
-
-    // Save range->End() because it may change in ProcessInitialDefinition.
-    intptr_t range_end = range->End();
     ProcessInitialDefinition(defn, range, graph_entry);
-    if (defn->IsParameter() && flow_graph_.num_copied_params() > 0) {
-      spill_slots_.Add(range_end);
-      quad_spill_slots_.Add(false);
-
-      MarkAsObjectAtSafepoints(range);
-    }
   }
 }
 
 
 void FlowGraphAllocator::ProcessInitialDefinition(Definition* defn,
                                                   LiveRange* range,
                                                   BlockEntryInstr* block) {
+  // Save the range end because it may change below.
+  intptr_t range_end = range->End();
   if (defn->IsParameter()) {
     ParameterInstr* param = defn->AsParameter();
     // Assert that copied and non-copied parameters are mutually exclusive.
     // This might change in the future and, if so, the index will be wrong.
     ASSERT((flow_graph_.num_copied_params() == 0) ||
            (flow_graph_.num_non_copied_params() == 0));
     // Slot index for the leftmost copied parameter is 0.
     intptr_t slot_index = param->index();
     // Slot index for the rightmost fixed parameter is -1.
     slot_index -= flow_graph_.num_non_copied_params();
@@ skipping 10 matching lines @@
   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);
+  if (defn->IsParameter() && range->spill_slot().stack_index() >= 0) {

[srdjan, 2013/06/11 17:12:02]

Add parentheses.

[Kevin Millikin (Google), 2013/06/14 10:10:42]

Done.

+    // Parameters above the frame pointer consume spill slots and are marked
+    // in stack maps.
+    spill_slots_.Add(range_end);
+    quad_spill_slots_.Add(false);
+    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 1018 matching lines @@
   if (idx == spill_slots_.length()) {
     // No free spill slot found. Allocate a new one.
     spill_slots_.Add(0);
     quad_spill_slots_.Add(need_quad);
     if (need_quad) {  // Allocate two double stack slots if we need quad slot.
       spill_slots_.Add(0);
       quad_spill_slots_.Add(need_quad);
     }
   }
 
-
   // Set spill slot expiration boundary to the live range's end.
   spill_slots_[idx] = end;
   if (need_quad) {
     ASSERT(quad_spill_slots_[idx] && quad_spill_slots_[idx + 1]);
     idx++;  // Use the higher index it corresponds to the lower stack address.
     spill_slots_[idx] = end;
   } else {
     ASSERT(!quad_spill_slots_[idx]);
   }
 
@@ skipping 960 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart