diff options
Diffstat (limited to 'llvm/lib/Analysis')
-rw-r--r-- | llvm/lib/Analysis/AliasAnalysis.cpp | 153 | ||||
-rw-r--r-- | llvm/lib/Analysis/AliasAnalysisEvaluator.cpp | 69 | ||||
-rw-r--r-- | llvm/lib/Analysis/AliasSetTracker.cpp | 78 | ||||
-rw-r--r-- | llvm/lib/Analysis/BasicAliasAnalysis.cpp | 110 | ||||
-rw-r--r-- | llvm/lib/Analysis/CaptureTracking.cpp | 21 | ||||
-rw-r--r-- | llvm/lib/Analysis/GlobalsModRef.cpp | 40 | ||||
-rw-r--r-- | llvm/lib/Analysis/Loads.cpp | 4 | ||||
-rw-r--r-- | llvm/lib/Analysis/MemDepPrinter.cpp | 5 | ||||
-rw-r--r-- | llvm/lib/Analysis/MemoryDependenceAnalysis.cpp | 47 | ||||
-rw-r--r-- | llvm/lib/Analysis/MemoryLocation.cpp | 17 | ||||
-rw-r--r-- | llvm/lib/Analysis/MemorySSA.cpp | 36 | ||||
-rw-r--r-- | llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp | 8 | ||||
-rw-r--r-- | llvm/lib/Analysis/ScopedNoAliasAA.cpp | 33 | ||||
-rw-r--r-- | llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp | 31 | ||||
-rw-r--r-- | llvm/lib/Analysis/ValueTracking.cpp | 28 |
15 files changed, 337 insertions, 343 deletions
diff --git a/llvm/lib/Analysis/AliasAnalysis.cpp b/llvm/lib/Analysis/AliasAnalysis.cpp index 8ed48390818..3446aef3993 100644 --- a/llvm/lib/Analysis/AliasAnalysis.cpp +++ b/llvm/lib/Analysis/AliasAnalysis.cpp @@ -40,7 +40,6 @@ #include "llvm/IR/Argument.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/BasicBlock.h" -#include "llvm/IR/CallSite.h" #include "llvm/IR/Instruction.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/Module.h" @@ -118,11 +117,11 @@ bool AAResults::pointsToConstantMemory(const MemoryLocation &Loc, return false; } -ModRefInfo AAResults::getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) { +ModRefInfo AAResults::getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) { ModRefInfo Result = ModRefInfo::ModRef; for (const auto &AA : AAs) { - Result = intersectModRef(Result, AA->getArgModRefInfo(CS, ArgIdx)); + Result = intersectModRef(Result, AA->getArgModRefInfo(Call, ArgIdx)); // Early-exit the moment we reach the bottom of the lattice. if (isNoModRef(Result)) @@ -132,11 +131,11 @@ ModRefInfo AAResults::getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) { return Result; } -ModRefInfo AAResults::getModRefInfo(Instruction *I, ImmutableCallSite Call) { +ModRefInfo AAResults::getModRefInfo(Instruction *I, const CallBase *Call2) { // We may have two calls. - if (auto CS = ImmutableCallSite(I)) { + if (const auto *Call1 = dyn_cast<CallBase>(I)) { // Check if the two calls modify the same memory. - return getModRefInfo(CS, Call); + return getModRefInfo(Call1, Call2); } else if (I->isFenceLike()) { // If this is a fence, just return ModRef. return ModRefInfo::ModRef; @@ -146,19 +145,19 @@ ModRefInfo AAResults::getModRefInfo(Instruction *I, ImmutableCallSite Call) { // is that if the call references what this instruction // defines, it must be clobbered by this location. const MemoryLocation DefLoc = MemoryLocation::get(I); - ModRefInfo MR = getModRefInfo(Call, DefLoc); + ModRefInfo MR = getModRefInfo(Call2, DefLoc); if (isModOrRefSet(MR)) return setModAndRef(MR); } return ModRefInfo::NoModRef; } -ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS, +ModRefInfo AAResults::getModRefInfo(const CallBase *Call, const MemoryLocation &Loc) { ModRefInfo Result = ModRefInfo::ModRef; for (const auto &AA : AAs) { - Result = intersectModRef(Result, AA->getModRefInfo(CS, Loc)); + Result = intersectModRef(Result, AA->getModRefInfo(Call, Loc)); // Early-exit the moment we reach the bottom of the lattice. if (isNoModRef(Result)) @@ -167,7 +166,7 @@ ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS, // Try to refine the mod-ref info further using other API entry points to the // aggregate set of AA results. - auto MRB = getModRefBehavior(CS); + auto MRB = getModRefBehavior(Call); if (MRB == FMRB_DoesNotAccessMemory || MRB == FMRB_OnlyAccessesInaccessibleMem) return ModRefInfo::NoModRef; @@ -181,15 +180,16 @@ ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS, bool IsMustAlias = true; ModRefInfo AllArgsMask = ModRefInfo::NoModRef; if (doesAccessArgPointees(MRB)) { - for (auto AI = CS.arg_begin(), AE = CS.arg_end(); AI != AE; ++AI) { + for (auto AI = Call->arg_begin(), AE = Call->arg_end(); AI != AE; ++AI) { const Value *Arg = *AI; if (!Arg->getType()->isPointerTy()) continue; - unsigned ArgIdx = std::distance(CS.arg_begin(), AI); - MemoryLocation ArgLoc = MemoryLocation::getForArgument(CS, ArgIdx, TLI); + unsigned ArgIdx = std::distance(Call->arg_begin(), AI); + MemoryLocation ArgLoc = + MemoryLocation::getForArgument(Call, ArgIdx, TLI); AliasResult ArgAlias = alias(ArgLoc, Loc); if (ArgAlias != NoAlias) { - ModRefInfo ArgMask = getArgModRefInfo(CS, ArgIdx); + ModRefInfo ArgMask = getArgModRefInfo(Call, ArgIdx); AllArgsMask = unionModRef(AllArgsMask, ArgMask); } // Conservatively clear IsMustAlias unless only MustAlias is found. @@ -213,12 +213,12 @@ ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS, return Result; } -ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS1, - ImmutableCallSite CS2) { +ModRefInfo AAResults::getModRefInfo(const CallBase *Call1, + const CallBase *Call2) { ModRefInfo Result = ModRefInfo::ModRef; for (const auto &AA : AAs) { - Result = intersectModRef(Result, AA->getModRefInfo(CS1, CS2)); + Result = intersectModRef(Result, AA->getModRefInfo(Call1, Call2)); // Early-exit the moment we reach the bottom of the lattice. if (isNoModRef(Result)) @@ -228,59 +228,61 @@ ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS1, // Try to refine the mod-ref info further using other API entry points to the // aggregate set of AA results. - // If CS1 or CS2 are readnone, they don't interact. - auto CS1B = getModRefBehavior(CS1); - if (CS1B == FMRB_DoesNotAccessMemory) + // If Call1 or Call2 are readnone, they don't interact. + auto Call1B = getModRefBehavior(Call1); + if (Call1B == FMRB_DoesNotAccessMemory) return ModRefInfo::NoModRef; - auto CS2B = getModRefBehavior(CS2); - if (CS2B == FMRB_DoesNotAccessMemory) + auto Call2B = getModRefBehavior(Call2); + if (Call2B == FMRB_DoesNotAccessMemory) return ModRefInfo::NoModRef; // If they both only read from memory, there is no dependence. - if (onlyReadsMemory(CS1B) && onlyReadsMemory(CS2B)) + if (onlyReadsMemory(Call1B) && onlyReadsMemory(Call2B)) return ModRefInfo::NoModRef; - // If CS1 only reads memory, the only dependence on CS2 can be - // from CS1 reading memory written by CS2. - if (onlyReadsMemory(CS1B)) + // If Call1 only reads memory, the only dependence on Call2 can be + // from Call1 reading memory written by Call2. + if (onlyReadsMemory(Call1B)) Result = clearMod(Result); - else if (doesNotReadMemory(CS1B)) + else if (doesNotReadMemory(Call1B)) Result = clearRef(Result); - // If CS2 only access memory through arguments, accumulate the mod/ref - // information from CS1's references to the memory referenced by - // CS2's arguments. - if (onlyAccessesArgPointees(CS2B)) { - if (!doesAccessArgPointees(CS2B)) + // If Call2 only access memory through arguments, accumulate the mod/ref + // information from Call1's references to the memory referenced by + // Call2's arguments. + if (onlyAccessesArgPointees(Call2B)) { + if (!doesAccessArgPointees(Call2B)) return ModRefInfo::NoModRef; ModRefInfo R = ModRefInfo::NoModRef; bool IsMustAlias = true; - for (auto I = CS2.arg_begin(), E = CS2.arg_end(); I != E; ++I) { + for (auto I = Call2->arg_begin(), E = Call2->arg_end(); I != E; ++I) { const Value *Arg = *I; if (!Arg->getType()->isPointerTy()) continue; - unsigned CS2ArgIdx = std::distance(CS2.arg_begin(), I); - auto CS2ArgLoc = MemoryLocation::getForArgument(CS2, CS2ArgIdx, TLI); - - // ArgModRefCS2 indicates what CS2 might do to CS2ArgLoc, and the - // dependence of CS1 on that location is the inverse: - // - If CS2 modifies location, dependence exists if CS1 reads or writes. - // - If CS2 only reads location, dependence exists if CS1 writes. - ModRefInfo ArgModRefCS2 = getArgModRefInfo(CS2, CS2ArgIdx); + unsigned Call2ArgIdx = std::distance(Call2->arg_begin(), I); + auto Call2ArgLoc = + MemoryLocation::getForArgument(Call2, Call2ArgIdx, TLI); + + // ArgModRefC2 indicates what Call2 might do to Call2ArgLoc, and the + // dependence of Call1 on that location is the inverse: + // - If Call2 modifies location, dependence exists if Call1 reads or + // writes. + // - If Call2 only reads location, dependence exists if Call1 writes. + ModRefInfo ArgModRefC2 = getArgModRefInfo(Call2, Call2ArgIdx); ModRefInfo ArgMask = ModRefInfo::NoModRef; - if (isModSet(ArgModRefCS2)) + if (isModSet(ArgModRefC2)) ArgMask = ModRefInfo::ModRef; - else if (isRefSet(ArgModRefCS2)) + else if (isRefSet(ArgModRefC2)) ArgMask = ModRefInfo::Mod; - // ModRefCS1 indicates what CS1 might do to CS2ArgLoc, and we use + // ModRefC1 indicates what Call1 might do to Call2ArgLoc, and we use // above ArgMask to update dependence info. - ModRefInfo ModRefCS1 = getModRefInfo(CS1, CS2ArgLoc); - ArgMask = intersectModRef(ArgMask, ModRefCS1); + ModRefInfo ModRefC1 = getModRefInfo(Call1, Call2ArgLoc); + ArgMask = intersectModRef(ArgMask, ModRefC1); // Conservatively clear IsMustAlias unless only MustAlias is found. - IsMustAlias &= isMustSet(ModRefCS1); + IsMustAlias &= isMustSet(ModRefC1); R = intersectModRef(unionModRef(R, ArgMask), Result); if (R == Result) { @@ -298,31 +300,32 @@ ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS1, return IsMustAlias ? setMust(R) : clearMust(R); } - // If CS1 only accesses memory through arguments, check if CS2 references - // any of the memory referenced by CS1's arguments. If not, return NoModRef. - if (onlyAccessesArgPointees(CS1B)) { - if (!doesAccessArgPointees(CS1B)) + // If Call1 only accesses memory through arguments, check if Call2 references + // any of the memory referenced by Call1's arguments. If not, return NoModRef. + if (onlyAccessesArgPointees(Call1B)) { + if (!doesAccessArgPointees(Call1B)) return ModRefInfo::NoModRef; ModRefInfo R = ModRefInfo::NoModRef; bool IsMustAlias = true; - for (auto I = CS1.arg_begin(), E = CS1.arg_end(); I != E; ++I) { + for (auto I = Call1->arg_begin(), E = Call1->arg_end(); I != E; ++I) { const Value *Arg = *I; if (!Arg->getType()->isPointerTy()) continue; - unsigned CS1ArgIdx = std::distance(CS1.arg_begin(), I); - auto CS1ArgLoc = MemoryLocation::getForArgument(CS1, CS1ArgIdx, TLI); - - // ArgModRefCS1 indicates what CS1 might do to CS1ArgLoc; if CS1 might - // Mod CS1ArgLoc, then we care about either a Mod or a Ref by CS2. If - // CS1 might Ref, then we care only about a Mod by CS2. - ModRefInfo ArgModRefCS1 = getArgModRefInfo(CS1, CS1ArgIdx); - ModRefInfo ModRefCS2 = getModRefInfo(CS2, CS1ArgLoc); - if ((isModSet(ArgModRefCS1) && isModOrRefSet(ModRefCS2)) || - (isRefSet(ArgModRefCS1) && isModSet(ModRefCS2))) - R = intersectModRef(unionModRef(R, ArgModRefCS1), Result); + unsigned Call1ArgIdx = std::distance(Call1->arg_begin(), I); + auto Call1ArgLoc = + MemoryLocation::getForArgument(Call1, Call1ArgIdx, TLI); + + // ArgModRefC1 indicates what Call1 might do to Call1ArgLoc; if Call1 + // might Mod Call1ArgLoc, then we care about either a Mod or a Ref by + // Call2. If Call1 might Ref, then we care only about a Mod by Call2. + ModRefInfo ArgModRefC1 = getArgModRefInfo(Call1, Call1ArgIdx); + ModRefInfo ModRefC2 = getModRefInfo(Call2, Call1ArgLoc); + if ((isModSet(ArgModRefC1) && isModOrRefSet(ModRefC2)) || + (isRefSet(ArgModRefC1) && isModSet(ModRefC2))) + R = intersectModRef(unionModRef(R, ArgModRefC1), Result); // Conservatively clear IsMustAlias unless only MustAlias is found. - IsMustAlias &= isMustSet(ModRefCS2); + IsMustAlias &= isMustSet(ModRefC2); if (R == Result) { // On early exit, not all args were checked, cannot set Must. @@ -342,11 +345,11 @@ ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS1, return Result; } -FunctionModRefBehavior AAResults::getModRefBehavior(ImmutableCallSite CS) { +FunctionModRefBehavior AAResults::getModRefBehavior(const CallBase *Call) { FunctionModRefBehavior Result = FMRB_UnknownModRefBehavior; for (const auto &AA : AAs) { - Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(CS)); + Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(Call)); // Early-exit the moment we reach the bottom of the lattice. if (Result == FMRB_DoesNotAccessMemory) @@ -558,8 +561,8 @@ ModRefInfo AAResults::callCapturesBefore(const Instruction *I, isa<Constant>(Object)) return ModRefInfo::ModRef; - ImmutableCallSite CS(I); - if (!CS.getInstruction() || CS.getInstruction() == Object) + const auto *Call = dyn_cast<CallBase>(I); + if (!Call || Call == Object) return ModRefInfo::ModRef; if (PointerMayBeCapturedBefore(Object, /* ReturnCaptures */ true, @@ -572,14 +575,14 @@ ModRefInfo AAResults::callCapturesBefore(const Instruction *I, ModRefInfo R = ModRefInfo::NoModRef; bool IsMustAlias = true; // Set flag only if no May found and all operands processed. - for (auto CI = CS.data_operands_begin(), CE = CS.data_operands_end(); + for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end(); CI != CE; ++CI, ++ArgNo) { // Only look at the no-capture or byval pointer arguments. If this // pointer were passed to arguments that were neither of these, then it // couldn't be no-capture. if (!(*CI)->getType()->isPointerTy() || - (!CS.doesNotCapture(ArgNo) && - ArgNo < CS.getNumArgOperands() && !CS.isByValArgument(ArgNo))) + (!Call->doesNotCapture(ArgNo) && ArgNo < Call->getNumArgOperands() && + !Call->isByValArgument(ArgNo))) continue; AliasResult AR = alias(MemoryLocation(*CI), MemoryLocation(Object)); @@ -591,9 +594,9 @@ ModRefInfo AAResults::callCapturesBefore(const Instruction *I, IsMustAlias = false; if (AR == NoAlias) continue; - if (CS.doesNotAccessMemory(ArgNo)) + if (Call->doesNotAccessMemory(ArgNo)) continue; - if (CS.onlyReadsMemory(ArgNo)) { + if (Call->onlyReadsMemory(ArgNo)) { R = ModRefInfo::Ref; continue; } @@ -775,8 +778,8 @@ AAResults llvm::createLegacyPMAAResults(Pass &P, Function &F, } bool llvm::isNoAliasCall(const Value *V) { - if (auto CS = ImmutableCallSite(V)) - return CS.hasRetAttr(Attribute::NoAlias); + if (const auto *Call = dyn_cast<CallBase>(V)) + return Call->hasRetAttr(Attribute::NoAlias); return false; } diff --git a/llvm/lib/Analysis/AliasAnalysisEvaluator.cpp b/llvm/lib/Analysis/AliasAnalysisEvaluator.cpp index 7b4d174949a..85dd4fe95b3 100644 --- a/llvm/lib/Analysis/AliasAnalysisEvaluator.cpp +++ b/llvm/lib/Analysis/AliasAnalysisEvaluator.cpp @@ -66,11 +66,10 @@ static inline void PrintModRefResults(const char *Msg, bool P, Instruction *I, } } -static inline void PrintModRefResults(const char *Msg, bool P, CallSite CSA, - CallSite CSB, Module *M) { +static inline void PrintModRefResults(const char *Msg, bool P, CallBase *CallA, + CallBase *CallB, Module *M) { if (PrintAll || P) { - errs() << " " << Msg << ": " << *CSA.getInstruction() << " <-> " - << *CSB.getInstruction() << '\n'; + errs() << " " << Msg << ": " << *CallA << " <-> " << *CallB << '\n'; } } @@ -98,7 +97,7 @@ void AAEvaluator::runInternal(Function &F, AAResults &AA) { ++FunctionCount; SetVector<Value *> Pointers; - SmallSetVector<CallSite, 16> CallSites; + SmallSetVector<CallBase *, 16> Calls; SetVector<Value *> Loads; SetVector<Value *> Stores; @@ -114,16 +113,16 @@ void AAEvaluator::runInternal(Function &F, AAResults &AA) { if (EvalAAMD && isa<StoreInst>(&*I)) Stores.insert(&*I); Instruction &Inst = *I; - if (auto CS = CallSite(&Inst)) { - Value *Callee = CS.getCalledValue(); + if (auto *Call = dyn_cast<CallBase>(&Inst)) { + Value *Callee = Call->getCalledValue(); // Skip actual functions for direct function calls. if (!isa<Function>(Callee) && isInterestingPointer(Callee)) Pointers.insert(Callee); // Consider formals. - for (Use &DataOp : CS.data_ops()) + for (Use &DataOp : Call->data_ops()) if (isInterestingPointer(DataOp)) Pointers.insert(DataOp); - CallSites.insert(CS); + Calls.insert(Call); } else { // Consider all operands. for (Instruction::op_iterator OI = Inst.op_begin(), OE = Inst.op_end(); @@ -136,7 +135,7 @@ void AAEvaluator::runInternal(Function &F, AAResults &AA) { if (PrintAll || PrintNoAlias || PrintMayAlias || PrintPartialAlias || PrintMustAlias || PrintNoModRef || PrintMod || PrintRef || PrintModRef) errs() << "Function: " << F.getName() << ": " << Pointers.size() - << " pointers, " << CallSites.size() << " call sites\n"; + << " pointers, " << Calls.size() << " call sites\n"; // iterate over the worklist, and run the full (n^2)/2 disambiguations for (SetVector<Value *>::iterator I1 = Pointers.begin(), E = Pointers.end(); @@ -230,50 +229,48 @@ void AAEvaluator::runInternal(Function &F, AAResults &AA) { } // Mod/ref alias analysis: compare all pairs of calls and values - for (CallSite C : CallSites) { - Instruction *I = C.getInstruction(); - + for (CallBase *Call : Calls) { for (auto Pointer : Pointers) { auto Size = LocationSize::unknown(); Type *ElTy = cast<PointerType>(Pointer->getType())->getElementType(); if (ElTy->isSized()) Size = LocationSize::precise(DL.getTypeStoreSize(ElTy)); - switch (AA.getModRefInfo(C, Pointer, Size)) { + switch (AA.getModRefInfo(Call, Pointer, Size)) { case ModRefInfo::NoModRef: - PrintModRefResults("NoModRef", PrintNoModRef, I, Pointer, + PrintModRefResults("NoModRef", PrintNoModRef, Call, Pointer, F.getParent()); ++NoModRefCount; break; case ModRefInfo::Mod: - PrintModRefResults("Just Mod", PrintMod, I, Pointer, F.getParent()); + PrintModRefResults("Just Mod", PrintMod, Call, Pointer, F.getParent()); ++ModCount; break; case ModRefInfo::Ref: - PrintModRefResults("Just Ref", PrintRef, I, Pointer, F.getParent()); + PrintModRefResults("Just Ref", PrintRef, Call, Pointer, F.getParent()); ++RefCount; break; case ModRefInfo::ModRef: - PrintModRefResults("Both ModRef", PrintModRef, I, Pointer, + PrintModRefResults("Both ModRef", PrintModRef, Call, Pointer, F.getParent()); ++ModRefCount; break; case ModRefInfo::Must: - PrintModRefResults("Must", PrintMust, I, Pointer, F.getParent()); + PrintModRefResults("Must", PrintMust, Call, Pointer, F.getParent()); ++MustCount; break; case ModRefInfo::MustMod: - PrintModRefResults("Just Mod (MustAlias)", PrintMustMod, I, Pointer, + PrintModRefResults("Just Mod (MustAlias)", PrintMustMod, Call, Pointer, F.getParent()); ++MustModCount; break; case ModRefInfo::MustRef: - PrintModRefResults("Just Ref (MustAlias)", PrintMustRef, I, Pointer, + PrintModRefResults("Just Ref (MustAlias)", PrintMustRef, Call, Pointer, F.getParent()); ++MustRefCount; break; case ModRefInfo::MustModRef: - PrintModRefResults("Both ModRef (MustAlias)", PrintMustModRef, I, + PrintModRefResults("Both ModRef (MustAlias)", PrintMustModRef, Call, Pointer, F.getParent()); ++MustModRefCount; break; @@ -282,44 +279,46 @@ void AAEvaluator::runInternal(Function &F, AAResults &AA) { } // Mod/ref alias analysis: compare all pairs of calls - for (auto C = CallSites.begin(), Ce = CallSites.end(); C != Ce; ++C) { - for (auto D = CallSites.begin(); D != Ce; ++D) { - if (D == C) + for (CallBase *CallA : Calls) { + for (CallBase *CallB : Calls) { + if (CallA == CallB) continue; - switch (AA.getModRefInfo(*C, *D)) { + switch (AA.getModRefInfo(CallA, CallB)) { case ModRefInfo::NoModRef: - PrintModRefResults("NoModRef", PrintNoModRef, *C, *D, F.getParent()); + PrintModRefResults("NoModRef", PrintNoModRef, CallA, CallB, + F.getParent()); ++NoModRefCount; break; case ModRefInfo::Mod: - PrintModRefResults("Just Mod", PrintMod, *C, *D, F.getParent()); + PrintModRefResults("Just Mod", PrintMod, CallA, CallB, F.getParent()); ++ModCount; break; case ModRefInfo::Ref: - PrintModRefResults("Just Ref", PrintRef, *C, *D, F.getParent()); + PrintModRefResults("Just Ref", PrintRef, CallA, CallB, F.getParent()); ++RefCount; break; case ModRefInfo::ModRef: - PrintModRefResults("Both ModRef", PrintModRef, *C, *D, F.getParent()); + PrintModRefResults("Both ModRef", PrintModRef, CallA, CallB, + F.getParent()); ++ModRefCount; break; case ModRefInfo::Must: - PrintModRefResults("Must", PrintMust, *C, *D, F.getParent()); + PrintModRefResults("Must", PrintMust, CallA, CallB, F.getParent()); ++MustCount; break; case ModRefInfo::MustMod: - PrintModRefResults("Just Mod (MustAlias)", PrintMustMod, *C, *D, + PrintModRefResults("Just Mod (MustAlias)", PrintMustMod, CallA, CallB, F.getParent()); ++MustModCount; break; case ModRefInfo::MustRef: - PrintModRefResults("Just Ref (MustAlias)", PrintMustRef, *C, *D, + PrintModRefResults("Just Ref (MustAlias)", PrintMustRef, CallA, CallB, F.getParent()); ++MustRefCount; break; case ModRefInfo::MustModRef: - PrintModRefResults("Both ModRef (MustAlias)", PrintMustModRef, *C, *D, - F.getParent()); + PrintModRefResults("Both ModRef (MustAlias)", PrintMustModRef, CallA, + CallB, F.getParent()); ++MustModRefCount; break; } diff --git a/llvm/lib/Analysis/AliasSetTracker.cpp b/llvm/lib/Analysis/AliasSetTracker.cpp index c152b0ddeca..f6ad704cc91 100644 --- a/llvm/lib/Analysis/AliasSetTracker.cpp +++ b/llvm/lib/Analysis/AliasSetTracker.cpp @@ -16,7 +16,6 @@ #include "llvm/Analysis/GuardUtils.h" #include "llvm/Analysis/MemoryLocation.h" #include "llvm/Config/llvm-config.h" -#include "llvm/IR/CallSite.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/Function.h" @@ -236,7 +235,8 @@ bool AliasSet::aliasesUnknownInst(const Instruction *Inst, for (unsigned i = 0, e = UnknownInsts.size(); i != e; ++i) { if (auto *UnknownInst = getUnknownInst(i)) { - ImmutableCallSite C1(UnknownInst), C2(Inst); + const auto *C1 = dyn_cast<CallBase>(UnknownInst); + const auto *C2 = dyn_cast<CallBase>(Inst); if (!C1 || !C2 || isModOrRefSet(AA.getModRefInfo(C1, C2)) || isModOrRefSet(AA.getModRefInfo(C2, C1))) return true; @@ -446,44 +446,44 @@ void AliasSetTracker::add(Instruction *I) { return add(MTI); // Handle all calls with known mod/ref sets genericall - CallSite CS(I); - if (CS && CS.onlyAccessesArgMemory()) { - auto getAccessFromModRef = [](ModRefInfo MRI) { - if (isRefSet(MRI) && isModSet(MRI)) - return AliasSet::ModRefAccess; - else if (isModSet(MRI)) - return AliasSet::ModAccess; - else if (isRefSet(MRI)) - return AliasSet::RefAccess; - else - return AliasSet::NoAccess; - - }; - - ModRefInfo CallMask = createModRefInfo(AA.getModRefBehavior(CS)); - - // Some intrinsics are marked as modifying memory for control flow - // modelling purposes, but don't actually modify any specific memory - // location. - using namespace PatternMatch; - if (I->use_empty() && match(I, m_Intrinsic<Intrinsic::invariant_start>())) - CallMask = clearMod(CallMask); - - for (auto AI = CS.arg_begin(), AE = CS.arg_end(); AI != AE; ++AI) { - const Value *Arg = *AI; - if (!Arg->getType()->isPointerTy()) - continue; - unsigned ArgIdx = std::distance(CS.arg_begin(), AI); - MemoryLocation ArgLoc = MemoryLocation::getForArgument(CS, ArgIdx, - nullptr); - ModRefInfo ArgMask = AA.getArgModRefInfo(CS, ArgIdx); - ArgMask = intersectModRef(CallMask, ArgMask); - if (!isNoModRef(ArgMask)) - addPointer(ArgLoc, getAccessFromModRef(ArgMask)); + if (auto *Call = dyn_cast<CallBase>(I)) + if (Call->onlyAccessesArgMemory()) { + auto getAccessFromModRef = [](ModRefInfo MRI) { + if (isRefSet(MRI) && isModSet(MRI)) + return AliasSet::ModRefAccess; + else if (isModSet(MRI)) + return AliasSet::ModAccess; + else if (isRefSet(MRI)) + return AliasSet::RefAccess; + else + return AliasSet::NoAccess; + }; + + ModRefInfo CallMask = createModRefInfo(AA.getModRefBehavior(Call)); + + // Some intrinsics are marked as modifying memory for control flow + // modelling purposes, but don't actually modify any specific memory + // location. + using namespace PatternMatch; + if (Call->use_empty() && + match(Call, m_Intrinsic<Intrinsic::invariant_start>())) + CallMask = clearMod(CallMask); + + for (auto IdxArgPair : enumerate(Call->args())) { + int ArgIdx = IdxArgPair.index(); + const Value *Arg = IdxArgPair.value(); + if (!Arg->getType()->isPointerTy()) + continue; + MemoryLocation ArgLoc = + MemoryLocation::getForArgument(Call, ArgIdx, nullptr); + ModRefInfo ArgMask = AA.getArgModRefInfo(Call, ArgIdx); + ArgMask = intersectModRef(CallMask, ArgMask); + if (!isNoModRef(ArgMask)) + addPointer(ArgLoc, getAccessFromModRef(ArgMask)); + } + return; } - return; - } - + return addUnknown(I); } diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp index 41a3023724e..332eeaa00e7 100644 --- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp +++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp @@ -31,7 +31,6 @@ #include "llvm/Analysis/PhiValues.h" #include "llvm/IR/Argument.h" #include "llvm/IR/Attributes.h" -#include "llvm/IR/CallSite.h" #include "llvm/IR/Constant.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DataLayout.h" @@ -144,7 +143,7 @@ static bool isNonEscapingLocalObject(const Value *V) { /// Returns true if the pointer is one which would have been considered an /// escape by isNonEscapingLocalObject. static bool isEscapeSource(const Value *V) { - if (ImmutableCallSite(V)) + if (isa<CallBase>(V)) return true; if (isa<Argument>(V)) @@ -454,7 +453,7 @@ bool BasicAAResult::DecomposeGEPExpression(const Value *V, const GEPOperator *GEPOp = dyn_cast<GEPOperator>(Op); if (!GEPOp) { - if (auto CS = ImmutableCallSite(V)) { + if (const auto *Call = dyn_cast<CallBase>(V)) { // CaptureTracking can know about special capturing properties of some // intrinsics like launder.invariant.group, that can't be expressed with // the attributes, but have properties like returning aliasing pointer. @@ -464,7 +463,7 @@ bool BasicAAResult::DecomposeGEPExpression(const Value *V, // because it should be in sync with CaptureTracking. Not using it may // cause weird miscompilations where 2 aliasing pointers are assumed to // noalias. - if (auto *RP = getArgumentAliasingToReturnedPointer(CS)) { + if (auto *RP = getArgumentAliasingToReturnedPointer(Call)) { V = RP; continue; } @@ -673,8 +672,8 @@ bool BasicAAResult::pointsToConstantMemory(const MemoryLocation &Loc, } /// Returns the behavior when calling the given call site. -FunctionModRefBehavior BasicAAResult::getModRefBehavior(ImmutableCallSite CS) { - if (CS.doesNotAccessMemory()) +FunctionModRefBehavior BasicAAResult::getModRefBehavior(const CallBase *Call) { + if (Call->doesNotAccessMemory()) // Can't do better than this. return FMRB_DoesNotAccessMemory; @@ -682,23 +681,23 @@ FunctionModRefBehavior BasicAAResult::getModRefBehavior(ImmutableCallSite CS) { // If the callsite knows it only reads memory, don't return worse // than that. - if (CS.onlyReadsMemory()) + if (Call->onlyReadsMemory()) Min = FMRB_OnlyReadsMemory; - else if (CS.doesNotReadMemory()) + else if (Call->doesNotReadMemory()) Min = FMRB_DoesNotReadMemory; - if (CS.onlyAccessesArgMemory()) + if (Call->onlyAccessesArgMemory()) Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesArgumentPointees); - else if (CS.onlyAccessesInaccessibleMemory()) + else if (Call->onlyAccessesInaccessibleMemory()) Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleMem); - else if (CS.onlyAccessesInaccessibleMemOrArgMem()) + else if (Call->onlyAccessesInaccessibleMemOrArgMem()) Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleOrArgMem); - // If CS has operand bundles then aliasing attributes from the function it - // calls do not directly apply to the CallSite. This can be made more - // precise in the future. - if (!CS.hasOperandBundles()) - if (const Function *F = CS.getCalledFunction()) + // If the call has operand bundles then aliasing attributes from the function + // it calls do not directly apply to the call. This can be made more precise + // in the future. + if (!Call->hasOperandBundles()) + if (const Function *F = Call->getCalledFunction()) Min = FunctionModRefBehavior(Min & getBestAAResults().getModRefBehavior(F)); @@ -731,9 +730,9 @@ FunctionModRefBehavior BasicAAResult::getModRefBehavior(const Function *F) { } /// Returns true if this is a writeonly (i.e Mod only) parameter. -static bool isWriteOnlyParam(ImmutableCallSite CS, unsigned ArgIdx, +static bool isWriteOnlyParam(const CallBase *Call, unsigned ArgIdx, const TargetLibraryInfo &TLI) { - if (CS.paramHasAttr(ArgIdx, Attribute::WriteOnly)) + if (Call->paramHasAttr(ArgIdx, Attribute::WriteOnly)) return true; // We can bound the aliasing properties of memset_pattern16 just as we can @@ -743,7 +742,8 @@ static bool isWriteOnlyParam(ImmutableCallSite CS, unsigned ArgIdx, // FIXME Consider handling this in InferFunctionAttr.cpp together with other // attributes. LibFunc F; - if (CS.getCalledFunction() && TLI.getLibFunc(*CS.getCalledFunction(), F) && + if (Call->getCalledFunction() && + TLI.getLibFunc(*Call->getCalledFunction(), F) && F == LibFunc_memset_pattern16 && TLI.has(F)) if (ArgIdx == 0) return true; @@ -755,23 +755,23 @@ static bool isWriteOnlyParam(ImmutableCallSite CS, unsigned ArgIdx, return false; } -ModRefInfo BasicAAResult::getArgModRefInfo(ImmutableCallSite CS, +ModRefInfo BasicAAResult::getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) { // Checking for known builtin intrinsics and target library functions. - if (isWriteOnlyParam(CS, ArgIdx, TLI)) + if (isWriteOnlyParam(Call, ArgIdx, TLI)) return ModRefInfo::Mod; - if (CS.paramHasAttr(ArgIdx, Attribute::ReadOnly)) + if (Call->paramHasAttr(ArgIdx, Attribute::ReadOnly)) return ModRefInfo::Ref; - if (CS.paramHasAttr(ArgIdx, Attribute::ReadNone)) + if (Call->paramHasAttr(ArgIdx, Attribute::ReadNone)) return ModRefInfo::NoModRef; - return AAResultBase::getArgModRefInfo(CS, ArgIdx); + return AAResultBase::getArgModRefInfo(Call, ArgIdx); } -static bool isIntrinsicCall(ImmutableCallSite CS, Intrinsic::ID IID) { - const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction()); +static bool isIntrinsicCall(const CallBase *Call, Intrinsic::ID IID) { + const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Call); return II && II->getIntrinsicID() == IID; } @@ -827,9 +827,9 @@ AliasResult BasicAAResult::alias(const MemoryLocation &LocA, /// Since we only look at local properties of this function, we really can't /// say much about this query. We do, however, use simple "address taken" /// analysis on local objects. -ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, +ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call, const MemoryLocation &Loc) { - assert(notDifferentParent(CS.getInstruction(), Loc.Ptr) && + assert(notDifferentParent(Call, Loc.Ptr) && "AliasAnalysis query involving multiple functions!"); const Value *Object = GetUnderlyingObject(Loc.Ptr, DL); @@ -840,7 +840,7 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, // contents of the alloca into argument registers or stack slots, so there is // no lifetime issue. if (isa<AllocaInst>(Object)) - if (const CallInst *CI = dyn_cast<CallInst>(CS.getInstruction())) + if (const CallInst *CI = dyn_cast<CallInst>(Call)) if (CI->isTailCall() && !CI->getAttributes().hasAttrSomewhere(Attribute::ByVal)) return ModRefInfo::NoModRef; @@ -848,13 +848,13 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, // Stack restore is able to modify unescaped dynamic allocas. Assume it may // modify them even though the alloca is not escaped. if (auto *AI = dyn_cast<AllocaInst>(Object)) - if (!AI->isStaticAlloca() && isIntrinsicCall(CS, Intrinsic::stackrestore)) + if (!AI->isStaticAlloca() && isIntrinsicCall(Call, Intrinsic::stackrestore)) return ModRefInfo::Mod; // If the pointer is to a locally allocated object that does not escape, // then the call can not mod/ref the pointer unless the call takes the pointer // as an argument, and itself doesn't capture it. - if (!isa<Constant>(Object) && CS.getInstruction() != Object && + if (!isa<Constant>(Object) && Call != Object && isNonEscapingLocalObject(Object)) { // Optimistically assume that call doesn't touch Object and check this @@ -863,19 +863,20 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, bool IsMustAlias = true; unsigned OperandNo = 0; - for (auto CI = CS.data_operands_begin(), CE = CS.data_operands_end(); + for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end(); CI != CE; ++CI, ++OperandNo) { // Only look at the no-capture or byval pointer arguments. If this // pointer were passed to arguments that were neither of these, then it // couldn't be no-capture. if (!(*CI)->getType()->isPointerTy() || - (!CS.doesNotCapture(OperandNo) && - OperandNo < CS.getNumArgOperands() && !CS.isByValArgument(OperandNo))) + (!Call->doesNotCapture(OperandNo) && + OperandNo < Call->getNumArgOperands() && + !Call->isByValArgument(OperandNo))) continue; // Call doesn't access memory through this operand, so we don't care // if it aliases with Object. - if (CS.doesNotAccessMemory(OperandNo)) + if (Call->doesNotAccessMemory(OperandNo)) continue; // If this is a no-capture pointer argument, see if we can tell that it @@ -889,12 +890,12 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, continue; // Operand aliases 'Object', but call doesn't modify it. Strengthen // initial assumption and keep looking in case if there are more aliases. - if (CS.onlyReadsMemory(OperandNo)) { + if (Call->onlyReadsMemory(OperandNo)) { Result = setRef(Result); continue; } // Operand aliases 'Object' but call only writes into it. - if (CS.doesNotReadMemory(OperandNo)) { + if (Call->doesNotReadMemory(OperandNo)) { Result = setMod(Result); continue; } @@ -918,17 +919,16 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, } } - // If the CallSite is to malloc or calloc, we can assume that it doesn't + // If the call is to malloc or calloc, we can assume that it doesn't // modify any IR visible value. This is only valid because we assume these // routines do not read values visible in the IR. TODO: Consider special // casing realloc and strdup routines which access only their arguments as // well. Or alternatively, replace all of this with inaccessiblememonly once // that's implemented fully. - auto *Inst = CS.getInstruction(); - if (isMallocOrCallocLikeFn(Inst, &TLI)) { + if (isMallocOrCallocLikeFn(Call, &TLI)) { // Be conservative if the accessed pointer may alias the allocation - // fallback to the generic handling below. - if (getBestAAResults().alias(MemoryLocation(Inst), Loc) == NoAlias) + if (getBestAAResults().alias(MemoryLocation(Call), Loc) == NoAlias) return ModRefInfo::NoModRef; } @@ -936,7 +936,7 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, // operands, i.e., source and destination of any given memcpy must no-alias. // If Loc must-aliases either one of these two locations, then it necessarily // no-aliases the other. - if (auto *Inst = dyn_cast<AnyMemCpyInst>(CS.getInstruction())) { + if (auto *Inst = dyn_cast<AnyMemCpyInst>(Call)) { AliasResult SrcAA, DestAA; if ((SrcAA = getBestAAResults().alias(MemoryLocation::getForSource(Inst), @@ -960,7 +960,7 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, // While the assume intrinsic is marked as arbitrarily writing so that // proper control dependencies will be maintained, it never aliases any // particular memory location. - if (isIntrinsicCall(CS, Intrinsic::assume)) + if (isIntrinsicCall(Call, Intrinsic::assume)) return ModRefInfo::NoModRef; // Like assumes, guard intrinsics are also marked as arbitrarily writing so @@ -970,7 +970,7 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, // *Unlike* assumes, guard intrinsics are modeled as reading memory since the // heap state at the point the guard is issued needs to be consistent in case // the guard invokes the "deopt" continuation. - if (isIntrinsicCall(CS, Intrinsic::experimental_guard)) + if (isIntrinsicCall(Call, Intrinsic::experimental_guard)) return ModRefInfo::Ref; // Like assumes, invariant.start intrinsics were also marked as arbitrarily @@ -996,20 +996,20 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS, // The transformation will cause the second store to be ignored (based on // rules of invariant.start) and print 40, while the first program always // prints 50. - if (isIntrinsicCall(CS, Intrinsic::invariant_start)) + if (isIntrinsicCall(Call, Intrinsic::invariant_start)) return ModRefInfo::Ref; // The AAResultBase base class has some smarts, lets use them. - return AAResultBase::getModRefInfo(CS, Loc); + return AAResultBase::getModRefInfo(Call, Loc); } -ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS1, - ImmutableCallSite CS2) { +ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call1, + const CallBase *Call2) { // While the assume intrinsic is marked as arbitrarily writing so that // proper control dependencies will be maintained, it never aliases any // particular memory location. - if (isIntrinsicCall(CS1, Intrinsic::assume) || - isIntrinsicCall(CS2, Intrinsic::assume)) + if (isIntrinsicCall(Call1, Intrinsic::assume) || + isIntrinsicCall(Call2, Intrinsic::assume)) return ModRefInfo::NoModRef; // Like assumes, guard intrinsics are also marked as arbitrarily writing so @@ -1023,18 +1023,18 @@ ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS1, // NB! This function is *not* commutative, so we specical case two // possibilities for guard intrinsics. - if (isIntrinsicCall(CS1, Intrinsic::experimental_guard)) - return isModSet(createModRefInfo(getModRefBehavior(CS2))) + if (isIntrinsicCall(Call1, Intrinsic::experimental_guard)) + return isModSet(createModRefInfo(getModRefBehavior(Call2))) ? ModRefInfo::Ref : ModRefInfo::NoModRef; - if (isIntrinsicCall(CS2, Intrinsic::experimental_guard)) - return isModSet(createModRefInfo(getModRefBehavior(CS1))) + if (isIntrinsicCall(Call2, Intrinsic::experimental_guard)) + return isModSet(createModRefInfo(getModRefBehavior(Call1))) ? ModRefInfo::Mod : ModRefInfo::NoModRef; // The AAResultBase base class has some smarts, lets use them. - return AAResultBase::getModRefInfo(CS1, CS2); + return AAResultBase::getModRefInfo(Call1, Call2); } /// Provide ad-hoc rules to disambiguate accesses through two GEP operators, diff --git a/llvm/lib/Analysis/CaptureTracking.cpp b/llvm/lib/Analysis/CaptureTracking.cpp index 5cac5e5ca61..669f4f2835f 100644 --- a/llvm/lib/Analysis/CaptureTracking.cpp +++ b/llvm/lib/Analysis/CaptureTracking.cpp @@ -23,7 +23,6 @@ #include "llvm/Analysis/CFG.h" #include "llvm/Analysis/OrderedBasicBlock.h" #include "llvm/Analysis/ValueTracking.h" -#include "llvm/IR/CallSite.h" #include "llvm/IR/Constants.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/Instructions.h" @@ -240,11 +239,12 @@ void llvm::PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker, switch (I->getOpcode()) { case Instruction::Call: case Instruction::Invoke: { - CallSite CS(I); + auto *Call = cast<CallBase>(I); // Not captured if the callee is readonly, doesn't return a copy through // its return value and doesn't unwind (a readonly function can leak bits // by throwing an exception or not depending on the input value). - if (CS.onlyReadsMemory() && CS.doesNotThrow() && I->getType()->isVoidTy()) + if (Call->onlyReadsMemory() && Call->doesNotThrow() && + Call->getType()->isVoidTy()) break; // The pointer is not captured if returned pointer is not captured. @@ -252,14 +252,14 @@ void llvm::PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker, // marked with nocapture do not capture. This means that places like // GetUnderlyingObject in ValueTracking or DecomposeGEPExpression // in BasicAA also need to know about this property. - if (isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(CS)) { - AddUses(I); + if (isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(Call)) { + AddUses(Call); break; } // Volatile operations effectively capture the memory location that they // load and store to. - if (auto *MI = dyn_cast<MemIntrinsic>(I)) + if (auto *MI = dyn_cast<MemIntrinsic>(Call)) if (MI->isVolatile()) if (Tracker->captured(U)) return; @@ -271,13 +271,14 @@ void llvm::PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker, // that loading a value from a pointer does not cause the pointer to be // captured, even though the loaded value might be the pointer itself // (think of self-referential objects). - CallSite::data_operand_iterator B = - CS.data_operands_begin(), E = CS.data_operands_end(); - for (CallSite::data_operand_iterator A = B; A != E; ++A) - if (A->get() == V && !CS.doesNotCapture(A - B)) + for (auto IdxOpPair : enumerate(Call->data_ops())) { + int Idx = IdxOpPair.index(); + Value *A = IdxOpPair.value(); + if (A == V && !Call->doesNotCapture(Idx)) // The parameter is not marked 'nocapture' - captured. if (Tracker->captured(U)) return; + } break; } case Instruction::Load: diff --git a/llvm/lib/Analysis/GlobalsModRef.cpp b/llvm/lib/Analysis/GlobalsModRef.cpp index 2c503609d96..b28abcadca4 100644 --- a/llvm/lib/Analysis/GlobalsModRef.cpp +++ b/llvm/lib/Analysis/GlobalsModRef.cpp @@ -255,11 +255,11 @@ FunctionModRefBehavior GlobalsAAResult::getModRefBehavior(const Function *F) { } FunctionModRefBehavior -GlobalsAAResult::getModRefBehavior(ImmutableCallSite CS) { +GlobalsAAResult::getModRefBehavior(const CallBase *Call) { FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior; - if (!CS.hasOperandBundles()) - if (const Function *F = CS.getCalledFunction()) + if (!Call->hasOperandBundles()) + if (const Function *F = Call->getCalledFunction()) if (FunctionInfo *FI = getFunctionInfo(F)) { if (!isModOrRefSet(FI->getModRefInfo())) Min = FMRB_DoesNotAccessMemory; @@ -267,7 +267,7 @@ GlobalsAAResult::getModRefBehavior(ImmutableCallSite CS) { Min = FMRB_OnlyReadsMemory; } - return FunctionModRefBehavior(AAResultBase::getModRefBehavior(CS) & Min); + return FunctionModRefBehavior(AAResultBase::getModRefBehavior(Call) & Min); } /// Returns the function info for the function, or null if we don't have @@ -366,14 +366,14 @@ bool GlobalsAAResult::AnalyzeUsesOfPointer(Value *V, } else if (Operator::getOpcode(I) == Instruction::BitCast) { if (AnalyzeUsesOfPointer(I, Readers, Writers, OkayStoreDest)) return true; - } else if (auto CS = CallSite(I)) { + } else if (auto *Call = dyn_cast<CallBase>(I)) { // Make sure that this is just the function being called, not that it is // passing into the function. - if (CS.isDataOperand(&U)) { + if (Call->isDataOperand(&U)) { // Detect calls to free. - if (CS.isArgOperand(&U) && isFreeCall(I, &TLI)) { + if (Call->isArgOperand(&U) && isFreeCall(I, &TLI)) { if (Writers) - Writers->insert(CS->getParent()->getParent()); + Writers->insert(Call->getParent()->getParent()); } else { return true; // Argument of an unknown call. } @@ -576,15 +576,15 @@ void GlobalsAAResult::AnalyzeCallGraph(CallGraph &CG, Module &M) { // We handle calls specially because the graph-relevant aspects are // handled above. - if (auto CS = CallSite(&I)) { - if (isAllocationFn(&I, &TLI) || isFreeCall(&I, &TLI)) { + if (auto *Call = dyn_cast<CallBase>(&I)) { + if (isAllocationFn(Call, &TLI) || isFreeCall(Call, &TLI)) { // FIXME: It is completely unclear why this is necessary and not // handled by the above graph code. FI.addModRefInfo(ModRefInfo::ModRef); - } else if (Function *Callee = CS.getCalledFunction()) { + } else if (Function *Callee = Call->getCalledFunction()) { // The callgraph doesn't include intrinsic calls. if (Callee->isIntrinsic()) { - if (isa<DbgInfoIntrinsic>(I)) + if (isa<DbgInfoIntrinsic>(Call)) // Don't let dbg intrinsics affect alias info. continue; @@ -885,16 +885,16 @@ AliasResult GlobalsAAResult::alias(const MemoryLocation &LocA, return AAResultBase::alias(LocA, LocB); } -ModRefInfo GlobalsAAResult::getModRefInfoForArgument(ImmutableCallSite CS, +ModRefInfo GlobalsAAResult::getModRefInfoForArgument(const CallBase *Call, const GlobalValue *GV) { - if (CS.doesNotAccessMemory()) + if (Call->doesNotAccessMemory()) return ModRefInfo::NoModRef; ModRefInfo ConservativeResult = - CS.onlyReadsMemory() ? ModRefInfo::Ref : ModRefInfo::ModRef; + Call->onlyReadsMemory() ? ModRefInfo::Ref : ModRefInfo::ModRef; // Iterate through all the arguments to the called function. If any argument // is based on GV, return the conservative result. - for (auto &A : CS.args()) { + for (auto &A : Call->args()) { SmallVector<Value*, 4> Objects; GetUnderlyingObjects(A, Objects, DL); @@ -914,7 +914,7 @@ ModRefInfo GlobalsAAResult::getModRefInfoForArgument(ImmutableCallSite CS, return ModRefInfo::NoModRef; } -ModRefInfo GlobalsAAResult::getModRefInfo(ImmutableCallSite CS, +ModRefInfo GlobalsAAResult::getModRefInfo(const CallBase *Call, const MemoryLocation &Loc) { ModRefInfo Known = ModRefInfo::ModRef; @@ -923,15 +923,15 @@ ModRefInfo GlobalsAAResult::getModRefInfo(ImmutableCallSite CS, if (const GlobalValue *GV = dyn_cast<GlobalValue>(GetUnderlyingObject(Loc.Ptr, DL))) if (GV->hasLocalLinkage()) - if (const Function *F = CS.getCalledFunction()) + if (const Function *F = Call->getCalledFunction()) if (NonAddressTakenGlobals.count(GV)) if (const FunctionInfo *FI = getFunctionInfo(F)) Known = unionModRef(FI->getModRefInfoForGlobal(*GV), - getModRefInfoForArgument(CS, GV)); + getModRefInfoForArgument(Call, GV)); if (!isModOrRefSet(Known)) return ModRefInfo::NoModRef; // No need to query other mod/ref analyses - return intersectModRef(Known, AAResultBase::getModRefInfo(CS, Loc)); + return intersectModRef(Known, AAResultBase::getModRefInfo(Call, Loc)); } GlobalsAAResult::GlobalsAAResult(const DataLayout &DL, diff --git a/llvm/lib/Analysis/Loads.cpp b/llvm/lib/Analysis/Loads.cpp index cd986dcfde8..8129795bc0c 100644 --- a/llvm/lib/Analysis/Loads.cpp +++ b/llvm/lib/Analysis/Loads.cpp @@ -107,8 +107,8 @@ static bool isDereferenceableAndAlignedPointer( return isDereferenceableAndAlignedPointer(ASC->getOperand(0), Align, Size, DL, CtxI, DT, Visited); - if (auto CS = ImmutableCallSite(V)) - if (auto *RP = getArgumentAliasingToReturnedPointer(CS)) + if (const auto *Call = dyn_cast<CallBase>(V)) + if (auto *RP = getArgumentAliasingToReturnedPointer(Call)) return isDereferenceableAndAlignedPointer(RP, Align, Size, DL, CtxI, DT, Visited); diff --git a/llvm/lib/Analysis/MemDepPrinter.cpp b/llvm/lib/Analysis/MemDepPrinter.cpp index 5a6bbd7b2ac..907b321b231 100644 --- a/llvm/lib/Analysis/MemDepPrinter.cpp +++ b/llvm/lib/Analysis/MemDepPrinter.cpp @@ -13,7 +13,6 @@ #include "llvm/ADT/SetVector.h" #include "llvm/Analysis/MemoryDependenceAnalysis.h" #include "llvm/Analysis/Passes.h" -#include "llvm/IR/CallSite.h" #include "llvm/IR/InstIterator.h" #include "llvm/IR/LLVMContext.h" #include "llvm/Support/ErrorHandling.h" @@ -106,9 +105,9 @@ bool MemDepPrinter::runOnFunction(Function &F) { if (!Res.isNonLocal()) { Deps[Inst].insert(std::make_pair(getInstTypePair(Res), static_cast<BasicBlock *>(nullptr))); - } else if (auto CS = CallSite(Inst)) { + } else if (auto *Call = dyn_cast<CallBase>(Inst)) { const MemoryDependenceResults::NonLocalDepInfo &NLDI = - MDA.getNonLocalCallDependency(CS); + MDA.getNonLocalCallDependency(Call); DepSet &InstDeps = Deps[Inst]; for (const NonLocalDepEntry &I : NLDI) { diff --git a/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp b/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp index 2fe012d3865..e22182b99e1 100644 --- a/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp +++ b/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp @@ -31,7 +31,6 @@ #include "llvm/Analysis/ValueTracking.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/BasicBlock.h" -#include "llvm/IR/CallSite.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DerivedTypes.h" @@ -182,8 +181,8 @@ static ModRefInfo GetLocation(const Instruction *Inst, MemoryLocation &Loc, } /// Private helper for finding the local dependencies of a call site. -MemDepResult MemoryDependenceResults::getCallSiteDependencyFrom( - CallSite CS, bool isReadOnlyCall, BasicBlock::iterator ScanIt, +MemDepResult MemoryDependenceResults::getCallDependencyFrom( + CallBase *Call, bool isReadOnlyCall, BasicBlock::iterator ScanIt, BasicBlock *BB) { unsigned Limit = BlockScanLimit; @@ -205,21 +204,21 @@ MemDepResult MemoryDependenceResults::getCallSiteDependencyFrom( ModRefInfo MR = GetLocation(Inst, Loc, TLI); if (Loc.Ptr) { // A simple instruction. - if (isModOrRefSet(AA.getModRefInfo(CS, Loc))) + if (isModOrRefSet(AA.getModRefInfo(Call, Loc))) return MemDepResult::getClobber(Inst); continue; } - if (auto InstCS = CallSite(Inst)) { + if (auto *CallB = dyn_cast<CallBase>(Inst)) { // If these two calls do not interfere, look past it. - if (isNoModRef(AA.getModRefInfo(CS, InstCS))) { - // If the two calls are the same, return InstCS as a Def, so that - // CS can be found redundant and eliminated. + if (isNoModRef(AA.getModRefInfo(Call, CallB))) { + // If the two calls are the same, return Inst as a Def, so that + // Call can be found redundant and eliminated. if (isReadOnlyCall && !isModSet(MR) && - CS.getInstruction()->isIdenticalToWhenDefined(Inst)) + Call->isIdenticalToWhenDefined(CallB)) return MemDepResult::getDef(Inst); - // Otherwise if the two calls don't interact (e.g. InstCS is readnone) + // Otherwise if the two calls don't interact (e.g. CallB is readnone) // keep scanning. continue; } else @@ -750,11 +749,10 @@ MemDepResult MemoryDependenceResults::getDependency(Instruction *QueryInst) { LocalCache = getPointerDependencyFrom( MemLoc, isLoad, ScanPos->getIterator(), QueryParent, QueryInst); - } else if (isa<CallInst>(QueryInst) || isa<InvokeInst>(QueryInst)) { - CallSite QueryCS(QueryInst); - bool isReadOnly = AA.onlyReadsMemory(QueryCS); - LocalCache = getCallSiteDependencyFrom( - QueryCS, isReadOnly, ScanPos->getIterator(), QueryParent); + } else if (auto *QueryCall = dyn_cast<CallBase>(QueryInst)) { + bool isReadOnly = AA.onlyReadsMemory(QueryCall); + LocalCache = getCallDependencyFrom(QueryCall, isReadOnly, + ScanPos->getIterator(), QueryParent); } else // Non-memory instruction. LocalCache = MemDepResult::getUnknown(); @@ -780,11 +778,11 @@ static void AssertSorted(MemoryDependenceResults::NonLocalDepInfo &Cache, #endif const MemoryDependenceResults::NonLocalDepInfo & -MemoryDependenceResults::getNonLocalCallDependency(CallSite QueryCS) { - assert(getDependency(QueryCS.getInstruction()).isNonLocal() && +MemoryDependenceResults::getNonLocalCallDependency(CallBase *QueryCall) { + assert(getDependency(QueryCall).isNonLocal() && "getNonLocalCallDependency should only be used on calls with " "non-local deps!"); - PerInstNLInfo &CacheP = NonLocalDeps[QueryCS.getInstruction()]; + PerInstNLInfo &CacheP = NonLocalDeps[QueryCall]; NonLocalDepInfo &Cache = CacheP.first; // This is the set of blocks that need to be recomputed. In the cached case, @@ -814,14 +812,14 @@ MemoryDependenceResults::getNonLocalCallDependency(CallSite QueryCS) { // << Cache.size() << " cached: " << *QueryInst; } else { // Seed DirtyBlocks with each of the preds of QueryInst's block. - BasicBlock *QueryBB = QueryCS.getInstruction()->getParent(); + BasicBlock *QueryBB = QueryCall->getParent(); for (BasicBlock *Pred : PredCache.get(QueryBB)) DirtyBlocks.push_back(Pred); ++NumUncacheNonLocal; } // isReadonlyCall - If this is a read-only call, we can be more aggressive. - bool isReadonlyCall = AA.onlyReadsMemory(QueryCS); + bool isReadonlyCall = AA.onlyReadsMemory(QueryCall); SmallPtrSet<BasicBlock *, 32> Visited; @@ -865,8 +863,8 @@ MemoryDependenceResults::getNonLocalCallDependency(CallSite QueryCS) { if (Instruction *Inst = ExistingResult->getResult().getInst()) { ScanPos = Inst->getIterator(); // We're removing QueryInst's use of Inst. - RemoveFromReverseMap(ReverseNonLocalDeps, Inst, - QueryCS.getInstruction()); + RemoveFromReverseMap<Instruction *>(ReverseNonLocalDeps, Inst, + QueryCall); } } @@ -874,8 +872,7 @@ MemoryDependenceResults::getNonLocalCallDependency(CallSite QueryCS) { MemDepResult Dep; if (ScanPos != DirtyBB->begin()) { - Dep = - getCallSiteDependencyFrom(QueryCS, isReadonlyCall, ScanPos, DirtyBB); + Dep = getCallDependencyFrom(QueryCall, isReadonlyCall, ScanPos, DirtyBB); } else if (DirtyBB != &DirtyBB->getParent()->getEntryBlock()) { // No dependence found. If this is the entry block of the function, it is // a clobber, otherwise it is unknown. @@ -897,7 +894,7 @@ MemoryDependenceResults::getNonLocalCallDependency(CallSite QueryCS) { // Keep the ReverseNonLocalDeps map up to date so we can efficiently // update this when we remove instructions. if (Instruction *Inst = Dep.getInst()) - ReverseNonLocalDeps[Inst].insert(QueryCS.getInstruction()); + ReverseNonLocalDeps[Inst].insert(QueryCall); } else { // If the block *is* completely transparent to the load, we need to check diff --git a/llvm/lib/Analysis/MemoryLocation.cpp b/llvm/lib/Analysis/MemoryLocation.cpp index c15ed680e0a..27e8d72b8e8 100644 --- a/llvm/lib/Analysis/MemoryLocation.cpp +++ b/llvm/lib/Analysis/MemoryLocation.cpp @@ -125,15 +125,15 @@ MemoryLocation MemoryLocation::getForDest(const AnyMemIntrinsic *MI) { return MemoryLocation(MI->getRawDest(), Size, AATags); } -MemoryLocation MemoryLocation::getForArgument(ImmutableCallSite CS, +MemoryLocation MemoryLocation::getForArgument(const CallBase *Call, unsigned ArgIdx, const TargetLibraryInfo *TLI) { AAMDNodes AATags; - CS->getAAMetadata(AATags); - const Value *Arg = CS.getArgument(ArgIdx); + Call->getAAMetadata(AATags); + const Value *Arg = Call->getArgOperand(ArgIdx); // We may be able to produce an exact size for known intrinsics. - if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) { + if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Call)) { const DataLayout &DL = II->getModule()->getDataLayout(); switch (II->getIntrinsicID()) { @@ -193,19 +193,20 @@ MemoryLocation MemoryLocation::getForArgument(ImmutableCallSite CS, // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16 // whenever possible. LibFunc F; - if (TLI && CS.getCalledFunction() && - TLI->getLibFunc(*CS.getCalledFunction(), F) && + if (TLI && Call->getCalledFunction() && + TLI->getLibFunc(*Call->getCalledFunction(), F) && F == LibFunc_memset_pattern16 && TLI->has(F)) { assert((ArgIdx == 0 || ArgIdx == 1) && "Invalid argument index for memset_pattern16"); if (ArgIdx == 1) return MemoryLocation(Arg, LocationSize::precise(16), AATags); - if (const ConstantInt *LenCI = dyn_cast<ConstantInt>(CS.getArgument(2))) + if (const ConstantInt *LenCI = + dyn_cast<ConstantInt>(Call->getArgOperand(2))) return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()), AATags); } // FIXME: Handle memset_pattern4 and memset_pattern8 also. - return MemoryLocation(CS.getArgument(ArgIdx), LocationSize::unknown(), + return MemoryLocation(Call->getArgOperand(ArgIdx), LocationSize::unknown(), AATags); } diff --git a/llvm/lib/Analysis/MemorySSA.cpp b/llvm/lib/Analysis/MemorySSA.cpp index 3d98fca823a..7c5cd163627 100644 --- a/llvm/lib/Analysis/MemorySSA.cpp +++ b/llvm/lib/Analysis/MemorySSA.cpp @@ -30,7 +30,6 @@ #include "llvm/Config/llvm-config.h" #include "llvm/IR/AssemblyAnnotationWriter.h" #include "llvm/IR/BasicBlock.h" -#include "llvm/IR/CallSite.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/Function.h" #include "llvm/IR/Instruction.h" @@ -131,9 +130,9 @@ public: : MemoryLocOrCall(MUD->getMemoryInst()) {} MemoryLocOrCall(Instruction *Inst) { - if (ImmutableCallSite(Inst)) { + if (auto *C = dyn_cast<CallBase>(Inst)) { IsCall = true; - CS = ImmutableCallSite(Inst); + Call = C; } else { IsCall = false; // There is no such thing as a memorylocation for a fence inst, and it is @@ -145,9 +144,9 @@ public: explicit MemoryLocOrCall(const MemoryLocation &Loc) : Loc(Loc) {} - ImmutableCallSite getCS() const { + const CallBase *getCall() const { assert(IsCall); - return CS; + return Call; } MemoryLocation getLoc() const { @@ -162,16 +161,17 @@ public: if (!IsCall) return Loc == Other.Loc; - if (CS.getCalledValue() != Other.CS.getCalledValue()) + if (Call->getCalledValue() != Other.Call->getCalledValue()) return false; - return CS.arg_size() == Other.CS.arg_size() && - std::equal(CS.arg_begin(), CS.arg_end(), Other.CS.arg_begin()); + return Call->arg_size() == Other.Call->arg_size() && + std::equal(Call->arg_begin(), Call->arg_end(), + Other.Call->arg_begin()); } private: union { - ImmutableCallSite CS; + const CallBase *Call; MemoryLocation Loc; }; }; @@ -197,9 +197,9 @@ template <> struct DenseMapInfo<MemoryLocOrCall> { hash_code hash = hash_combine(MLOC.IsCall, DenseMapInfo<const Value *>::getHashValue( - MLOC.getCS().getCalledValue())); + MLOC.getCall()->getCalledValue())); - for (const Value *Arg : MLOC.getCS().args()) + for (const Value *Arg : MLOC.getCall()->args()) hash = hash_combine(hash, DenseMapInfo<const Value *>::getHashValue(Arg)); return hash; } @@ -258,7 +258,7 @@ static ClobberAlias instructionClobbersQuery(const MemoryDef *MD, AliasAnalysis &AA) { Instruction *DefInst = MD->getMemoryInst(); assert(DefInst && "Defining instruction not actually an instruction"); - ImmutableCallSite UseCS(UseInst); + const auto *UseCall = dyn_cast<CallBase>(UseInst); Optional<AliasResult> AR; if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(DefInst)) { @@ -271,7 +271,7 @@ static ClobberAlias instructionClobbersQuery(const MemoryDef *MD, // context. switch (II->getIntrinsicID()) { case Intrinsic::lifetime_start: - if (UseCS) + if (UseCall) return {false, NoAlias}; AR = AA.alias(MemoryLocation(II->getArgOperand(1)), UseLoc); return {AR != NoAlias, AR}; @@ -285,8 +285,8 @@ static ClobberAlias instructionClobbersQuery(const MemoryDef *MD, } } - if (UseCS) { - ModRefInfo I = AA.getModRefInfo(DefInst, UseCS); + if (UseCall) { + ModRefInfo I = AA.getModRefInfo(DefInst, UseCall); AR = isMustSet(I) ? MustAlias : MayAlias; return {isModOrRefSet(I), AR}; } @@ -336,7 +336,7 @@ struct UpwardsMemoryQuery { UpwardsMemoryQuery() = default; UpwardsMemoryQuery(const Instruction *Inst, const MemoryAccess *Access) - : IsCall(ImmutableCallSite(Inst)), Inst(Inst), OriginalAccess(Access) { + : IsCall(isa<CallBase>(Inst)), Inst(Inst), OriginalAccess(Access) { if (!IsCall) StartingLoc = MemoryLocation::get(Inst); } @@ -2162,7 +2162,7 @@ MemoryAccess *MemorySSA::CachingWalker::getClobberingMemoryAccess( // Conservatively, fences are always clobbers, so don't perform the walk if we // hit a fence. - if (!ImmutableCallSite(I) && I->isFenceLike()) + if (!isa<CallBase>(I) && I->isFenceLike()) return StartingUseOrDef; UpwardsMemoryQuery Q; @@ -2202,7 +2202,7 @@ MemorySSA::CachingWalker::getClobberingMemoryAccess(MemoryAccess *MA) { // We can't sanely do anything with a fence, since they conservatively clobber // all memory, and have no locations to get pointers from to try to // disambiguate. - if (!ImmutableCallSite(I) && I->isFenceLike()) + if (!isa<CallBase>(I) && I->isFenceLike()) return StartingAccess; UpwardsMemoryQuery Q(I, StartingAccess); diff --git a/llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp b/llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp index 096ea661ecb..95ae1a6e744 100644 --- a/llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp +++ b/llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp @@ -106,12 +106,12 @@ FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) { return AAResultBase::getModRefBehavior(F); } -ModRefInfo ObjCARCAAResult::getModRefInfo(ImmutableCallSite CS, +ModRefInfo ObjCARCAAResult::getModRefInfo(const CallBase *Call, const MemoryLocation &Loc) { if (!EnableARCOpts) - return AAResultBase::getModRefInfo(CS, Loc); + return AAResultBase::getModRefInfo(Call, Loc); - switch (GetBasicARCInstKind(CS.getInstruction())) { + switch (GetBasicARCInstKind(Call)) { case ARCInstKind::Retain: case ARCInstKind::RetainRV: case ARCInstKind::Autorelease: @@ -128,7 +128,7 @@ ModRefInfo ObjCARCAAResult::getModRefInfo(ImmutableCallSite CS, break; } - return AAResultBase::getModRefInfo(CS, Loc); + return AAResultBase::getModRefInfo(Call, Loc); } ObjCARCAAResult ObjCARCAA::run(Function &F, FunctionAnalysisManager &AM) { diff --git a/llvm/lib/Analysis/ScopedNoAliasAA.cpp b/llvm/lib/Analysis/ScopedNoAliasAA.cpp index f12275aff38..9a581fe46af 100644 --- a/llvm/lib/Analysis/ScopedNoAliasAA.cpp +++ b/llvm/lib/Analysis/ScopedNoAliasAA.cpp @@ -95,39 +95,36 @@ AliasResult ScopedNoAliasAAResult::alias(const MemoryLocation &LocA, return AAResultBase::alias(LocA, LocB); } -ModRefInfo ScopedNoAliasAAResult::getModRefInfo(ImmutableCallSite CS, +ModRefInfo ScopedNoAliasAAResult::getModRefInfo(const CallBase *Call, const MemoryLocation &Loc) { if (!EnableScopedNoAlias) - return AAResultBase::getModRefInfo(CS, Loc); + return AAResultBase::getModRefInfo(Call, Loc); - if (!mayAliasInScopes(Loc.AATags.Scope, CS.getInstruction()->getMetadata( - LLVMContext::MD_noalias))) + if (!mayAliasInScopes(Loc.AATags.Scope, + Call->getMetadata(LLVMContext::MD_noalias))) return ModRefInfo::NoModRef; - if (!mayAliasInScopes( - CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope), - Loc.AATags.NoAlias)) + if (!mayAliasInScopes(Call->getMetadata(LLVMContext::MD_alias_scope), + Loc.AATags.NoAlias)) return ModRefInfo::NoModRef; - return AAResultBase::getModRefInfo(CS, Loc); + return AAResultBase::getModRefInfo(Call, Loc); } -ModRefInfo ScopedNoAliasAAResult::getModRefInfo(ImmutableCallSite CS1, - ImmutableCallSite CS2) { +ModRefInfo ScopedNoAliasAAResult::getModRefInfo(const CallBase *Call1, + const CallBase *Call2) { if (!EnableScopedNoAlias) - return AAResultBase::getModRefInfo(CS1, CS2); + return AAResultBase::getModRefInfo(Call1, Call2); - if (!mayAliasInScopes( - CS1.getInstruction()->getMetadata(LLVMContext::MD_alias_scope), - CS2.getInstruction()->getMetadata(LLVMContext::MD_noalias))) + if (!mayAliasInScopes(Call1->getMetadata(LLVMContext::MD_alias_scope), + Call2->getMetadata(LLVMContext::MD_noalias))) return ModRefInfo::NoModRef; - if (!mayAliasInScopes( - CS2.getInstruction()->getMetadata(LLVMContext::MD_alias_scope), - CS1.getInstruction()->getMetadata(LLVMContext::MD_noalias))) + if (!mayAliasInScopes(Call2->getMetadata(LLVMContext::MD_alias_scope), + Call1->getMetadata(LLVMContext::MD_noalias))) return ModRefInfo::NoModRef; - return AAResultBase::getModRefInfo(CS1, CS2); + return AAResultBase::getModRefInfo(Call1, Call2); } static void collectMDInDomain(const MDNode *List, const MDNode *Domain, diff --git a/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp b/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp index 25a154edf4a..83974da30a5 100644 --- a/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp +++ b/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp @@ -399,20 +399,20 @@ bool TypeBasedAAResult::pointsToConstantMemory(const MemoryLocation &Loc, } FunctionModRefBehavior -TypeBasedAAResult::getModRefBehavior(ImmutableCallSite CS) { +TypeBasedAAResult::getModRefBehavior(const CallBase *Call) { if (!EnableTBAA) - return AAResultBase::getModRefBehavior(CS); + return AAResultBase::getModRefBehavior(Call); FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior; // If this is an "immutable" type, we can assume the call doesn't write // to memory. - if (const MDNode *M = CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa)) + if (const MDNode *M = Call->getMetadata(LLVMContext::MD_tbaa)) if ((!isStructPathTBAA(M) && TBAANode(M).isTypeImmutable()) || (isStructPathTBAA(M) && TBAAStructTagNode(M).isTypeImmutable())) Min = FMRB_OnlyReadsMemory; - return FunctionModRefBehavior(AAResultBase::getModRefBehavior(CS) & Min); + return FunctionModRefBehavior(AAResultBase::getModRefBehavior(Call) & Min); } FunctionModRefBehavior TypeBasedAAResult::getModRefBehavior(const Function *F) { @@ -420,33 +420,30 @@ FunctionModRefBehavior TypeBasedAAResult::getModRefBehavior(const Function *F) { return AAResultBase::getModRefBehavior(F); } -ModRefInfo TypeBasedAAResult::getModRefInfo(ImmutableCallSite CS, +ModRefInfo TypeBasedAAResult::getModRefInfo(const CallBase *Call, const MemoryLocation &Loc) { if (!EnableTBAA) - return AAResultBase::getModRefInfo(CS, Loc); + return AAResultBase::getModRefInfo(Call, Loc); if (const MDNode *L = Loc.AATags.TBAA) - if (const MDNode *M = - CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa)) + if (const MDNode *M = Call->getMetadata(LLVMContext::MD_tbaa)) if (!Aliases(L, M)) return ModRefInfo::NoModRef; - return AAResultBase::getModRefInfo(CS, Loc); + return AAResultBase::getModRefInfo(Call, Loc); } -ModRefInfo TypeBasedAAResult::getModRefInfo(ImmutableCallSite CS1, - ImmutableCallSite CS2) { +ModRefInfo TypeBasedAAResult::getModRefInfo(const CallBase *Call1, + const CallBase *Call2) { if (!EnableTBAA) - return AAResultBase::getModRefInfo(CS1, CS2); + return AAResultBase::getModRefInfo(Call1, Call2); - if (const MDNode *M1 = - CS1.getInstruction()->getMetadata(LLVMContext::MD_tbaa)) - if (const MDNode *M2 = - CS2.getInstruction()->getMetadata(LLVMContext::MD_tbaa)) + if (const MDNode *M1 = Call1->getMetadata(LLVMContext::MD_tbaa)) + if (const MDNode *M2 = Call2->getMetadata(LLVMContext::MD_tbaa)) if (!Aliases(M1, M2)) return ModRefInfo::NoModRef; - return AAResultBase::getModRefInfo(CS1, CS2); + return AAResultBase::getModRefInfo(Call1, Call2); } bool MDNode::isTBAAVtableAccess() const { diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp index 3c4cf1d88f9..0446426c0e6 100644 --- a/llvm/lib/Analysis/ValueTracking.cpp +++ b/llvm/lib/Analysis/ValueTracking.cpp @@ -2023,10 +2023,10 @@ bool isKnownNonZero(const Value *V, unsigned Depth, const Query &Q) { if (Q.IIQ.getMetadata(LI, LLVMContext::MD_nonnull)) return true; - if (auto CS = ImmutableCallSite(V)) { - if (CS.isReturnNonNull()) + if (const auto *Call = dyn_cast<CallBase>(V)) { + if (Call->isReturnNonNull()) return true; - if (const auto *RP = getArgumentAliasingToReturnedPointer(CS)) + if (const auto *RP = getArgumentAliasingToReturnedPointer(Call)) return isKnownNonZero(RP, Depth, Q); } } @@ -3624,21 +3624,21 @@ uint64_t llvm::GetStringLength(const Value *V, unsigned CharSize) { return Len == ~0ULL ? 1 : Len; } -const Value *llvm::getArgumentAliasingToReturnedPointer(ImmutableCallSite CS) { - assert(CS && - "getArgumentAliasingToReturnedPointer only works on nonnull CallSite"); - if (const Value *RV = CS.getReturnedArgOperand()) +const Value *llvm::getArgumentAliasingToReturnedPointer(const CallBase *Call) { + assert(Call && + "getArgumentAliasingToReturnedPointer only works on nonnull calls"); + if (const Value *RV = Call->getReturnedArgOperand()) return RV; // This can be used only as a aliasing property. - if (isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(CS)) - return CS.getArgOperand(0); + if (isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(Call)) + return Call->getArgOperand(0); return nullptr; } bool llvm::isIntrinsicReturningPointerAliasingArgumentWithoutCapturing( - ImmutableCallSite CS) { - return CS.getIntrinsicID() == Intrinsic::launder_invariant_group || - CS.getIntrinsicID() == Intrinsic::strip_invariant_group; + const CallBase *Call) { + return Call->getIntrinsicID() == Intrinsic::launder_invariant_group || + Call->getIntrinsicID() == Intrinsic::strip_invariant_group; } /// \p PN defines a loop-variant pointer to an object. Check if the @@ -3686,7 +3686,7 @@ Value *llvm::GetUnderlyingObject(Value *V, const DataLayout &DL, // An alloca can't be further simplified. return V; } else { - if (auto CS = CallSite(V)) { + if (auto *Call = dyn_cast<CallBase>(V)) { // CaptureTracking can know about special capturing properties of some // intrinsics like launder.invariant.group, that can't be expressed with // the attributes, but have properties like returning aliasing pointer. @@ -3696,7 +3696,7 @@ Value *llvm::GetUnderlyingObject(Value *V, const DataLayout &DL, // because it should be in sync with CaptureTracking. Not using it may // cause weird miscompilations where 2 aliasing pointers are assumed to // noalias. - if (auto *RP = getArgumentAliasingToReturnedPointer(CS)) { + if (auto *RP = getArgumentAliasingToReturnedPointer(Call)) { V = RP; continue; } |