1//===--------------------- NVPTXAliasAnalysis.cpp--------------------------===//
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#include "NVPTXAliasAnalysis.h"
13#include "MCTargetDesc/NVPTXBaseInfo.h"
14#include "NVPTX.h"
15#include "NVPTXSubtarget.h"
16#include "llvm/Analysis/ValueTracking.h"
17#include "llvm/IR/InlineAsm.h"
18#include "llvm/IR/Instructions.h"
19
20using namespace llvm;
21
22#define DEBUG_TYPE "NVPTX-aa"
23
24AnalysisKey NVPTXAA::Key;
25
26char NVPTXAAWrapperPass::ID = 0;
27char NVPTXExternalAAWrapper::ID = 0;
28
29INITIALIZE_PASS(NVPTXAAWrapperPass, "nvptx-aa",
30 "NVPTX Address space based Alias Analysis", false, true)
31
32INITIALIZE_PASS(NVPTXExternalAAWrapper, "nvptx-aa-wrapper",
33 "NVPTX Address space based Alias Analysis Wrapper", false, true)
34
35ImmutablePass *llvm::createNVPTXAAWrapperPass() {
36 return new NVPTXAAWrapperPass();
37}
38
39ImmutablePass *llvm::createNVPTXExternalAAWrapperPass() {
40 return new NVPTXExternalAAWrapper();
41}
42
43NVPTXAAWrapperPass::NVPTXAAWrapperPass() : ImmutablePass(ID) {}
44
45NVPTXAAResult NVPTXAA::run(Function &F, AnalysisManager<Function> &AM) {
46 return NVPTXAAResult(getNVPTXOptions(F));
47}
48
49bool NVPTXAAWrapperPass::doInitialization(Module &M) {
50 Result = std::make_unique<NVPTXAAResult>(args: getNVPTXOptions(M));
51 return false;
52}
53
54void NVPTXAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
55 AU.setPreservesAll();
56}
57
58static unsigned getAddressSpace(const Value *V, unsigned MaxLookup) {
59 // Find the first non-generic address space traversing the UD chain.
60 // It is undefined behaviour if a pointer belongs to more than one
61 // non-overlapping address spaces along a valid execution path.
62 auto GetAS = [](const Value *V) -> unsigned {
63 if (const auto *PTy = dyn_cast<PointerType>(Val: V->getType()))
64 return PTy->getAddressSpace();
65 return ADDRESS_SPACE_GENERIC;
66 };
67 while (MaxLookup-- && GetAS(V) == ADDRESS_SPACE_GENERIC) {
68 const Value *NewV = getUnderlyingObject(V, MaxLookup: 1);
69 if (NewV == V)
70 break;
71 V = NewV;
72 }
73 return GetAS(V);
74}
75
76static AliasResult::Kind getAliasResult(unsigned AS1, unsigned AS2) {
77 if ((AS1 == ADDRESS_SPACE_GENERIC) || (AS2 == ADDRESS_SPACE_GENERIC))
78 return AliasResult::MayAlias;
79
80 // PTX s6.4.1.1. Generic Addressing:
81 // A generic address maps to global memory unless it falls within
82 // the window for const, local, or shared memory. The Kernel
83 // Function Parameters (.param) window is contained within the
84 // .global window.
85 //
86 // Therefore a global pointer may alias with a param pointer on some
87 // GPUs via addrspacecast(param->generic->global) when cvta.param
88 // instruction is used (PTX 7.7+ and SM_70+).
89 //
90 // TODO: cvta.param is not yet supported. We need to change aliasing
91 // rules once it is added.
92
93 // Distributed shared memory aliases with shared memory.
94 if (((AS1 == ADDRESS_SPACE_SHARED) &&
95 (AS2 == ADDRESS_SPACE_SHARED_CLUSTER)) ||
96 ((AS1 == ADDRESS_SPACE_SHARED_CLUSTER) && (AS2 == ADDRESS_SPACE_SHARED)))
97 return AliasResult::MayAlias;
98
99 return (AS1 == AS2 ? AliasResult::MayAlias : AliasResult::NoAlias);
100}
101
102AliasResult NVPTXAAResult::alias(const MemoryLocation &Loc1,
103 const MemoryLocation &Loc2, AAQueryInfo &AAQI,
104 const Instruction *) {
105 unsigned AS1 =
106 getAddressSpace(V: Loc1.Ptr, MaxLookup: CLOpts.traverse_address_aliasing_limit);
107 unsigned AS2 =
108 getAddressSpace(V: Loc2.Ptr, MaxLookup: CLOpts.traverse_address_aliasing_limit);
109
110 return getAliasResult(AS1, AS2);
111}
112
113// TODO: .param address space may be writable in presence of cvta.param, but
114// this instruction is currently not supported. NVPTXLowerArgs also does not
115// allow any writes to .param pointers.
116static bool isConstOrParam(unsigned AS) {
117 return AS == AddressSpace::ADDRESS_SPACE_CONST ||
118 AS == AddressSpace::ADDRESS_SPACE_ENTRY_PARAM;
119}
120
121ModRefInfo NVPTXAAResult::getModRefInfoMask(const MemoryLocation &Loc,
122 AAQueryInfo &AAQI,
123 bool IgnoreLocals) {
124 if (isConstOrParam(
125 AS: getAddressSpace(V: Loc.Ptr, MaxLookup: CLOpts.traverse_address_aliasing_limit)))
126 return ModRefInfo::NoModRef;
127
128 return ModRefInfo::ModRef;
129}
130
131MemoryEffects NVPTXAAResult::getMemoryEffects(const CallBase *Call,
132 AAQueryInfo &AAQI) {
133 // Inline assembly with no side-effect or memory clobbers should not
134 // indirectly access memory in the PTX specification.
135 if (const auto *IA = dyn_cast<InlineAsm>(Val: Call->getCalledOperand())) {
136 // Volatile is translated as side-effects.
137 if (IA->hasSideEffects())
138 return MemoryEffects::unknown();
139
140 for (const InlineAsm::ConstraintInfo &Constraint : IA->ParseConstraints()) {
141 // Indirect constraints (e.g. =*m) are unsupported in inline PTX.
142 if (Constraint.isIndirect)
143 return MemoryEffects::unknown();
144
145 // Memory clobbers prevent optimization.
146 if ((Constraint.Type & InlineAsm::ConstraintPrefix::isClobber) &&
147 any_of(Range: Constraint.Codes,
148 P: [](const auto &Code) { return Code == "{memory}"; }))
149 return MemoryEffects::unknown();
150 }
151 return MemoryEffects::none();
152 }
153
154 return MemoryEffects::unknown();
155}
156