1 //===-------------------- NVPTXAliasAnalysis.h ------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// \file 9 /// This is the NVPTX address space based alias analysis pass. 10 //===----------------------------------------------------------------------===// 11 12 #ifndef LLVM_LIB_TARGET_NVPTX_NVPTXALIASANALYSIS_H 13 #define LLVM_LIB_TARGET_NVPTX_NVPTXALIASANALYSIS_H 14 15 #include "llvm/Analysis/AliasAnalysis.h" 16 17 namespace llvm { 18 19 class MemoryLocation; 20 21 class NVPTXAAResult : public AAResultBase { 22 public: NVPTXAAResult()23 NVPTXAAResult() {} NVPTXAAResult(NVPTXAAResult && Arg)24 NVPTXAAResult(NVPTXAAResult &&Arg) : AAResultBase(std::move(Arg)) {} 25 26 /// Handle invalidation events from the new pass manager. 27 /// 28 /// By definition, this result is stateless and so remains valid. invalidate(Function &,const PreservedAnalyses &,FunctionAnalysisManager::Invalidator & Inv)29 bool invalidate(Function &, const PreservedAnalyses &, 30 FunctionAnalysisManager::Invalidator &Inv) { 31 return false; 32 } 33 34 AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB, 35 AAQueryInfo &AAQI, const Instruction *CtxI = nullptr); 36 37 ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, AAQueryInfo &AAQI, 38 bool IgnoreLocals); 39 40 MemoryEffects getMemoryEffects(const CallBase *Call, AAQueryInfo &AAQI); 41 getMemoryEffects(const Function * F)42 MemoryEffects getMemoryEffects(const Function *F) { 43 return MemoryEffects::unknown(); 44 } 45 }; 46 47 /// Analysis pass providing a never-invalidated alias analysis result. 48 class NVPTXAA : public AnalysisInfoMixin<NVPTXAA> { 49 friend AnalysisInfoMixin<NVPTXAA>; 50 51 static AnalysisKey Key; 52 53 public: 54 using Result = NVPTXAAResult; 55 run(Function & F,AnalysisManager<Function> & AM)56 NVPTXAAResult run(Function &F, AnalysisManager<Function> &AM) { 57 return NVPTXAAResult(); 58 } 59 }; 60 61 /// Legacy wrapper pass to provide the NVPTXAAResult object. 62 class NVPTXAAWrapperPass : public ImmutablePass { 63 std::unique_ptr<NVPTXAAResult> Result; 64 65 public: 66 static char ID; 67 68 NVPTXAAWrapperPass(); 69 getResult()70 NVPTXAAResult &getResult() { return *Result; } getResult()71 const NVPTXAAResult &getResult() const { return *Result; } 72 doInitialization(Module & M)73 bool doInitialization(Module &M) override { 74 Result.reset(new NVPTXAAResult()); 75 return false; 76 } 77 doFinalization(Module & M)78 bool doFinalization(Module &M) override { 79 Result.reset(); 80 return false; 81 } 82 83 void getAnalysisUsage(AnalysisUsage &AU) const override; 84 }; 85 86 // Wrapper around ExternalAAWrapperPass so that the default 87 // constructor gets the callback. 88 // Note that NVPTXAA will run before BasicAA for compile time considerations. 89 class NVPTXExternalAAWrapper : public ExternalAAWrapperPass { 90 public: 91 static char ID; 92 NVPTXExternalAAWrapper()93 NVPTXExternalAAWrapper() 94 : ExternalAAWrapperPass( 95 [](Pass &P, Function &, AAResults &AAR) { 96 if (auto *WrapperPass = 97 P.getAnalysisIfAvailable<NVPTXAAWrapperPass>()) 98 AAR.addAAResult(WrapperPass->getResult()); 99 }, 100 /*RunEarly=*/true) {} 101 getPassName()102 StringRef getPassName() const override { 103 return "NVPTX Address space based Alias Analysis Wrapper"; 104 } 105 }; 106 107 ImmutablePass *createNVPTXAAWrapperPass(); 108 ImmutablePass *createNVPTXExternalAAWrapperPass(); 109 110 } // end namespace llvm 111 112 #endif // LLVM_LIB_TARGET_NVPTX_NVPTXALIASANALYSIS_H 113