Reverting r85338 for now. It's causing a bootstrap failure on PPC darwin9.

--- Reverse-merging r85338 into '.':
U    lib/CodeGen/SimpleRegisterCoalescing.cpp
U    lib/CodeGen/SimpleRegisterCoalescing.h



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@85454 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/CodeGen/Passes.h

@@ -186,7 +186,7 @@ namespace llvm {
 
   /// createDwarfEHPass - This pass mulches exception handling code into a form
   /// adapted to code generation.  Required if using dwarf exception handling.
-  FunctionPass *createDwarfEHPass(const TargetLowering *tli, bool fast);
+  FunctionPass *createDwarfEHPass(const TargetLowering *tli);
 
   /// createSjLjEHPass - This pass adapts exception handling code to use
   /// the GCC-style builtin setjmp/longjmp (sjlj) to handling EH control flow.

include/llvm/IntrinsicInst.h

@@ -307,6 +307,19 @@ namespace llvm {
     }
   };
 
+  /// EHExceptionInst - This represents the llvm.eh.exception instruction.
+  ///
+  struct EHExceptionInst : public IntrinsicInst {
+    // Methods for support type inquiry through isa, cast, and dyn_cast:
+    static inline bool classof(const EHExceptionInst *) { return true; }
+    static inline bool classof(const IntrinsicInst *I) {
+      return I->getIntrinsicID() == Intrinsic::eh_exception;
+    }
+    static inline bool classof(const Value *V) {
+      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+    }
+  };
+
   /// EHSelectorInst - This represents the llvm.eh.selector instruction.
   ///
   struct EHSelectorInst : public IntrinsicInst {

lib/CodeGen/DwarfEHPrepare.cpp

@@ -21,27 +21,41 @@
 #include "llvm/IntrinsicInst.h"
 #include "llvm/Module.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/IRBuilder.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/PromoteMemToReg.h"
 using namespace llvm;
 
-STATISTIC(NumLandingPadsSplit,     "Number of landing pads split");
-STATISTIC(NumUnwindsLowered,       "Number of unwind instructions lowered");
 STATISTIC(NumExceptionValuesMoved, "Number of eh.exception calls moved");
+STATISTIC(NumLonelyLandingPads,    "Number of landing pads with no selector");
+STATISTIC(NumLonelySelectors,      "Number of lonely selectors lowered");
+STATISTIC(NumLandingPadsSplit,     "Number of landing pads split");
+STATISTIC(NumSelectorsAdjusted,    "Number of selector results adjusted");
+STATISTIC(NumSelectorsSimplified,  "Number of selectors truncated");
 STATISTIC(NumStackTempsIntroduced, "Number of stack temporaries introduced");
+STATISTIC(NumUnwindsLowered,       "Number of unwind instructions lowered");
 
 namespace {
   class DwarfEHPrepare : public FunctionPass {
     const TargetLowering *TLI;
-    bool CompileFast;
 
     // The eh.exception intrinsic.
-    Function *ExceptionValueIntrinsic;
+    Function *ExceptionIntrinsic;
+
+    // The eh.selector intrinsic.
+    Function *SelectorIntrinsic;
+
+    // The eh.typeid.for intrinsic.
+    Function *TypeIdIntrinsic;
 
     // _Unwind_Resume or the target equivalent.
     Constant *RewindFunction;
 
+    // _Unwind_RaiseException.
+    Constant *UnwindFunction;
+
     // Dominator info is used when turning stack temporaries into registers.
     DominatorTree *DT;
     DominanceFrontier *DF;
@@ -49,6 +63,13 @@ namespace {
     // The function we are running on.
     Function *F;
 
+    // The current context.
+    LLVMContext *Context;
+
+    // The personality and catch-all value for this function.
+    Constant *Personality;
+    Constant *CatchAll;
+
     // The landing pads for this function.
     typedef SmallPtrSet<BasicBlock*, 8> BBSet;
     BBSet LandingPads;
@@ -58,7 +79,10 @@ namespace {
 
     bool NormalizeLandingPads();
     bool LowerUnwinds();
+    bool MoveSelectorCalls();
+    bool RectifySelectorCalls();
     bool MoveExceptionValueCalls();
+    bool AddMissingSelectors();
     bool FinishStackTemporaries();
     bool PromoteStackTemporaries();
 
@@ -75,22 +99,13 @@ namespace {
 
   public:
     static char ID; // Pass identification, replacement for typeid.
-    DwarfEHPrepare(const TargetLowering *tli, bool fast) :
-      FunctionPass(&ID), TLI(tli), CompileFast(fast),
-      ExceptionValueIntrinsic(0), RewindFunction(0) {}
+    DwarfEHPrepare(const TargetLowering *tli) :
+      FunctionPass(&ID), TLI(tli), ExceptionIntrinsic(0),
+      SelectorIntrinsic(0), TypeIdIntrinsic(0), RewindFunction(0),
+      UnwindFunction(0) {}
 
     virtual bool runOnFunction(Function &Fn);
 
-    // getAnalysisUsage - We need dominance frontiers for memory promotion.
-    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-      if (!CompileFast)
-        AU.addRequired<DominatorTree>();
-      AU.addPreserved<DominatorTree>();
-      if (!CompileFast)
-        AU.addRequired<DominanceFrontier>();
-      AU.addPreserved<DominanceFrontier>();
-    }
-
     const char *getPassName() const {
       return "Exception handling preparation";
     }
@@ -100,8 +115,8 @@ namespace {
 
 char DwarfEHPrepare::ID = 0;
 
-FunctionPass *llvm::createDwarfEHPass(const TargetLowering *tli, bool fast) {
-  return new DwarfEHPrepare(tli, fast);
+FunctionPass *llvm::createDwarfEHPass(const TargetLowering *tli) {
+  return new DwarfEHPrepare(tli);
 }
 
 /// NormalizeLandingPads - Normalize and discover landing pads, noting them
@@ -144,7 +159,7 @@ bool DwarfEHPrepare::NormalizeLandingPads() {
     // edges to a new basic block which falls through into this one.
 
     // Create the new basic block.
-    BasicBlock *NewBB = BasicBlock::Create(F->getContext(),
+    BasicBlock *NewBB = BasicBlock::Create(*Context,
                                            LPad->getName() + "_unwind_edge");
 
     // Insert it into the function right before the original landing pad.
@@ -233,17 +248,14 @@ bool DwarfEHPrepare::LowerUnwinds() {
 
   // Find the rewind function if we didn't already.
   if (!RewindFunction) {
-    LLVMContext &Ctx = UnwindInsts[0]->getContext();
     std::vector<const Type*>
-      Params(1, Type::getInt8PtrTy(Ctx));
-    FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
+      Params(1, Type::getInt8PtrTy(*Context));
+    FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Context),
                                           Params, false);
     const char *RewindName = TLI->getLibcallName(RTLIB::UNWIND_RESUME);
     RewindFunction = F->getParent()->getOrInsertFunction(RewindName, FTy);
   }
 
-  bool Changed = false;
-
   for (SmallVectorImpl<TerminatorInst*>::iterator
          I = UnwindInsts.begin(), E = UnwindInsts.end(); I != E; ++I) {
     TerminatorInst *TI = *I;
@@ -257,11 +269,244 @@ bool DwarfEHPrepare::LowerUnwinds() {
                                     "", TI);
     CI->setCallingConv(TLI->getLibcallCallingConv(RTLIB::UNWIND_RESUME));
     // ...followed by an UnreachableInst.
-    new UnreachableInst(TI->getContext(), TI);
+    new UnreachableInst(*Context, TI);
 
     // Nuke the unwind instruction.
     TI->eraseFromParent();
     ++NumUnwindsLowered;
+  }
+
+  return true;
+}
+
+/// MoveSelectorCalls - Make sure that every call to eh.selector occurs in its
+/// own landing pad, the landing pad corresponding to the exception object.
+bool DwarfEHPrepare::MoveSelectorCalls() {
+  // If the eh.selector intrinsic is not declared in the module then there is
+  // nothing to do.  Speed up compilation by checking for this common case.
+  if (!F->getParent()->getFunction(Intrinsic::getName(Intrinsic::eh_selector)))
+    return false;
+
+  // TODO: There is a lot of room for optimization here.
+
+  bool Changed = false;
+  BasicBlock *UnrBB = 0;
+
+  for (Function::iterator BB = F->begin(); BB != F->end(); ++BB) {
+    // If this basic block is not a landing pad then synthesize a landing pad
+    // for every selector in it.
+    bool SynthesizeLandingPad = !LandingPads.count(BB);
+
+    for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE; ++II) {
+      EHSelectorInst *SI = dyn_cast<EHSelectorInst>(II);
+      // Only interested in eh.selector calls.
+      if (!SI)
+        continue;
+
+      // Note the personality and catch-all for later use.
+      Personality = cast<Constant>(SI->getOperand(2));
+      CatchAll = cast<Constant>(SI->getOperand(SI->getNumOperands() - 1)
+                                ->stripPointerCasts());
+
+      // The exception object.
+      Value *Exception = SI->getOperand(1);
+
+      if (!SynthesizeLandingPad) {
+        // Did the exception come from unwinding to this landing pad or another?
+        // If it comes from a different landing pad then we need to synthesize a
+        // new landing pad for the selector.
+        EHExceptionInst *EI = dyn_cast<EHExceptionInst>(Exception);
+        SynthesizeLandingPad = !EI || EI->getParent() != BB;
+      }
+
+      if (!SynthesizeLandingPad) {
+        // This is the first selector in this landing pad, and it is the landing
+        // pad corresponding to the exception object.  No need to do anything to
+        // this selector, but any subsequent selectors in this landing pad will
+        // need their own invoke in order to make them independent of this one.
+        SynthesizeLandingPad = true;
+        continue;
+      }
+
+      // Rethrow the exception and catch it again, generating a landing pad for
+      // this selector to live in.
+
+      // Find _Unwind_RaiseException if we didn't already.
+      if (!UnwindFunction) {
+        std::vector<const Type*> ArgTys(1, Type::getInt8PtrTy(*Context));
+        const FunctionType *FTy =
+          FunctionType::get(Type::getInt32Ty(*Context), ArgTys, true);
+
+        const char *Name = "_Unwind_RaiseException";
+        UnwindFunction = F->getParent()->getOrInsertFunction(Name, FTy);
+      }
+
+      // Create a basic block containing only an unreachable instruction if we
+      // didn't already.
+      if (!UnrBB) {
+        UnrBB = BasicBlock::Create(*Context, "unreachable", F);
+        new UnreachableInst(*Context, UnrBB);
+      }
+
+      // Split the basic block before the selector.
+      BasicBlock *NewBB = SplitBlock(BB, SI, this);
+
+      // Replace the terminator with an invoke of _Unwind_RaiseException.
+      BB->getTerminator()->eraseFromParent();
+      InvokeInst::Create(UnwindFunction, UnrBB, NewBB, &Exception,
+                         1 + &Exception, "", BB);
+
+      // The split off basic block is now a landing pad.
+      LandingPads.insert(NewBB);
+
+      // Replace the exception argument in the selector call with a call to
+      // eh.exception.  This is not really necessary but it makes things more
+      // regular.
+      Exception = CreateExceptionValueCall(NewBB);
+      SI->setOperand(1, Exception);
+
+      ++NumLonelySelectors;
+      Changed = true;
+
+      // All instructions still in the original basic block have been scanned.
+      // Move on to the next basic block.
+      break;
+    }
+  }
+
+  return Changed;
+}
+
+/// RectifySelectorCalls - Remove useless catch-all clauses from the ends of
+/// selectors, or correct the selector result for the presence of the catch-all
+/// if it is really needed.
+bool DwarfEHPrepare::RectifySelectorCalls() {
+  // If the eh.selector intrinsic is not declared in the module then there is
+  // nothing to do.  Speed up compilation by checking for this common case.
+  if (!F->getParent()->getFunction(Intrinsic::getName(Intrinsic::eh_selector)))
+    return false;
+
+  bool Changed = false;
+
+  for (BBSet::iterator I = LandingPads.begin(), E = LandingPads.end(); I != E;
+       ++I)
+    for (BasicBlock::iterator II = (*I)->begin(), IE = (*I)->end(); II != IE; )
+      if (EHSelectorInst *SI = dyn_cast<EHSelectorInst>(II++)) {
+        // Found a call to eh.selector.  Check whether it has a catch-all in the
+        // middle.
+        unsigned LastIndex = 0;
+        for (unsigned i = 3, e = SI->getNumOperands() - 1; i < e; ++i) {
+          Value *V = SI->getOperand(i);
+          if (V->stripPointerCasts() == CatchAll) {
+            // A catch-all.  The catch-all at the end was not needed.
+            LastIndex = i;
+            break;
+          } else if (ConstantInt *FilterLength = dyn_cast<ConstantInt>(V)) {
+            // A cleanup or a filter.
+            unsigned Length = FilterLength->getZExtValue();
+            if (Length == 0)
+              // A cleanup - skip it.
+              continue;
+            if (Length == 1) {
+              // A catch-all filter.  Drop everything that follows.
+              LastIndex = i;
+              break;
+            }
+            // A filter, skip over the typeinfos.
+            i += Length - 1;
+          }
+        }
+
+        if (LastIndex) {
+          // Drop the pointless catch-all from the end.  In fact drop everything
+          // after LastIndex as an optimization.
+          SmallVector<Value*, 16> Args;
+          Args.reserve(LastIndex);
+          for (unsigned i = 1; i <= LastIndex; ++i)
+            Args.push_back(SI->getOperand(i));
+          CallInst *CI = CallInst::Create(SI->getOperand(0), Args.begin(),
+                                          Args.end(), "", SI);
+          CI->takeName(SI);
+          SI->replaceAllUsesWith(CI);
+          SI->eraseFromParent();
+          ++NumSelectorsSimplified;
+        } else if (!isa<ConstantInt>(CatchAll) && // Not a cleanup.
+                   !SI->use_empty()) {
+          // Correct the selector value to return zero if the catch-all matches.
+          Constant *Zero = ConstantInt::getNullValue(Type::getInt32Ty(*Context));
+
+          // Create the new selector value, with placeholders instead of the
+          // real operands and make everyone use it.  The reason for this round
+          // about approach is that the computation of the new value makes use
+          // of the old value, so we can't just compute it then do RAUW.
+          SelectInst *S = SelectInst::Create(ConstantInt::getFalse(*Context),
+                                             Zero, Zero, "", II);
+          SI->replaceAllUsesWith(S);
+
+          // Now calculate the operands of the select.
+          IRBuilder<> Builder(*I, S);
+
+          // Find the eh.typeid.for intrinsic if we didn't already.
+          if (!TypeIdIntrinsic)
+            TypeIdIntrinsic = Intrinsic::getDeclaration(F->getParent(),
+                                                      Intrinsic::eh_typeid_for);
+
+          // Obtain the id of the catch-all.
+          Value *CatchAllId = Builder.CreateCall(TypeIdIntrinsic,
+              ConstantExpr::getBitCast(CatchAll, Type::getInt8PtrTy(*Context)));
+
+          // Compare it with the original selector result.  If it matched then
+          // the selector result is zero, otherwise it is the original selector.
+          Value *MatchesCatchAll = Builder.CreateICmpEQ(SI, CatchAllId);
+          S->setOperand(0, MatchesCatchAll);
+          S->setOperand(2, SI);
+          ++NumSelectorsAdjusted;
+        }
+
+        Changed = true;
+        break;
+      }
+
+  return Changed;
+}
+
+/// Make sure every landing pad has a selector in it.
+bool DwarfEHPrepare::AddMissingSelectors() {
+  if (!Personality)
+    // We only know how to codegen invokes if there is a personality.
+    // FIXME: This results in wrong code.
+    return false;
+
+  bool Changed = false;
+
+  for (BBSet::iterator I = LandingPads.begin(), E = LandingPads.end(); I != E;
+       ++I) {
+    bool FoundSelector = false;
+
+    // Check whether the landing pad already contains a call to eh.selector.
+    for (BasicBlock::iterator II = (*I)->begin(), IE = (*I)->end(); II != IE;
+         ++II)
+      if (isa<EHSelectorInst>(II)) {
+        FoundSelector = true;
+        break;
+      }
+
+    if (FoundSelector)
+      continue;
+
+    // Find the eh.selector intrinsic if we didn't already.
+    if (!SelectorIntrinsic)
+      SelectorIntrinsic = Intrinsic::getDeclaration(F->getParent(),
+                                                    Intrinsic::eh_selector);
+
+    // Get the exception object.
+    Instruction *Exception = CreateExceptionValueCall(*I);
+
+    Value *Args[3] = { Exception, Personality, CatchAll };
+    CallInst *Selector = CallInst::Create(SelectorIntrinsic, Args, Args + 3);
+    Selector->insertAfter(Exception);
+
+    ++NumLonelyLandingPads;
     Changed = true;
   }
 
@@ -275,7 +520,7 @@ bool DwarfEHPrepare::LowerUnwinds() {
 bool DwarfEHPrepare::MoveExceptionValueCalls() {
   // If the eh.exception intrinsic is not declared in the module then there is
   // nothing to do.  Speed up compilation by checking for this common case.
-  if (!ExceptionValueIntrinsic &&
+  if (!ExceptionIntrinsic &&
       !F->getParent()->getFunction(Intrinsic::getName(Intrinsic::eh_exception)))
     return false;
 
@@ -332,7 +577,7 @@ bool DwarfEHPrepare::PromoteStackTemporaries() {
   if (ExceptionValueVar && DT && DF && isAllocaPromotable(ExceptionValueVar)) {
     // Turn the exception temporary into registers and phi nodes if possible.
     std::vector<AllocaInst*> Allocas(1, ExceptionValueVar);
-    PromoteMemToReg(Allocas, *DT, *DF, ExceptionValueVar->getContext());
+    PromoteMemToReg(Allocas, *DT, *DF, *Context);
     return true;
   }
   return false;
@@ -350,12 +595,12 @@ Instruction *DwarfEHPrepare::CreateExceptionValueCall(BasicBlock *BB) {
       return Start;
 
   // Find the eh.exception intrinsic if we didn't already.
-  if (!ExceptionValueIntrinsic)
-    ExceptionValueIntrinsic = Intrinsic::getDeclaration(F->getParent(),
+  if (!ExceptionIntrinsic)
+    ExceptionIntrinsic = Intrinsic::getDeclaration(F->getParent(),
                                                        Intrinsic::eh_exception);
 
   // Create the call.
-  return CallInst::Create(ExceptionValueIntrinsic, "eh.value.call", Start);
+  return CallInst::Create(ExceptionIntrinsic, "eh.value.call", Start);
 }
 
 /// CreateValueLoad - Insert a load of the exception value stack variable
@@ -373,7 +618,7 @@ Instruction *DwarfEHPrepare::CreateValueLoad(BasicBlock *BB) {
   // Create the temporary if we didn't already.
   if (!ExceptionValueVar) {
     ExceptionValueVar = new AllocaInst(PointerType::getUnqual(
-           Type::getInt8Ty(BB->getContext())), "eh.value", F->begin()->begin());
+           Type::getInt8Ty(*Context)), "eh.value", F->begin()->begin());
     ++NumStackTempsIntroduced;
   }
 
@@ -388,6 +633,9 @@ bool DwarfEHPrepare::runOnFunction(Function &Fn) {
   DT = getAnalysisIfAvailable<DominatorTree>();
   DF = getAnalysisIfAvailable<DominanceFrontier>();
   ExceptionValueVar = 0;
+  Personality = 0;
+  CatchAll = 0;
+  Context = &Fn.getContext();
   F = &Fn;
 
   // Ensure that only unwind edges end at landing pads (a landing pad is a
@@ -397,7 +645,15 @@ bool DwarfEHPrepare::runOnFunction(Function &Fn) {
   // Turn unwind instructions into libcalls.
   Changed |= LowerUnwinds();
 
-  // TODO: Move eh.selector calls to landing pads and combine them.
+  // Make sure that every call to eh.selector occurs in its own landing pad.
+  Changed |= MoveSelectorCalls();
+
+  // Remove useless catch-all clauses from the ends of selectors, or correct the
+  // selector result for the presence of the catch-all if it is really needed.
+  Changed |= RectifySelectorCalls();
+
+  // Make sure every landing pad has a selector in it.
+  Changed |= AddMissingSelectors();
 
   // Move eh.exception calls to landing pads.
   Changed |= MoveExceptionValueCalls();
@@ -406,8 +662,8 @@ bool DwarfEHPrepare::runOnFunction(Function &Fn) {
   Changed |= FinishStackTemporaries();
 
   // Turn any stack temporaries into registers if possible.
-  if (!CompileFast)
-    Changed |= PromoteStackTemporaries();
+//TODO  if (!CompileFast)
+//TODO    Changed |= PromoteStackTemporaries();
 
   LandingPads.clear();
 

lib/CodeGen/LLVMTargetMachine.cpp

@@ -239,11 +239,11 @@ bool LLVMTargetMachine::addCommonCodeGenPasses(PassManagerBase &PM,
   {
   case ExceptionHandling::SjLj:
     // SjLj piggy-backs on dwarf for this bit. The cleanups done apply to both
-    PM.add(createDwarfEHPass(getTargetLowering(), OptLevel==CodeGenOpt::None));
+    PM.add(createDwarfEHPass(getTargetLowering()));
     PM.add(createSjLjEHPass(getTargetLowering()));
     break;
   case ExceptionHandling::Dwarf:
-    PM.add(createDwarfEHPass(getTargetLowering(), OptLevel==CodeGenOpt::None));
+    PM.add(createDwarfEHPass(getTargetLowering()));
     break;
   case ExceptionHandling::None:
     PM.add(createLowerInvokePass(getTargetLowering()));

lib/CodeGen/SimpleRegisterCoalescing.cpp

@@ -1861,21 +1861,6 @@ bool SimpleRegisterCoalescing::RangeIsDefinedByCopyFromReg(LiveInterval &li,
   return false;
 }
 
-
-/// ValueLiveAt - Return true if the LiveRange pointed to by the given
-/// iterator, or any subsequent range with the same value number,
-/// is live at the given point.
-bool SimpleRegisterCoalescing::ValueLiveAt(LiveInterval::iterator LRItr,
-                                           LiveIndex defPoint) const {
-  for (const VNInfo *valno = LRItr->valno; LRItr->valno == valno; ++LRItr) {
-    if (LRItr->contains(defPoint))
-      return true;
-  }
-
-  return false;
-}
-
-
 /// SimpleJoin - Attempt to joint the specified interval into this one. The
 /// caller of this method must guarantee that the RHS only contains a single
 /// value number and that the RHS is not defined by a copy from this
@@ -1922,7 +1907,7 @@ bool SimpleRegisterCoalescing::SimpleJoin(LiveInterval &LHS, LiveInterval &RHS){
         if (!RangeIsDefinedByCopyFromReg(LHS, LHSIt, RHS.reg))
           return false;    // Nope, bail out.
 
-        if (ValueLiveAt(LHSIt, RHSIt->valno->def))
+        if (LHSIt->contains(RHSIt->valno->def))
           // Here is an interesting situation:
           // BB1:
           //   vr1025 = copy vr1024
@@ -1960,7 +1945,7 @@ bool SimpleRegisterCoalescing::SimpleJoin(LiveInterval &LHS, LiveInterval &RHS){
           // Otherwise, if this is a copy from the RHS, mark it as being merged
           // in.
           if (RangeIsDefinedByCopyFromReg(LHS, LHSIt, RHS.reg)) {
-            if (ValueLiveAt(LHSIt, RHSIt->valno->def))
+            if (LHSIt->contains(RHSIt->valno->def))
               // Here is an interesting situation:
               // BB1:
               //   vr1025 = copy vr1024

lib/CodeGen/SimpleRegisterCoalescing.h

@@ -201,11 +201,6 @@ namespace llvm {
     bool CanJoinInsertSubRegToPhysReg(unsigned DstReg, unsigned SrcReg,
                                       unsigned SubIdx, unsigned &RealDstReg);
 
-    /// ValueLiveAt - Return true if the LiveRange pointed to by the given
-    /// iterator, or any subsequent range with the same value number,
-    /// is live at the given point.
-    bool ValueLiveAt(LiveInterval::iterator LRItr, LiveIndex defPoint) const;
-
     /// RangeIsDefinedByCopyFromReg - Return true if the specified live range of
     /// the specified live interval is defined by a copy from the specified
     /// register.