From 67bd697ef77533a1af0621293eebb3cd51addf65 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Fri, 14 Aug 2015 01:38:25 +0000 Subject: [PATCH 1/1] [PM/AA] Run clang-format over LibCallAliasAnalysis prior to making substantial changes needed for the new pass manager's AA integration. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@245000 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/LibCallAliasAnalysis.h | 88 ++++++++++---------- lib/Analysis/LibCallAliasAnalysis.cpp | 34 ++++---- 2 files changed, 62 insertions(+), 60 deletions(-) diff --git a/include/llvm/Analysis/LibCallAliasAnalysis.h b/include/llvm/Analysis/LibCallAliasAnalysis.h index 12b10a988eb..36d9e063312 100644 --- a/include/llvm/Analysis/LibCallAliasAnalysis.h +++ b/include/llvm/Analysis/LibCallAliasAnalysis.h @@ -19,53 +19,55 @@ #include "llvm/Pass.h" namespace llvm { - class LibCallInfo; - struct LibCallFunctionInfo; - - /// LibCallAliasAnalysis - Alias analysis driven from LibCallInfo. - struct LibCallAliasAnalysis : public FunctionPass, public AliasAnalysis { - static char ID; // Class identification - - LibCallInfo *LCI; - - explicit LibCallAliasAnalysis(LibCallInfo *LC = nullptr) - : FunctionPass(ID), LCI(LC) { - initializeLibCallAliasAnalysisPass(*PassRegistry::getPassRegistry()); - } - explicit LibCallAliasAnalysis(char &ID, LibCallInfo *LC) - : FunctionPass(ID), LCI(LC) { - initializeLibCallAliasAnalysisPass(*PassRegistry::getPassRegistry()); - } - ~LibCallAliasAnalysis() override; - ModRefInfo getModRefInfo(ImmutableCallSite CS, - const MemoryLocation &Loc) override; +class LibCallInfo; +struct LibCallFunctionInfo; - ModRefInfo getModRefInfo(ImmutableCallSite CS1, - ImmutableCallSite CS2) override { - // TODO: Could compare two direct calls against each other if we cared to. - return AliasAnalysis::getModRefInfo(CS1, CS2); - } +/// LibCallAliasAnalysis - Alias analysis driven from LibCallInfo. +struct LibCallAliasAnalysis : public FunctionPass, public AliasAnalysis { + static char ID; // Class identification - void getAnalysisUsage(AnalysisUsage &AU) const override; + LibCallInfo *LCI; - bool runOnFunction(Function &F) override; + explicit LibCallAliasAnalysis(LibCallInfo *LC = nullptr) + : FunctionPass(ID), LCI(LC) { + initializeLibCallAliasAnalysisPass(*PassRegistry::getPassRegistry()); + } + explicit LibCallAliasAnalysis(char &ID, LibCallInfo *LC) + : FunctionPass(ID), LCI(LC) { + initializeLibCallAliasAnalysisPass(*PassRegistry::getPassRegistry()); + } + ~LibCallAliasAnalysis() override; - /// getAdjustedAnalysisPointer - This method is used when a pass implements - /// an analysis interface through multiple inheritance. If needed, it - /// should override this to adjust the this pointer as needed for the - /// specified pass info. - void *getAdjustedAnalysisPointer(const void *PI) override { - if (PI == &AliasAnalysis::ID) - return (AliasAnalysis*)this; - return this; - } - - private: - ModRefInfo AnalyzeLibCallDetails(const LibCallFunctionInfo *FI, - ImmutableCallSite CS, - const MemoryLocation &Loc); - }; -} // End of llvm namespace + ModRefInfo getModRefInfo(ImmutableCallSite CS, + const MemoryLocation &Loc) override; + + ModRefInfo getModRefInfo(ImmutableCallSite CS1, + ImmutableCallSite CS2) override { + // TODO: Could compare two direct calls against each other if we cared to. + return AliasAnalysis::getModRefInfo(CS1, CS2); + } + + void getAnalysisUsage(AnalysisUsage &AU) const override; + + bool runOnFunction(Function &F) override; + + /// getAdjustedAnalysisPointer - This method is used when a pass implements + /// an analysis interface through multiple inheritance. If needed, it + /// should override this to adjust the this pointer as needed for the + /// specified pass info. + void *getAdjustedAnalysisPointer(const void *PI) override { + if (PI == &AliasAnalysis::ID) + return (AliasAnalysis *)this; + return this; + } + +private: + ModRefInfo AnalyzeLibCallDetails(const LibCallFunctionInfo *FI, + ImmutableCallSite CS, + const MemoryLocation &Loc); +}; + +} // End of llvm namespace #endif diff --git a/lib/Analysis/LibCallAliasAnalysis.cpp b/lib/Analysis/LibCallAliasAnalysis.cpp index c9e2585bd66..8e839e8ce75 100644 --- a/lib/Analysis/LibCallAliasAnalysis.cpp +++ b/lib/Analysis/LibCallAliasAnalysis.cpp @@ -27,13 +27,11 @@ FunctionPass *llvm::createLibCallAliasAnalysisPass(LibCallInfo *LCI) { return new LibCallAliasAnalysis(LCI); } -LibCallAliasAnalysis::~LibCallAliasAnalysis() { - delete LCI; -} +LibCallAliasAnalysis::~LibCallAliasAnalysis() { delete LCI; } void LibCallAliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { AliasAnalysis::getAnalysisUsage(AU); - AU.setPreservesAll(); // Does not transform code + AU.setPreservesAll(); // Does not transform code } bool LibCallAliasAnalysis::runOnFunction(Function &F) { @@ -61,52 +59,54 @@ LibCallAliasAnalysis::AnalyzeLibCallDetails(const LibCallFunctionInfo *FI, const LibCallFunctionInfo::LocationMRInfo *Details = FI->LocationDetails; if (Details == nullptr) return MRInfo; - + // If the details array is of the 'DoesNot' kind, we only know something if // the pointer is a match for one of the locations in 'Details'. If we find a // match, we can prove some interactions cannot happen. - // + // if (FI->DetailsType == LibCallFunctionInfo::DoesNot) { // Find out if the pointer refers to a known location. for (unsigned i = 0; Details[i].LocationID != ~0U; ++i) { const LibCallLocationInfo &LocInfo = - LCI->getLocationInfo(Details[i].LocationID); + LCI->getLocationInfo(Details[i].LocationID); LibCallLocationInfo::LocResult Res = LocInfo.isLocation(CS, Loc); - if (Res != LibCallLocationInfo::Yes) continue; - + if (Res != LibCallLocationInfo::Yes) + continue; + // If we find a match against a location that we 'do not' interact with, // learn this info into MRInfo. return ModRefInfo(MRInfo & ~Details[i].MRInfo); } return MRInfo; } - + // If the details are of the 'DoesOnly' sort, we know something if the pointer // is a match for one of the locations in 'Details'. Also, if we can prove // that the pointers is *not* one of the locations in 'Details', we know that // the call is MRI_NoModRef. assert(FI->DetailsType == LibCallFunctionInfo::DoesOnly); - + // Find out if the pointer refers to a known location. bool NoneMatch = true; for (unsigned i = 0; Details[i].LocationID != ~0U; ++i) { const LibCallLocationInfo &LocInfo = - LCI->getLocationInfo(Details[i].LocationID); + LCI->getLocationInfo(Details[i].LocationID); LibCallLocationInfo::LocResult Res = LocInfo.isLocation(CS, Loc); - if (Res == LibCallLocationInfo::No) continue; - + if (Res == LibCallLocationInfo::No) + continue; + // If we don't know if this pointer points to the location, then we have to // assume it might alias in some case. if (Res == LibCallLocationInfo::Unknown) { NoneMatch = false; continue; } - + // If we know that this pointer definitely is pointing into the location, // merge in this information. return ModRefInfo(MRInfo & Details[i].MRInfo); } - + // If we found that the pointer is guaranteed to not match any of the // locations in our 'DoesOnly' rule, then we know that the pointer must point // to some other location. Since the libcall doesn't mod/ref any other @@ -136,7 +136,7 @@ ModRefInfo LibCallAliasAnalysis::getModRefInfo(ImmutableCallSite CS, } } } - + // The AliasAnalysis base class has some smarts, lets use them. return (ModRefInfo)(MRInfo | AliasAnalysis::getModRefInfo(CS, Loc)); } -- 2.34.1