LLVM 19.0.0git
HipStdPar.cpp
Go to the documentation of this file.
1//===----- HipStdPar.cpp - HIP C++ Standard Parallelism Support Passes ----===//
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// This file implements two passes that enable HIP C++ Standard Parallelism
9// Support:
10//
11// 1. AcceleratorCodeSelection (required): Given that only algorithms are
12// accelerated, and that the accelerated implementation exists in the form of
13// a compute kernel, we assume that only the kernel, and all functions
14// reachable from it, constitute code that the user expects the accelerator
15// to execute. Thus, we identify the set of all functions reachable from
16// kernels, and then remove all unreachable ones. This last part is necessary
17// because it is possible for code that the user did not expect to execute on
18// an accelerator to contain constructs that cannot be handled by the target
19// BE, which cannot be provably demonstrated to be dead code in general, and
20// thus can lead to mis-compilation. The degenerate case of this is when a
21// Module contains no kernels (the parent TU had no algorithm invocations fit
22// for acceleration), which we handle by completely emptying said module.
23// **NOTE**: The above does not handle indirectly reachable functions i.e.
24// it is possible to obtain a case where the target of an indirect
25// call is otherwise unreachable and thus is removed; this
26// restriction is aligned with the current `-hipstdpar` limitations
27// and will be relaxed in the future.
28//
29// 2. AllocationInterposition (required only when on-demand paging is
30// unsupported): Some accelerators or operating systems might not support
31// transparent on-demand paging. Thus, they would only be able to access
32// memory that is allocated by an accelerator-aware mechanism. For such cases
33// the user can opt into enabling allocation / deallocation interposition,
34// whereby we replace calls to known allocation / deallocation functions with
35// calls to runtime implemented equivalents that forward the requests to
36// accelerator-aware interfaces. We also support freeing system allocated
37// memory that ends up in one of the runtime equivalents, since this can
38// happen if e.g. a library that was compiled without interposition returns
39// an allocation that can be validly passed to `free`.
40//===----------------------------------------------------------------------===//
41
43
46#include "llvm/ADT/STLExtras.h"
49#include "llvm/IR/Constants.h"
51#include "llvm/IR/Function.h"
52#include "llvm/IR/Module.h"
54
55#include <cassert>
56#include <string>
57#include <utility>
58
59using namespace llvm;
60
61template<typename T>
62static inline void eraseFromModule(T &ToErase) {
63 ToErase.replaceAllUsesWith(PoisonValue::get(ToErase.getType()));
64 ToErase.eraseFromParent();
65}
66
67static inline bool checkIfSupported(GlobalVariable &G) {
68 if (!G.isThreadLocal())
69 return true;
70
71 G.dropDroppableUses();
72
73 if (!G.isConstantUsed())
74 return true;
75
76 std::string W;
78
79 OS << "Accelerator does not support the thread_local variable "
80 << G.getName();
81
82 Instruction *I = nullptr;
83 SmallVector<User *> Tmp(G.user_begin(), G.user_end());
85 do {
86 auto U = std::move(Tmp.back());
87 Tmp.pop_back();
88
89 if (Visited.contains(U))
90 continue;
91
92 if (isa<Instruction>(U))
93 I = cast<Instruction>(U);
94 else
95 Tmp.insert(Tmp.end(), U->user_begin(), U->user_end());
96
97 Visited.insert(U);
98 } while (!I && !Tmp.empty());
99
100 assert(I && "thread_local global should have at least one non-constant use.");
101
102 G.getContext().diagnose(
103 DiagnosticInfoUnsupported(*I->getParent()->getParent(), W,
104 I->getDebugLoc(), DS_Error));
105
106 return false;
107}
108
109static inline void clearModule(Module &M) { // TODO: simplify.
110 while (!M.functions().empty())
111 eraseFromModule(*M.begin());
112 while (!M.globals().empty())
113 eraseFromModule(*M.globals().begin());
114 while (!M.aliases().empty())
115 eraseFromModule(*M.aliases().begin());
116 while (!M.ifuncs().empty())
117 eraseFromModule(*M.ifuncs().begin());
118}
119
120static inline void maybeHandleGlobals(Module &M) {
121 unsigned GlobAS = M.getDataLayout().getDefaultGlobalsAddressSpace();
122 for (auto &&G : M.globals()) { // TODO: should we handle these in the FE?
123 if (!checkIfSupported(G))
124 return clearModule(M);
125
126 if (G.isThreadLocal())
127 continue;
128 if (G.isConstant())
129 continue;
130 if (G.getAddressSpace() != GlobAS)
131 continue;
132 if (G.getLinkage() != GlobalVariable::ExternalLinkage)
133 continue;
134
135 G.setLinkage(GlobalVariable::ExternalWeakLinkage);
136 G.setInitializer(nullptr);
137 G.setExternallyInitialized(true);
138 }
139}
140
141template<unsigned N>
142static inline void removeUnreachableFunctions(
143 const SmallPtrSet<const Function *, N>& Reachable, Module &M) {
145 if (auto F = dyn_cast<Function>(C))
146 return !Reachable.contains(F);
147
148 return false;
149 });
150
152 copy_if(M, std::back_inserter(ToRemove), [&](auto &&F) {
153 return !F.isIntrinsic() && !Reachable.contains(&F);
154 });
155
156 for_each(ToRemove, eraseFromModule<Function>);
157}
158
159static inline bool isAcceleratorExecutionRoot(const Function *F) {
160 if (!F)
161 return false;
162
163 return F->getCallingConv() == CallingConv::AMDGPU_KERNEL;
164}
165
166static inline bool checkIfSupported(const Function *F, const CallBase *CB) {
167 const auto Dx = F->getName().rfind("__hipstdpar_unsupported");
168
169 if (Dx == StringRef::npos)
170 return true;
171
172 const auto N = F->getName().substr(0, Dx);
173
174 std::string W;
176
177 if (N == "__ASM")
178 OS << "Accelerator does not support the ASM block:\n"
179 << cast<ConstantDataArray>(CB->getArgOperand(0))->getAsCString();
180 else
181 OS << "Accelerator does not support the " << N << " function.";
182
183 auto Caller = CB->getParent()->getParent();
184
185 Caller->getContext().diagnose(
187
188 return false;
189}
190
194 auto &CGA = MAM.getResult<CallGraphAnalysis>(M);
195
197 for (auto &&CGN : CGA) {
198 if (!isAcceleratorExecutionRoot(CGN.first))
199 continue;
200
201 Reachable.insert(CGN.first);
202
203 SmallVector<const Function *> Tmp({CGN.first});
204 do {
205 auto F = std::move(Tmp.back());
206 Tmp.pop_back();
207
208 for (auto &&N : *CGA[F]) {
209 if (!N.second)
210 continue;
211 if (!N.second->getFunction())
212 continue;
213 if (Reachable.contains(N.second->getFunction()))
214 continue;
215
216 if (!checkIfSupported(N.second->getFunction(),
217 dyn_cast<CallBase>(*N.first)))
219
220 Reachable.insert(N.second->getFunction());
221 Tmp.push_back(N.second->getFunction());
222 }
223 } while (!std::empty(Tmp));
224 }
225
226 if (std::empty(Reachable))
227 clearModule(M);
228 else
229 removeUnreachableFunctions(Reachable, M);
230
232
234}
235
236static constexpr std::pair<StringLiteral, StringLiteral> ReplaceMap[]{
237 {"aligned_alloc", "__hipstdpar_aligned_alloc"},
238 {"calloc", "__hipstdpar_calloc"},
239 {"free", "__hipstdpar_free"},
240 {"malloc", "__hipstdpar_malloc"},
241 {"memalign", "__hipstdpar_aligned_alloc"},
242 {"posix_memalign", "__hipstdpar_posix_aligned_alloc"},
243 {"realloc", "__hipstdpar_realloc"},
244 {"reallocarray", "__hipstdpar_realloc_array"},
245 {"_ZdaPv", "__hipstdpar_operator_delete"},
246 {"_ZdaPvm", "__hipstdpar_operator_delete_sized"},
247 {"_ZdaPvSt11align_val_t", "__hipstdpar_operator_delete_aligned"},
248 {"_ZdaPvmSt11align_val_t", "__hipstdpar_operator_delete_aligned_sized"},
249 {"_ZdlPv", "__hipstdpar_operator_delete"},
250 {"_ZdlPvm", "__hipstdpar_operator_delete_sized"},
251 {"_ZdlPvSt11align_val_t", "__hipstdpar_operator_delete_aligned"},
252 {"_ZdlPvmSt11align_val_t", "__hipstdpar_operator_delete_aligned_sized"},
253 {"_Znam", "__hipstdpar_operator_new"},
254 {"_ZnamRKSt9nothrow_t", "__hipstdpar_operator_new_nothrow"},
255 {"_ZnamSt11align_val_t", "__hipstdpar_operator_new_aligned"},
256 {"_ZnamSt11align_val_tRKSt9nothrow_t",
257 "__hipstdpar_operator_new_aligned_nothrow"},
258
259 {"_Znwm", "__hipstdpar_operator_new"},
260 {"_ZnwmRKSt9nothrow_t", "__hipstdpar_operator_new_nothrow"},
261 {"_ZnwmSt11align_val_t", "__hipstdpar_operator_new_aligned"},
262 {"_ZnwmSt11align_val_tRKSt9nothrow_t",
263 "__hipstdpar_operator_new_aligned_nothrow"},
264 {"__builtin_calloc", "__hipstdpar_calloc"},
265 {"__builtin_free", "__hipstdpar_free"},
266 {"__builtin_malloc", "__hipstdpar_malloc"},
267 {"__builtin_operator_delete", "__hipstdpar_operator_delete"},
268 {"__builtin_operator_new", "__hipstdpar_operator_new"},
269 {"__builtin_realloc", "__hipstdpar_realloc"},
270 {"__libc_calloc", "__hipstdpar_calloc"},
271 {"__libc_free", "__hipstdpar_free"},
272 {"__libc_malloc", "__hipstdpar_malloc"},
273 {"__libc_memalign", "__hipstdpar_aligned_alloc"},
274 {"__libc_realloc", "__hipstdpar_realloc"}
275};
276
279 SmallDenseMap<StringRef, StringRef> AllocReplacements(std::cbegin(ReplaceMap),
280 std::cend(ReplaceMap));
281
282 for (auto &&F : M) {
283 if (!F.hasName())
284 continue;
285 if (!AllocReplacements.contains(F.getName()))
286 continue;
287
288 if (auto R = M.getFunction(AllocReplacements[F.getName()])) {
289 F.replaceAllUsesWith(R);
290 } else {
291 std::string W;
293
294 OS << "cannot be interposed, missing: " << AllocReplacements[F.getName()]
295 << ". Tried to run the allocation interposition pass without the "
296 << "replacement functions available.";
297
298 F.getContext().diagnose(DiagnosticInfoUnsupported(F, W,
299 F.getSubprogram(),
300 DS_Warning));
301 }
302 }
303
304 if (auto F = M.getFunction("__hipstdpar_hidden_free")) {
305 auto LibcFree = M.getOrInsertFunction("__libc_free", F->getFunctionType(),
306 F->getAttributes());
307 F->replaceAllUsesWith(LibcFree.getCallee());
308
310 }
311
313}
ReachingDefAnalysis InstSet & ToRemove
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static constexpr std::pair< StringLiteral, StringLiteral > ReplaceMap[]
Definition: HipStdPar.cpp:236
static void maybeHandleGlobals(Module &M)
Definition: HipStdPar.cpp:120
static bool isAcceleratorExecutionRoot(const Function *F)
Definition: HipStdPar.cpp:159
static void eraseFromModule(T &ToErase)
Definition: HipStdPar.cpp:62
static void removeUnreachableFunctions(const SmallPtrSet< const Function *, N > &Reachable, Module &M)
Definition: HipStdPar.cpp:142
static bool checkIfSupported(GlobalVariable &G)
Definition: HipStdPar.cpp:67
static void clearModule(Module &M)
Definition: HipStdPar.cpp:109
AcceleratorCodeSelection - Identify all functions reachable from a kernel, removing those that are un...
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define G(x, y, z)
Definition: MD5.cpp:56
Module.h This file contains the declarations for the Module class.
ModuleAnalysisManager MAM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:242
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:394
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1236
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1410
An analysis pass to compute the CallGraph for a Module.
Definition: CallGraph.h:302
This is an important base class in LLVM.
Definition: Constant.h:41
bool contains(const_arg_type_t< KeyT > Val) const
Return true if the specified key is in the map, false otherwise.
Definition: DenseMap.h:145
Diagnostic information for unsupported feature in backend.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
Definition: HipStdPar.cpp:192
PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
Definition: HipStdPar.cpp:278
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:470
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Definition: Constants.cpp:1814
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:109
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: Analysis.h:112
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:342
bool contains(ConstPtrType Ptr) const
Definition: SmallPtrSet.h:366
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:427
bool empty() const
Definition: SmallVector.h:94
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:818
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
static constexpr size_t npos
Definition: StringRef.h:52
const ParentTy * getParent() const
Definition: ilist_node.h:32
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:661
@ AMDGPU_KERNEL
Used for AMDGPU code object kernels.
Definition: CallingConv.h:200
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
UnaryFunction for_each(R &&Range, UnaryFunction F)
Provide wrappers to std::for_each which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1715
OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P)
Provide wrappers to std::copy_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1768
void removeFromUsedLists(Module &M, function_ref< bool(Constant *)> ShouldRemove)
Removes global values from the llvm.used and llvm.compiler.used arrays.
@ DS_Warning
@ DS_Error
#define N