[llvm-commits] [llvm] r85454 - in /llvm/trunk: include/llvm/CodeGen/Passes.h include/llvm/IntrinsicInst.h lib/CodeGen/DwarfEHPrepare.cpp lib/CodeGen/LLVMTargetMachine.cpp lib/CodeGen/SimpleRegisterCoalescing.cpp lib/CodeGen/SimpleRegisterCoalescing.h
Bill Wendling
isanbard at gmail.com
Wed Oct 28 17:22:16 PDT 2009
Author: void
Date: Wed Oct 28 19:22:16 2009
New Revision: 85454
URL: http://llvm.org/viewvc/llvm-project?rev=85454&view=rev
Log:
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
Modified:
llvm/trunk/include/llvm/CodeGen/Passes.h
llvm/trunk/include/llvm/IntrinsicInst.h
llvm/trunk/lib/CodeGen/DwarfEHPrepare.cpp
llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp
llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.cpp
llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.h
Modified: llvm/trunk/include/llvm/CodeGen/Passes.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/Passes.h?rev=85454&r1=85453&r2=85454&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/Passes.h (original)
+++ llvm/trunk/include/llvm/CodeGen/Passes.h Wed Oct 28 19:22:16 2009
@@ -186,7 +186,7 @@
/// 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.
Modified: llvm/trunk/include/llvm/IntrinsicInst.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IntrinsicInst.h?rev=85454&r1=85453&r2=85454&view=diff
==============================================================================
--- llvm/trunk/include/llvm/IntrinsicInst.h (original)
+++ llvm/trunk/include/llvm/IntrinsicInst.h Wed Oct 28 19:22:16 2009
@@ -307,6 +307,19 @@
}
};
+ /// 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 {
Modified: llvm/trunk/lib/CodeGen/DwarfEHPrepare.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/DwarfEHPrepare.cpp?rev=85454&r1=85453&r2=85454&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/DwarfEHPrepare.cpp (original)
+++ llvm/trunk/lib/CodeGen/DwarfEHPrepare.cpp Wed Oct 28 19:22:16 2009
@@ -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 @@
// 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 @@
bool NormalizeLandingPads();
bool LowerUnwinds();
+ bool MoveSelectorCalls();
+ bool RectifySelectorCalls();
bool MoveExceptionValueCalls();
+ bool AddMissingSelectors();
bool FinishStackTemporaries();
bool PromoteStackTemporaries();
@@ -75,22 +99,13 @@
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 @@
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 @@
// 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 @@
// 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 @@
"", 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::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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
Changed |= FinishStackTemporaries();
// Turn any stack temporaries into registers if possible.
- if (!CompileFast)
- Changed |= PromoteStackTemporaries();
+//TODO if (!CompileFast)
+//TODO Changed |= PromoteStackTemporaries();
LandingPads.clear();
Modified: llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp?rev=85454&r1=85453&r2=85454&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp (original)
+++ llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp Wed Oct 28 19:22:16 2009
@@ -239,11 +239,11 @@
{
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()));
Modified: llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.cpp?rev=85454&r1=85453&r2=85454&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.cpp (original)
+++ llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.cpp Wed Oct 28 19:22:16 2009
@@ -1861,21 +1861,6 @@
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 @@
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 @@
// 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
Modified: llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.h?rev=85454&r1=85453&r2=85454&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.h (original)
+++ llvm/trunk/lib/CodeGen/SimpleRegisterCoalescing.h Wed Oct 28 19:22:16 2009
@@ -201,11 +201,6 @@
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.
More information about the llvm-commits
mailing list