Subzero: Local variable splitting.

src/IceInst.h

 //===- subzero/src/IceInst.h - High-level instructions ----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 93 matching lines @@
   Variable *getDest() const { return Dest; }
 
   SizeT getSrcSize() const { return Srcs.size(); }
   Operand *getSrc(SizeT I) const {
     assert(I < getSrcSize());
     return Srcs[I];
   }
   void replaceSource(SizeT Index, Operand *Replacement) {
     assert(Index < getSrcSize());
     assert(!isDeleted());
-    assert(LiveRangesEnded == 0);
-    // Invalidates liveness info because the use Srcs[Index] is removed.
     Srcs[Index] = Replacement;
   }
 
   bool isLastUse(const Operand *Src) const;
   void spliceLivenessInfo(Inst *OrigInst, Inst *SpliceAssn);
 
   /// Returns a list of out-edges corresponding to a terminator instruction,
   /// which is the last instruction of the block. The list must not contain
   /// duplicates.
   virtual NodeList getTerminatorEdges() const {
@@ skipping 18 matching lines @@
   /// "var_dest=var_src" assignment where the dest and src are both variables.
   virtual bool isVarAssign() const { return false; }
 
   /// Returns true if the instruction has a possible side effect of changing
   /// memory, in which case a memory load should not be reordered with respect
   /// to this instruction.  It should really be pure virtual, but we can't
   /// because of g++ and llvm::ilist<>, so we implement it as
   /// report_fatal_error().
   virtual bool isMemoryWrite() const;
 
+  /// Returns true if the (target-specific) instruction represents an
+  /// intra-block label, i.e. branch target.  This is meant primarily for
+  /// Cfg::splitLocalVars().
+  virtual bool isLabel() const { return false; }
+  /// If the (target-specific) instruction represents an intra-block branch to
+  /// some Label instruction, return that Label branch target instruction;
+  /// otherwise return nullptr.
+  virtual const Inst *getIntraBlockBranchTarget() const { return nullptr; }
+
   void livenessLightweight(Cfg *Func, LivenessBV &Live);
   /// Calculates liveness for this instruction. Returns true if this instruction
   /// is (tentatively) still live and should be retained, and false if this
   /// instruction is (tentatively) dead and should be deleted. The decision is
   /// tentative until the liveness dataflow algorithm has converged, and then a
   /// separate pass permanently deletes dead instructions.
   bool liveness(InstNumberT InstNumber, LivenessBV &Live, Liveness *Liveness,
                 LiveBeginEndMap *LiveBegin, LiveBeginEndMap *LiveEnd);
 
   /// Get the number of native instructions that this instruction ultimately
@@ skipping 983 matching lines @@
 
 inline Inst *iteratorToInst(InstList::iterator Iter) { return &*Iter; }
 
 inline const Inst *iteratorToInst(InstList::const_iterator Iter) {
   return &*Iter;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINST_H