Make CTX allocatable by the register allocator.

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 88 matching lines @@
   }
 
   // All registers are marked as "not blocked" (array initialized to false).
   // Mark the unavailable ones as "blocked" (true).
   for (intptr_t i = 0; i < kFirstFreeCpuRegister; i++) {
     blocked_cpu_registers_[i] = true;
   }
   for (intptr_t i = kLastFreeCpuRegister + 1; i < kNumberOfCpuRegisters; i++) {
     blocked_cpu_registers_[i] = true;
   }
-  blocked_cpu_registers_[CTX] = true;
   if (TMP != kNoRegister) {
     blocked_cpu_registers_[TMP] = true;
   }
   if (TMP2 != kNoRegister) {
     blocked_cpu_registers_[TMP2] = true;
   }
   if (PP != kNoRegister) {
     blocked_cpu_registers_[PP] = true;
   }
   blocked_cpu_registers_[SPREG] = true;
   blocked_cpu_registers_[FPREG] = true;
 
   // FpuTMP is used as scratch by optimized code and parallel move resolver.
   blocked_fpu_registers_[FpuTMP] = true;
 
   // Block additional registers needed preserved when generating intrinsics.
   // TODO(fschneider): Handle saving and restoring these registers when
   // generating intrinsic code.
   if (intrinsic_mode) {
     blocked_cpu_registers_[ARGS_DESC_REG] = true;
+    blocked_cpu_registers_[CTX] = true;
   }
 }
 
 
 static void DeepLiveness(MaterializeObjectInstr* mat, BitVector* live_in) {
   if (mat->was_visited_for_liveness()) {
     return;
   }
   mat->mark_visited_for_liveness();
 
@@ skipping 514 matching lines @@
     if (param->base_reg() == FPREG) {
       // Slot index for the leftmost copied parameter is 0.
       // Slot index for the rightmost fixed parameter is -1.
       slot_index -= flow_graph_.num_non_copied_params();
     }
 
     range->set_assigned_location(Location::StackSlot(slot_index,
                                                      param->base_reg()));
     range->set_spill_slot(Location::StackSlot(slot_index,
                                               param->base_reg()));
+  } else if (defn->IsCurrentContext()) {
+    AssignSafepoints(defn, range);
+    range->finger()->Initialize(range);
+    range->set_assigned_location(Location::RegisterLocation(CTX));
+    if (range->End() > kNormalEntryPos) {
+      LiveRange* tail = range->SplitAt(kNormalEntryPos);
+      CompleteRange(tail, Location::kRegister);
+    }
+    ConvertAllUses(range);
+    return;
   } else {
     ConstantInstr* constant = defn->AsConstant();
     ASSERT(constant != NULL);
     range->set_assigned_location(Location::Constant(constant));
     range->set_spill_slot(Location::Constant(constant));
   }
   AssignSafepoints(defn, range);
   range->finger()->Initialize(range);
   UsePosition* use =
       range->finger()->FirstRegisterBeneficialUse(block->start_pos());
@@ skipping 1753 matching lines @@
 
   return true;
 }
 
 
 MoveOperands* FlowGraphAllocator::AddMoveAt(intptr_t pos,
                                             Location to,
                                             Location from) {
   ASSERT(!IsBlockEntry(pos));
 
+  if (pos < kNormalEntryPos) {
+    ASSERT(pos > 0);
+    // Parallel moves added to the GraphEntry (B0) will be added at the start
+    // of the normal entry (B1)
+    BlockEntryInstr* entry = InstructionAt(kNormalEntryPos)->AsBlockEntry();
+    return entry->GetParallelMove()->AddMove(to, from);
+  }
+
   Instruction* instr = InstructionAt(pos);
 
   ParallelMoveInstr* parallel_move = NULL;
   if (IsInstructionStartPosition(pos)) {
     parallel_move = CreateParallelMoveBefore(instr, pos);
   } else {
     parallel_move = CreateParallelMoveAfter(instr, pos);
   }
 
   return parallel_move->AddMove(to, from);
@@ skipping 508 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart