1//===- AMDGPUAliasAnalysis ------------------------------------------------===//
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 AMGPU address space based alias analysis pass.
10//===----------------------------------------------------------------------===//
11
12#include "AMDGPUAliasAnalysis.h"
13#include "AMDGPU.h"
14#include "llvm/Analysis/ValueTracking.h"
15#include "llvm/IR/Instructions.h"
16
17using namespace llvm;
18
19#define DEBUG_TYPE "amdgpu-aa"
20
21AnalysisKey AMDGPUAA::Key;
22
23// Register this pass...
24char AMDGPUAAWrapperPass::ID = 0;
25char AMDGPUExternalAAWrapper::ID = 0;
26
27INITIALIZE_PASS(AMDGPUAAWrapperPass, "amdgpu-aa",
28 "AMDGPU Address space based Alias Analysis", false, true)
29
30INITIALIZE_PASS(AMDGPUExternalAAWrapper, "amdgpu-aa-wrapper",
31 "AMDGPU Address space based Alias Analysis Wrapper", false, true)
32
33ImmutablePass *llvm::createAMDGPUAAWrapperPass() {
34 return new AMDGPUAAWrapperPass();
35}
36
37ImmutablePass *llvm::createAMDGPUExternalAAWrapperPass() {
38 return new AMDGPUExternalAAWrapper();
39}
40
41AMDGPUAAWrapperPass::AMDGPUAAWrapperPass() : ImmutablePass(ID) {
42 initializeAMDGPUAAWrapperPassPass(Registry&: *PassRegistry::getPassRegistry());
43}
44
45void AMDGPUAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
46 AU.setPreservesAll();
47}
48
49AliasResult AMDGPUAAResult::alias(const MemoryLocation &LocA,
50 const MemoryLocation &LocB, AAQueryInfo &AAQI,
51 const Instruction *) {
52 unsigned asA = LocA.Ptr->getType()->getPointerAddressSpace();
53 unsigned asB = LocB.Ptr->getType()->getPointerAddressSpace();
54
55 if (!AMDGPU::addrspacesMayAlias(AS1: asA, AS2: asB))
56 return AliasResult::NoAlias;
57
58 // In general, FLAT (generic) pointers could be aliased to LOCAL or PRIVATE
59 // pointers. However, as LOCAL or PRIVATE pointers point to local objects, in
60 // certain cases, it's still viable to check whether a FLAT pointer won't
61 // alias to a LOCAL or PRIVATE pointer.
62 MemoryLocation A = LocA;
63 MemoryLocation B = LocB;
64 // Canonicalize the location order to simplify the following alias check.
65 if (asA != AMDGPUAS::FLAT_ADDRESS) {
66 std::swap(a&: asA, b&: asB);
67 std::swap(a&: A, b&: B);
68 }
69 if (asA == AMDGPUAS::FLAT_ADDRESS &&
70 (asB == AMDGPUAS::LOCAL_ADDRESS || asB == AMDGPUAS::PRIVATE_ADDRESS)) {
71 const auto *ObjA =
72 getUnderlyingObject(V: A.Ptr->stripPointerCastsForAliasAnalysis());
73 if (const LoadInst *LI = dyn_cast<LoadInst>(Val: ObjA)) {
74 // If a generic pointer is loaded from the constant address space, it
75 // could only be a GLOBAL or CONSTANT one as that address space is solely
76 // prepared on the host side, where only GLOBAL or CONSTANT variables are
77 // visible. Note that this even holds for regular functions.
78 if (LI->getPointerAddressSpace() == AMDGPUAS::CONSTANT_ADDRESS)
79 return AliasResult::NoAlias;
80 } else if (const Argument *Arg = dyn_cast<Argument>(Val: ObjA)) {
81 const Function *F = Arg->getParent();
82 switch (F->getCallingConv()) {
83 case CallingConv::AMDGPU_KERNEL:
84 // In the kernel function, kernel arguments won't alias to (local)
85 // variables in shared or private address space.
86 return AliasResult::NoAlias;
87 default:
88 // TODO: In the regular function, if that local variable in the
89 // location B is not captured, that argument pointer won't alias to it
90 // as well.
91 break;
92 }
93 }
94 }
95
96 return AliasResult::MayAlias;
97}
98
99ModRefInfo AMDGPUAAResult::getModRefInfoMask(const MemoryLocation &Loc,
100 AAQueryInfo &AAQI,
101 bool IgnoreLocals) {
102 unsigned AS = Loc.Ptr->getType()->getPointerAddressSpace();
103 if (AS == AMDGPUAS::CONSTANT_ADDRESS ||
104 AS == AMDGPUAS::CONSTANT_ADDRESS_32BIT)
105 return ModRefInfo::NoModRef;
106
107 const Value *Base = getUnderlyingObject(V: Loc.Ptr);
108 AS = Base->getType()->getPointerAddressSpace();
109 if (AS == AMDGPUAS::CONSTANT_ADDRESS ||
110 AS == AMDGPUAS::CONSTANT_ADDRESS_32BIT)
111 return ModRefInfo::NoModRef;
112
113 return ModRefInfo::ModRef;
114}
115