Allow deoptimization from states with spilled values.

runtime/vm/flow_graph_allocator.h

 // 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.
 
 #ifndef VM_FLOW_GRAPH_ALLOCATOR_H_
 #define VM_FLOW_GRAPH_ALLOCATOR_H_
 
 #include "vm/growable_array.h"
 #include "vm/intermediate_language.h"
 
@@ skipping 34 matching lines @@
   // for blocks until they stop changing.
   void ComputeLiveInAndLiveOutSets();
 
   // Print results of liveness analysis.
   void DumpLiveness();
 
   // Visit blocks in the code generation order (reverse post order) and
   // linearly assign consequent lifetime positions to every instruction.
   // We assign position as follows:
   //
-  //    2 * n     - even position corresponding to an implicit parallel move
-  //                preceding the instruction;
+  //    2 * n     - even position corresponding to instruction's start;
   //
-  //    2 * n + 1 - odd position corresponding to instruction itself;
+  //    2 * n + 1 - odd position corresponding to instruction's end;
   //
-  // Having positions corresponding to parallel moves between every two
-  // instructions allows us to capture non-trivial shapes of use intervals.
+  // Having two positions per instruction allows us to capture non-trivial
+  // shapes of use intervals: e.g. by placing a use at the start or the
+  // end position we can distinguish between instructions that need value
+  // at the register only at their start and those instructions that
+  // need value in the register until the end of instruction's body.
+  // Register allocator can perform splitting of live ranges at any position.
+  // An implicit ParallelMove will be inserted by ConnectSplitSiblings where
+  // required to resolve data flow between split siblings when allocation
+  // is finished.
   // For specific examples see comments inside ProcessOneInstruction.
   // Additionally creates parallel moves at the joins' predecessors
   // that will be used for phi resolution.
   void NumberInstructions();
   Instruction* InstructionAt(intptr_t pos) const;
   bool IsBlockEntry(intptr_t pos) const;
 
   LiveRange* GetLiveRange(intptr_t vreg);
 
   // Visit instructions in the postorder and build live ranges for
   // all SSA values.
   void BuildLiveRanges();
   Instruction* ConnectOutgoingPhiMoves(BlockEntryInstr* block);
   void ProcessOneInstruction(BlockEntryInstr* block, Instruction* instr);
   void ConnectIncomingPhiMoves(BlockEntryInstr* block);
-  void BlockLocation(Location loc, intptr_t from, intptr_t to);
+  void BlockLocation(Location loc, intptr_t pos);
 
   // Process live ranges sorted by their start and assign registers
   // to them
   void AllocateCPURegisters();
   void AdvanceActiveIntervals(const intptr_t start);
 
   // Connect split siblings over non-linear control flow edges.
   void ResolveControlFlow();
   void ConnectSplitSiblings(LiveRange* range,
                             BlockEntryInstr* source_block,
@@ skipping 290 matching lines @@
 
   AllocationFinger finger_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRange);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_ALLOCATOR_H_