LLVM 19.0.0git
AMDGPUMemoryUtils.cpp
Go to the documentation of this file.
1//===-- AMDGPUMemoryUtils.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
9#include "AMDGPUMemoryUtils.h"
10#include "AMDGPU.h"
11#include "AMDGPUBaseInfo.h"
12#include "llvm/ADT/SmallSet.h"
15#include "llvm/IR/DataLayout.h"
18#include "llvm/IR/IntrinsicsAMDGPU.h"
20
21#define DEBUG_TYPE "amdgpu-memory-utils"
22
23using namespace llvm;
24
25namespace llvm {
26
27namespace AMDGPU {
28
30 return DL.getValueOrABITypeAlignment(GV->getPointerAlignment(DL),
31 GV->getValueType());
32}
33
35 // external zero size addrspace(3) without initializer implies cuda/hip extern
36 // __shared__ the semantics for such a variable appears to be that all extern
37 // __shared__ variables alias one another. This hits different handling.
38 const Module *M = GV.getParent();
39 const DataLayout &DL = M->getDataLayout();
41 return false;
42 }
43 uint64_t AllocSize = DL.getTypeAllocSize(GV.getValueType());
44 return GV.hasExternalLinkage() && AllocSize == 0;
45}
46
49 return false;
50 }
51 if (isDynamicLDS(GV)) {
52 return true;
53 }
54 if (GV.isConstant()) {
55 // A constant undef variable can't be written to, and any load is
56 // undef, so it should be eliminated by the optimizer. It could be
57 // dropped by the back end if not. This pass skips over it.
58 return false;
59 }
60 if (GV.hasInitializer() && !isa<UndefValue>(GV.getInitializer())) {
61 // Initializers are unimplemented for LDS address space.
62 // Leave such variables in place for consistent error reporting.
63 return false;
64 }
65 return true;
66}
67
68bool isReallyAClobber(const Value *Ptr, MemoryDef *Def, AAResults *AA) {
69 Instruction *DefInst = Def->getMemoryInst();
70
71 if (isa<FenceInst>(DefInst))
72 return false;
73
74 if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(DefInst)) {
75 switch (II->getIntrinsicID()) {
76 case Intrinsic::amdgcn_s_barrier:
77 case Intrinsic::amdgcn_s_barrier_signal:
78 case Intrinsic::amdgcn_s_barrier_signal_var:
79 case Intrinsic::amdgcn_s_barrier_signal_isfirst:
80 case Intrinsic::amdgcn_s_barrier_signal_isfirst_var:
81 case Intrinsic::amdgcn_s_barrier_init:
82 case Intrinsic::amdgcn_s_barrier_join:
83 case Intrinsic::amdgcn_s_barrier_wait:
84 case Intrinsic::amdgcn_s_barrier_leave:
85 case Intrinsic::amdgcn_s_get_barrier_state:
86 case Intrinsic::amdgcn_s_wakeup_barrier:
87 case Intrinsic::amdgcn_wave_barrier:
88 case Intrinsic::amdgcn_sched_barrier:
89 case Intrinsic::amdgcn_sched_group_barrier:
90 return false;
91 default:
92 break;
93 }
94 }
95
96 // Ignore atomics not aliasing with the original load, any atomic is a
97 // universal MemoryDef from MSSA's point of view too, just like a fence.
98 const auto checkNoAlias = [AA, Ptr](auto I) -> bool {
99 return I && AA->isNoAlias(I->getPointerOperand(), Ptr);
100 };
101
102 if (checkNoAlias(dyn_cast<AtomicCmpXchgInst>(DefInst)) ||
103 checkNoAlias(dyn_cast<AtomicRMWInst>(DefInst)))
104 return false;
105
106 return true;
107}
108
110 AAResults *AA) {
111 MemorySSAWalker *Walker = MSSA->getWalker();
115
116 LLVM_DEBUG(dbgs() << "Checking clobbering of: " << *Load << '\n');
117
118 // Start with a nearest dominating clobbering access, it will be either
119 // live on entry (nothing to do, load is not clobbered), MemoryDef, or
120 // MemoryPhi if several MemoryDefs can define this memory state. In that
121 // case add all Defs to WorkList and continue going up and checking all
122 // the definitions of this memory location until the root. When all the
123 // defs are exhausted and came to the entry state we have no clobber.
124 // Along the scan ignore barriers and fences which are considered clobbers
125 // by the MemorySSA, but not really writing anything into the memory.
126 while (!WorkList.empty()) {
127 MemoryAccess *MA = WorkList.pop_back_val();
128 if (!Visited.insert(MA).second)
129 continue;
130
131 if (MSSA->isLiveOnEntryDef(MA))
132 continue;
133
134 if (MemoryDef *Def = dyn_cast<MemoryDef>(MA)) {
135 LLVM_DEBUG(dbgs() << " Def: " << *Def->getMemoryInst() << '\n');
136
137 if (isReallyAClobber(Load->getPointerOperand(), Def, AA)) {
138 LLVM_DEBUG(dbgs() << " -> load is clobbered\n");
139 return true;
140 }
141
142 WorkList.push_back(
143 Walker->getClobberingMemoryAccess(Def->getDefiningAccess(), Loc));
144 continue;
145 }
146
147 const MemoryPhi *Phi = cast<MemoryPhi>(MA);
148 for (const auto &Use : Phi->incoming_values())
149 WorkList.push_back(cast<MemoryAccess>(&Use));
150 }
151
152 LLVM_DEBUG(dbgs() << " -> no clobber\n");
153 return false;
154}
155
156} // end namespace AMDGPU
157
158} // end namespace llvm
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
#define LLVM_DEBUG(X)
Definition: Debug.h:101
#define I(x, y, z)
Definition: MD5.cpp:58
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
This file defines the SmallSet class.
bool isNoAlias(const MemoryLocation &LocA, const MemoryLocation &LocB)
A trivial helper function to check to see if the specified pointers are no-alias.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
bool hasExternalLinkage() const
Definition: GlobalValue.h:510
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:655
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:294
Type * getValueType() const
Definition: GlobalValue.h:296
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasInitializer() const
Definitions have initializers, declarations don't.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:47
An instruction for reading from memory.
Definition: Instructions.h:184
Represents a read-write access to memory, whether it is a must-alias, or a may-alias.
Definition: MemorySSA.h:372
Representation for a specific memory location.
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
Represents phi nodes for memory accesses.
Definition: MemorySSA.h:479
This is the generic walker interface for walkers of MemorySSA.
Definition: MemorySSA.h:1011
MemoryAccess * getClobberingMemoryAccess(const Instruction *I, BatchAAResults &AA)
Given a memory Mod/Ref/ModRef'ing instruction, calling this will give you the nearest dominating Memo...
Definition: MemorySSA.h:1040
Encapsulates MemorySSA, including all data associated with memory accesses.
Definition: MemorySSA.h:700
MemorySSAWalker * getWalker()
Definition: MemorySSA.cpp:1547
bool isLiveOnEntryDef(const MemoryAccess *MA) const
Return true if MA represents the live on entry value.
Definition: MemorySSA.h:737
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:135
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:179
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
LLVM Value Representation.
Definition: Value.h:74
Align getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
Definition: Value.cpp:926
@ LOCAL_ADDRESS
Address space for local memory.
bool isDynamicLDS(const GlobalVariable &GV)
Align getAlign(DataLayout const &DL, const GlobalVariable *GV)
bool isReallyAClobber(const Value *Ptr, MemoryDef *Def, AAResults *AA)
Given a Def clobbering a load from Ptr according to the MSSA check if this is actually a memory updat...
bool isLDSVariableToLower(const GlobalVariable &GV)
bool isClobberedInFunction(const LoadInst *Load, MemorySSA *MSSA, AAResults *AA)
Check is a Load is clobbered in its function.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39