CbC/CbC_llvm: lib/Transforms/IPO/FunctionAttrs.cpp comparison

comparison lib/Transforms/IPO/FunctionAttrs.cpp @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children	3a76565eade5

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-///
+//
 /// \file
 /// This file implements interprocedural passes which walk the
 /// call-graph deducing and/or propagating function attributes.
-///
+//
 //===----------------------------------------------------------------------===//
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
-#include "llvm/Transforms/IPO.h"
 #include "llvm/ADT/SCCIterator.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
-#include "llvm/ADT/StringSwitch.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
+#include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/CaptureTracking.h"
-#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Analysis/LazyCallGraph.h"
+#include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/Analysis/ValueTracking.h"
-#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/Argument.h"
+#include "llvm/IR/Attributes.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/CallSite.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
-#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/InstrTypes.h"
-#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Metadata.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/Type.h"
+#include "llvm/IR/Use.h"
+#include "llvm/IR/User.h"
+#include "llvm/IR/Value.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Transforms/IPO.h"
+#include <cassert>
+#include <iterator>
+#include <map>
+#include <vector>
 using namespace llvm;
 #define DEBUG_TYPE "functionattrs"
 STATISTIC(NumReadNone, "Number of functions marked readnone");
 STATISTIC(NumReadOnlyArg, "Number of arguments marked readonly");
 STATISTIC(NumNoAlias, "Number of function returns marked noalias");
 STATISTIC(NumNonNullReturn, "Number of function returns marked nonnull");
 STATISTIC(NumNoRecurse, "Number of functions marked as norecurse");
+// FIXME: This is disabled by default to avoid exposing security vulnerabilities
+// in C/C++ code compiled by clang:
+// http://lists.llvm.org/pipermail/cfe-dev/2017-January/052066.html
+static cl::opt<bool> EnableNonnullArgPropagation(
+"enable-nonnull-arg-prop", cl::Hidden,
+cl::desc("Try to propagate nonnull argument attributes from callsites to "
+"caller functions."));
 namespace {
-typedef SmallSetVector<Function *, 8> SCCNodeSet;
-}
+using SCCNodeSet = SmallSetVector<Function *, 8>;
-namespace {
+} // end anonymous namespace
-/// The three kinds of memory access relevant to 'readonly' and
-/// 'readnone' attributes.
+/// Returns the memory access attribute for function F using AAR for AA results,
-enum MemoryAccessKind {
+/// where SCCNodes is the current SCC.
-MAK_ReadNone = 0,
+///
-MAK_ReadOnly = 1,
+/// If ThisBody is true, this function may examine the function body and will
-MAK_MayWrite = 2
+/// return a result pertaining to this copy of the function. If it is false, the
-};
+/// result will be based only on AA results for the function declaration; it
-}
+/// will be assumed that some other (perhaps less optimized) version of the
+/// function may be selected at link time.
-static MemoryAccessKind checkFunctionMemoryAccess(Function &F, AAResults &AAR,
+static MemoryAccessKind checkFunctionMemoryAccess(Function &F, bool ThisBody,
+AAResults &AAR,
 const SCCNodeSet &SCCNodes) {
 FunctionModRefBehavior MRB = AAR.getModRefBehavior(&F);
 if (MRB == FMRB_DoesNotAccessMemory)
 // Already perfect!
 return MAK_ReadNone;
-// Non-exact function definitions may not be selected at link time, and an
+if (!ThisBody) {
-// alternative version that writes to memory may be selected.  See the comment
-// on GlobalValue::isDefinitionExact for more details.
-if (!F.hasExactDefinition()) {
 if (AliasAnalysis::onlyReadsMemory(MRB))
 return MAK_ReadOnly;
 // Conservatively assume it writes to memory.
 return MAK_MayWrite;
 }
 return ReadsMemory ? MAK_ReadOnly : MAK_ReadNone;
 }
+MemoryAccessKind llvm::computeFunctionBodyMemoryAccess(Function &F,
+AAResults &AAR) {
+return checkFunctionMemoryAccess(F, /*ThisBody=*/true, AAR, {});
+}
 /// Deduce readonly/readnone attributes for the SCC.
 template <typename AARGetterT>
-static bool addReadAttrs(const SCCNodeSet &SCCNodes, AARGetterT AARGetter) {
+static bool addReadAttrs(const SCCNodeSet &SCCNodes, AARGetterT &&AARGetter) {
 // Check if any of the functions in the SCC read or write memory.  If they
 // write memory then they can't be marked readnone or readonly.
 bool ReadsMemory = false;
 for (Function *F : SCCNodes) {
 // Call the callable parameter to look up AA results for this function.
 AAResults &AAR = AARGetter(*F);
-switch (checkFunctionMemoryAccess(*F, AAR, SCCNodes)) {
+// Non-exact function definitions may not be selected at link time, and an
+// alternative version that writes to memory may be selected.  See the
+// comment on GlobalValue::isDefinitionExact for more details.
+switch (checkFunctionMemoryAccess(*F, F->hasExactDefinition(),
+AAR, SCCNodes)) {
 case MAK_MayWrite:
 return false;
 case MAK_ReadOnly:
 ReadsMemory = true;
 break;
 continue;
 MadeChange = true;
 // Clear out any existing attributes.
-AttrBuilder B;
+F->removeFnAttr(Attribute::ReadOnly);
-B.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone);
+F->removeFnAttr(Attribute::ReadNone);
-F->removeAttributes(
-AttributeSet::FunctionIndex,
-AttributeSet::get(F->getContext(), AttributeSet::FunctionIndex, B));
 // Add in the new attribute.
-F->addAttribute(AttributeSet::FunctionIndex,
+F->addFnAttr(ReadsMemory ? Attribute::ReadOnly : Attribute::ReadNone);
-ReadsMemory ? Attribute::ReadOnly : Attribute::ReadNone);
 if (ReadsMemory)
 ++NumReadOnly;
 else
 ++NumReadNone;
 return MadeChange;
 }
 namespace {
 /// For a given pointer Argument, this retains a list of Arguments of functions
 /// in the same SCC that the pointer data flows into. We use this to build an
 /// SCC of the arguments.
 struct ArgumentGraphNode {
 Argument *Definition;
 };
 class ArgumentGraph {
 // We store pointers to ArgumentGraphNode objects, so it's important that
 // that they not move around upon insert.
-typedef std::map<Argument *, ArgumentGraphNode> ArgumentMapTy;
+using ArgumentMapTy = std::map<Argument *, ArgumentGraphNode>;
 ArgumentMapTy ArgumentMap;
 // There is no root node for the argument graph, in fact:
 //   void f(int *x, int *y) { if (...) f(x, y); }
 ArgumentGraphNode SyntheticRoot;
 public:
 ArgumentGraph() { SyntheticRoot.Definition = nullptr; }
-typedef SmallVectorImpl<ArgumentGraphNode *>::iterator iterator;
+using iterator = SmallVectorImpl<ArgumentGraphNode *>::iterator;
 iterator begin() { return SyntheticRoot.Uses.begin(); }
 iterator end() { return SyntheticRoot.Uses.end(); }
 ArgumentGraphNode *getEntryNode() { return &SyntheticRoot; }
 /// This tracker checks whether callees are in the SCC, and if so it does not
 /// consider that a capture, instead adding it to the "Uses" list and
 /// continuing with the analysis.
 struct ArgumentUsesTracker : public CaptureTracker {
-ArgumentUsesTracker(const SCCNodeSet &SCCNodes)
+ArgumentUsesTracker(const SCCNodeSet &SCCNodes) : SCCNodes(SCCNodes) {}
-: Captured(false), SCCNodes(SCCNodes) {}
 void tooManyUses() override { Captured = true; }
 bool captured(const Use *U) override {
 CallSite CS(U->getUser());
 Uses.push_back(&*std::next(F->arg_begin(), UseIndex));
 return false;
 }
-bool Captured; // True only if certainly captured (used outside our SCC).
+// True only if certainly captured (used outside our SCC).
-SmallVector<Argument *, 4> Uses; // Uses within our SCC.
+bool Captured = false;
+// Uses within our SCC.
+SmallVector<Argument *, 4> Uses;
 const SCCNodeSet &SCCNodes;
 };
-}
+} // end anonymous namespace
 namespace llvm {
 template <> struct GraphTraits<ArgumentGraphNode *> {
-typedef ArgumentGraphNode *NodeRef;
+using NodeRef = ArgumentGraphNode *;
-typedef SmallVectorImpl<ArgumentGraphNode *>::iterator ChildIteratorType;
+using ChildIteratorType = SmallVectorImpl<ArgumentGraphNode *>::iterator;
 static NodeRef getEntryNode(NodeRef A) { return A; }
 static ChildIteratorType child_begin(NodeRef N) { return N->Uses.begin(); }
 static ChildIteratorType child_end(NodeRef N) { return N->Uses.end(); }
 };
 template <>
 struct GraphTraits<ArgumentGraph *> : public GraphTraits<ArgumentGraphNode *> {
 static NodeRef getEntryNode(ArgumentGraph *AG) { return AG->getEntryNode(); }
 static ChildIteratorType nodes_begin(ArgumentGraph *AG) {
 return AG->begin();
 }
 static ChildIteratorType nodes_end(ArgumentGraph *AG) { return AG->end(); }
 };
-}
+} // end namespace llvm
 /// Returns Attribute::None, Attribute::ReadOnly or Attribute::ReadNone.
 static Attribute::AttrKind
 determinePointerReadAttrs(Argument *A,
 const SmallPtrSet<Argument *, 8> &SCCNodes) {
 SmallVector<Use *, 32> Worklist;
 SmallSet<Use *, 32> Visited;
 // inalloca arguments are always clobbered by the call.
 if (A->hasInAllocaAttr())
 /// Deduce returned attributes for the SCC.
 static bool addArgumentReturnedAttrs(const SCCNodeSet &SCCNodes) {
 bool Changed = false;
-AttrBuilder B;
-B.addAttribute(Attribute::Returned);
 // Check each function in turn, determining if an argument is always returned.
 for (Function *F : SCCNodes) {
 // We can infer and propagate function attributes only when we know that the
 // definition we'll get at link time is *exactly* the definition we see now.
 // For more details, see GlobalValue::mayBeDerefined.
 if (F->getReturnType()->isVoidTy())
 continue;
 // There is nothing to do if an argument is already marked as 'returned'.
-if (any_of(F->args(),
+if (llvm::any_of(F->args(),
 [](const Argument &Arg) { return Arg.hasReturnedAttr(); }))
 continue;
 auto FindRetArg = [&]() -> Value * {
 Value *RetArg = nullptr;
 for (BasicBlock &BB : *F)
 return RetArg;
 };
 if (Value *RetArg = FindRetArg()) {
 auto *A = cast<Argument>(RetArg);
-A->addAttr(AttributeSet::get(F->getContext(), A->getArgNo() + 1, B));
+A->addAttr(Attribute::Returned);
 ++NumReturned;
 Changed = true;
 }
 }
+return Changed;
+}
+/// If a callsite has arguments that are also arguments to the parent function,
+/// try to propagate attributes from the callsite's arguments to the parent's
+/// arguments. This may be important because inlining can cause information loss
+/// when attribute knowledge disappears with the inlined call.
+static bool addArgumentAttrsFromCallsites(Function &F) {
+if (!EnableNonnullArgPropagation)
+return false;
+bool Changed = false;
+// For an argument attribute to transfer from a callsite to the parent, the
+// call must be guaranteed to execute every time the parent is called.
+// Conservatively, just check for calls in the entry block that are guaranteed
+// to execute.
+// TODO: This could be enhanced by testing if the callsite post-dominates the
+// entry block or by doing simple forward walks or backward walks to the
+// callsite.
+BasicBlock &Entry = F.getEntryBlock();
+for (Instruction &I : Entry) {
+if (auto CS = CallSite(&I)) {
+if (auto *CalledFunc = CS.getCalledFunction()) {
+for (auto &CSArg : CalledFunc->args()) {
+if (!CSArg.hasNonNullAttr())
+continue;
+// If the non-null callsite argument operand is an argument to 'F'
+// (the caller) and the call is guaranteed to execute, then the value
+// must be non-null throughout 'F'.
+auto *FArg = dyn_cast<Argument>(CS.getArgOperand(CSArg.getArgNo()));
+if (FArg && !FArg->hasNonNullAttr()) {
+FArg->addAttr(Attribute::NonNull);
+Changed = true;
+}
+}
+}
+}
+if (!isGuaranteedToTransferExecutionToSuccessor(&I))
+break;
+}
 return Changed;
 }
 /// Deduce nocapture attributes for the SCC.
 static bool addArgumentAttrs(const SCCNodeSet &SCCNodes) {
 bool Changed = false;
 ArgumentGraph AG;
-AttrBuilder B;
-B.addAttribute(Attribute::NoCapture);
 // Check each function in turn, determining which pointer arguments are not
 // captured.
 for (Function *F : SCCNodes) {
 // We can infer and propagate function attributes only when we know that the
 // definition we'll get at link time is *exactly* the definition we see now.
 // For more details, see GlobalValue::mayBeDerefined.
 if (!F->hasExactDefinition())
 continue;
+Changed |= addArgumentAttrsFromCallsites(*F);
 // Functions that are readonly (or readnone) and nounwind and don't return
 // a value can't capture arguments. Don't analyze them.
 if (F->onlyReadsMemory() && F->doesNotThrow() &&
 F->getReturnType()->isVoidTy()) {
 for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E;
 ++A) {
 if (A->getType()->isPointerTy() && !A->hasNoCaptureAttr()) {
-A->addAttr(AttributeSet::get(F->getContext(), A->getArgNo() + 1, B));
+A->addAttr(Attribute::NoCapture);
 ++NumNoCapture;
 Changed = true;
 }
 }
 continue;
 ArgumentUsesTracker Tracker(SCCNodes);
 PointerMayBeCaptured(&*A, &Tracker);
 if (!Tracker.Captured) {
 if (Tracker.Uses.empty()) {
 // If it's trivially not captured, mark it nocapture now.
-A->addAttr(
+A->addAttr(Attribute::NoCapture);
-AttributeSet::get(F->getContext(), A->getArgNo() + 1, B));
 ++NumNoCapture;
 Changed = true;
 } else {
 // If it's not trivially captured and not trivially not captured,
 // then it must be calling into another function in our SCC. Save
 // SCC.
 SmallPtrSet<Argument *, 8> Self;
 Self.insert(&*A);
 Attribute::AttrKind R = determinePointerReadAttrs(&*A, Self);
 if (R != Attribute::None) {
-AttrBuilder B;
+A->addAttr(R);
-B.addAttribute(R);
-A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B));
 Changed = true;
 R == Attribute::ReadOnly ? ++NumReadOnlyArg : ++NumReadNoneArg;
 }
 }
 }
 // eg. "void f(int* x) { if (...) f(x); }"
 if (ArgumentSCC[0]->Uses.size() == 1 &&
 ArgumentSCC[0]->Uses[0] == ArgumentSCC[0]) {
 Argument *A = ArgumentSCC[0]->Definition;
-A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B));
+A->addAttr(Attribute::NoCapture);
 ++NumNoCapture;
 Changed = true;
 }
 continue;
 }
 if (SCCCaptured)
 continue;
 for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
 Argument *A = ArgumentSCC[i]->Definition;
-A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B));
+A->addAttr(Attribute::NoCapture);
 ++NumNoCapture;
 Changed = true;
 }
 // We also want to compute readonly/readnone. With a small number of false
 ReadAttr = K;
 break;
 }
 if (ReadAttr != Attribute::None) {
-AttrBuilder B, R;
-B.addAttribute(ReadAttr);
-R.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone);
 for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
 Argument *A = ArgumentSCC[i]->Definition;
 // Clear out existing readonly/readnone attributes
-A->removeAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, R));
+A->removeAttr(Attribute::ReadOnly);
-A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B));
+A->removeAttr(Attribute::ReadNone);
+A->addAttr(ReadAttr);
 ReadAttr == Attribute::ReadOnly ? ++NumReadOnlyArg : ++NumReadNoneArg;
 Changed = true;
 }
 }
 }
 case Instruction::Alloca:
 break;
 case Instruction::Call:
 case Instruction::Invoke: {
 CallSite CS(RVI);
-if (CS.paramHasAttr(0, Attribute::NoAlias))
+if (CS.hasRetAttr(Attribute::NoAlias))
 break;
 if (CS.getCalledFunction() && SCCNodes.count(CS.getCalledFunction()))
 break;
 LLVM_FALLTHROUGH;
 }
 static bool addNoAliasAttrs(const SCCNodeSet &SCCNodes) {
 // Check each function in turn, determining which functions return noalias
 // pointers.
 for (Function *F : SCCNodes) {
 // Already noalias.
-if (F->doesNotAlias(0))
+if (F->returnDoesNotAlias())
 continue;
 // We can infer and propagate function attributes only when we know that the
 // definition we'll get at link time is *exactly* the definition we see now.
 // For more details, see GlobalValue::mayBeDerefined.
 return false;
 }
 bool MadeChange = false;
 for (Function *F : SCCNodes) {
-if (F->doesNotAlias(0) || !F->getReturnType()->isPointerTy())
+if (F->returnDoesNotAlias() ||
-continue;
+!F->getReturnType()->isPointerTy())
+continue;
-F->setDoesNotAlias(0);
+F->setReturnDoesNotAlias();
 ++NumNoAlias;
 MadeChange = true;
 }
 return MadeChange;
 SmallSetVector<Value *, 8> FlowsToReturn;
 for (BasicBlock &BB : *F)
 if (auto *Ret = dyn_cast<ReturnInst>(BB.getTerminator()))
 FlowsToReturn.insert(Ret->getReturnValue());
+auto &DL = F->getParent()->getDataLayout();
 for (unsigned i = 0; i != FlowsToReturn.size(); ++i) {
 Value *RetVal = FlowsToReturn[i];
 // If this value is locally known to be non-null, we're good
-if (isKnownNonNull(RetVal))
+if (isKnownNonZero(RetVal, DL))
 continue;
 // Otherwise, we need to look upwards since we can't make any local
 // conclusions.
 Instruction *RVI = dyn_cast<Instruction>(RetVal);
 // Check each function in turn, determining which functions return nonnull
 // pointers.
 for (Function *F : SCCNodes) {
 // Already nonnull.
-if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
+if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
 Attribute::NonNull))
 continue;
 // We can infer and propagate function attributes only when we know that the
 // definition we'll get at link time is *exactly* the definition we see now.
 if (isReturnNonNull(F, SCCNodes, Speculative)) {
 if (!Speculative) {
 // Mark the function eagerly since we may discover a function
 // which prevents us from speculating about the entire SCC
 DEBUG(dbgs() << "Eagerly marking " << F->getName() << " as nonnull\n");
-F->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull);
+F->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
 ++NumNonNullReturn;
 MadeChange = true;
 }
 continue;
 }
 SCCReturnsNonNull = false;
 }
 if (SCCReturnsNonNull) {
 for (Function *F : SCCNodes) {
-if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
+if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
 Attribute::NonNull) ||
 !F->getReturnType()->isPointerTy())
 continue;
 DEBUG(dbgs() << "SCC marking " << F->getName() << " as nonnull\n");
-F->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull);
+F->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
 ++NumNonNullReturn;
 MadeChange = true;
 }
 }
 return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
 }
 namespace {
 struct PostOrderFunctionAttrsLegacyPass : public CallGraphSCCPass {
-static char ID; // Pass identification, replacement for typeid
+// Pass identification, replacement for typeid
+static char ID;
 PostOrderFunctionAttrsLegacyPass() : CallGraphSCCPass(ID) {
 initializePostOrderFunctionAttrsLegacyPassPass(
 *PassRegistry::getPassRegistry());
 }
 AU.addRequired<AssumptionCacheTracker>();
 getAAResultsAnalysisUsage(AU);
 CallGraphSCCPass::getAnalysisUsage(AU);
 }
 };
-}
+} // end anonymous namespace
 char PostOrderFunctionAttrsLegacyPass::ID = 0;
 INITIALIZE_PASS_BEGIN(PostOrderFunctionAttrsLegacyPass, "functionattrs",
 "Deduce function attributes", false, false)
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 }
 SCCNodes.insert(F);
 }
+// Skip it if the SCC only contains optnone functions.
+if (SCCNodes.empty())
+return Changed;
 Changed |= addArgumentReturnedAttrs(SCCNodes);
 Changed |= addReadAttrs(SCCNodes, AARGetter);
 Changed |= addArgumentAttrs(SCCNodes);
 // If we have no external nodes participating in the SCC, we can deduce some
 }
 bool PostOrderFunctionAttrsLegacyPass::runOnSCC(CallGraphSCC &SCC) {
 if (skipSCC(SCC))
 return false;
+return runImpl(SCC, LegacyAARGetter(*this));
-// We compute dedicated AA results for each function in the SCC as needed. We
-// use a lambda referencing external objects so that they live long enough to
-// be queried, but we re-use them each time.
-Optional<BasicAAResult> BAR;
-Optional<AAResults> AAR;
-auto AARGetter = [&](Function &F) -> AAResults & {
-BAR.emplace(createLegacyPMBasicAAResult(*this, F));
-AAR.emplace(createLegacyPMAAResults(*this, F, *BAR));
-return *AAR;
-};
-return runImpl(SCC, AARGetter);
 }
 namespace {
 struct ReversePostOrderFunctionAttrsLegacyPass : public ModulePass {
-static char ID; // Pass identification, replacement for typeid
+// Pass identification, replacement for typeid
+static char ID;
 ReversePostOrderFunctionAttrsLegacyPass() : ModulePass(ID) {
 initializeReversePostOrderFunctionAttrsLegacyPassPass(
 *PassRegistry::getPassRegistry());
 }
 AU.setPreservesCFG();
 AU.addRequired<CallGraphWrapperPass>();
 AU.addPreserved<CallGraphWrapperPass>();
 }
 };
-}
+} // end anonymous namespace
 char ReversePostOrderFunctionAttrsLegacyPass::ID = 0;
 INITIALIZE_PASS_BEGIN(ReversePostOrderFunctionAttrsLegacyPass, "rpo-functionattrs",
 "Deduce function attributes in RPO", false, false)
 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
 INITIALIZE_PASS_END(ReversePostOrderFunctionAttrsLegacyPass, "rpo-functionattrs",
 "Deduce function attributes in RPO", false, false)
 F->hasInternalLinkage())
 Worklist.push_back(F);
 }
 bool Changed = false;
-for (auto *F : reverse(Worklist))
+for (auto *F : llvm::reverse(Worklist))
 Changed |= addNoRecurseAttrsTopDown(*F);
 return Changed;
 }
 PreservedAnalyses
 ReversePostOrderFunctionAttrsPass::run(Module &M, ModuleAnalysisManager &AM) {
 auto &CG = AM.getResult<CallGraphAnalysis>(M);
-bool Changed = deduceFunctionAttributeInRPO(M, CG);
+if (!deduceFunctionAttributeInRPO(M, CG))
-// CallGraphAnalysis holds AssertingVH and must be invalidated eagerly so
-// that other passes don't delete stuff from under it.
-// FIXME: We need to invalidate this to avoid PR28400. Is there a better
-// solution?
-AM.invalidate<CallGraphAnalysis>(M);
-if (!Changed)
 return PreservedAnalyses::all();
 PreservedAnalyses PA;
 PA.preserve<CallGraphAnalysis>();
 return PA;
 }

Mercurial > hg > CbC > CbC_llvm

comparison lib/Transforms/IPO/FunctionAttrs.cpp @ 121:803732b1fca8