|
150
|
1 //===-- CGBuilder.h - Choose IRBuilder implementation ----------*- 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
|
|
|
9 #ifndef LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H
|
|
|
10 #define LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H
|
|
|
11
|
|
|
12 #include "llvm/IR/DataLayout.h"
|
|
|
13 #include "llvm/IR/IRBuilder.h"
|
|
|
14 #include "Address.h"
|
|
|
15 #include "CodeGenTypeCache.h"
|
|
|
16
|
|
|
17 namespace clang {
|
|
|
18 namespace CodeGen {
|
|
|
19
|
|
|
20 class CodeGenFunction;
|
|
|
21
|
|
|
22 /// This is an IRBuilder insertion helper that forwards to
|
|
|
23 /// CodeGenFunction::InsertHelper, which adds necessary metadata to
|
|
|
24 /// instructions.
|
|
173
|
25 class CGBuilderInserter final : public llvm::IRBuilderDefaultInserter {
|
|
150
|
26 public:
|
|
|
27 CGBuilderInserter() = default;
|
|
|
28 explicit CGBuilderInserter(CodeGenFunction *CGF) : CGF(CGF) {}
|
|
|
29
|
|
|
30 /// This forwards to CodeGenFunction::InsertHelper.
|
|
|
31 void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
|
|
|
32 llvm::BasicBlock *BB,
|
|
173
|
33 llvm::BasicBlock::iterator InsertPt) const override;
|
|
150
|
34 private:
|
|
|
35 CodeGenFunction *CGF = nullptr;
|
|
|
36 };
|
|
|
37
|
|
|
38 typedef CGBuilderInserter CGBuilderInserterTy;
|
|
|
39
|
|
|
40 typedef llvm::IRBuilder<llvm::ConstantFolder, CGBuilderInserterTy>
|
|
|
41 CGBuilderBaseTy;
|
|
|
42
|
|
|
43 class CGBuilderTy : public CGBuilderBaseTy {
|
|
|
44 /// Storing a reference to the type cache here makes it a lot easier
|
|
|
45 /// to build natural-feeling, target-specific IR.
|
|
|
46 const CodeGenTypeCache &TypeCache;
|
|
|
47 public:
|
|
|
48 CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::LLVMContext &C)
|
|
|
49 : CGBuilderBaseTy(C), TypeCache(TypeCache) {}
|
|
|
50 CGBuilderTy(const CodeGenTypeCache &TypeCache,
|
|
|
51 llvm::LLVMContext &C, const llvm::ConstantFolder &F,
|
|
|
52 const CGBuilderInserterTy &Inserter)
|
|
|
53 : CGBuilderBaseTy(C, F, Inserter), TypeCache(TypeCache) {}
|
|
|
54 CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::Instruction *I)
|
|
|
55 : CGBuilderBaseTy(I), TypeCache(TypeCache) {}
|
|
|
56 CGBuilderTy(const CodeGenTypeCache &TypeCache, llvm::BasicBlock *BB)
|
|
|
57 : CGBuilderBaseTy(BB), TypeCache(TypeCache) {}
|
|
|
58
|
|
|
59 llvm::ConstantInt *getSize(CharUnits N) {
|
|
|
60 return llvm::ConstantInt::get(TypeCache.SizeTy, N.getQuantity());
|
|
|
61 }
|
|
|
62 llvm::ConstantInt *getSize(uint64_t N) {
|
|
|
63 return llvm::ConstantInt::get(TypeCache.SizeTy, N);
|
|
|
64 }
|
|
|
65
|
|
|
66 // Note that we intentionally hide the CreateLoad APIs that don't
|
|
|
67 // take an alignment.
|
|
|
68 llvm::LoadInst *CreateLoad(Address Addr, const llvm::Twine &Name = "") {
|
|
|
69 return CreateAlignedLoad(Addr.getPointer(),
|
|
|
70 Addr.getAlignment().getAsAlign(), Name);
|
|
|
71 }
|
|
|
72 llvm::LoadInst *CreateLoad(Address Addr, const char *Name) {
|
|
|
73 // This overload is required to prevent string literals from
|
|
|
74 // ending up in the IsVolatile overload.
|
|
|
75 return CreateAlignedLoad(Addr.getPointer(),
|
|
|
76 Addr.getAlignment().getAsAlign(), Name);
|
|
|
77 }
|
|
|
78 llvm::LoadInst *CreateLoad(Address Addr, bool IsVolatile,
|
|
|
79 const llvm::Twine &Name = "") {
|
|
|
80 return CreateAlignedLoad(
|
|
|
81 Addr.getPointer(), Addr.getAlignment().getAsAlign(), IsVolatile, Name);
|
|
|
82 }
|
|
|
83
|
|
|
84 using CGBuilderBaseTy::CreateAlignedLoad;
|
|
|
85 llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align,
|
|
|
86 const llvm::Twine &Name = "") {
|
|
|
87 return CreateAlignedLoad(Addr, Align.getAsAlign(), Name);
|
|
|
88 }
|
|
|
89 llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align,
|
|
|
90 const char *Name) {
|
|
|
91 return CreateAlignedLoad(Addr, Align.getAsAlign(), Name);
|
|
|
92 }
|
|
|
93 llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr,
|
|
|
94 CharUnits Align,
|
|
|
95 const llvm::Twine &Name = "") {
|
|
|
96 assert(Addr->getType()->getPointerElementType() == Ty);
|
|
|
97 return CreateAlignedLoad(Addr, Align.getAsAlign(), Name);
|
|
|
98 }
|
|
|
99
|
|
|
100 // Note that we intentionally hide the CreateStore APIs that don't
|
|
|
101 // take an alignment.
|
|
|
102 llvm::StoreInst *CreateStore(llvm::Value *Val, Address Addr,
|
|
|
103 bool IsVolatile = false) {
|
|
|
104 return CreateAlignedStore(Val, Addr.getPointer(),
|
|
|
105 Addr.getAlignment().getAsAlign(), IsVolatile);
|
|
|
106 }
|
|
|
107
|
|
|
108 using CGBuilderBaseTy::CreateAlignedStore;
|
|
|
109 llvm::StoreInst *CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr,
|
|
|
110 CharUnits Align, bool IsVolatile = false) {
|
|
|
111 return CreateAlignedStore(Val, Addr, Align.getAsAlign(), IsVolatile);
|
|
|
112 }
|
|
|
113
|
|
|
114 // FIXME: these "default-aligned" APIs should be removed,
|
|
|
115 // but I don't feel like fixing all the builtin code right now.
|
|
|
116 llvm::StoreInst *CreateDefaultAlignedStore(llvm::Value *Val,
|
|
|
117 llvm::Value *Addr,
|
|
|
118 bool IsVolatile = false) {
|
|
|
119 return CGBuilderBaseTy::CreateStore(Val, Addr, IsVolatile);
|
|
|
120 }
|
|
|
121
|
|
|
122 /// Emit a load from an i1 flag variable.
|
|
|
123 llvm::LoadInst *CreateFlagLoad(llvm::Value *Addr,
|
|
|
124 const llvm::Twine &Name = "") {
|
|
|
125 assert(Addr->getType()->getPointerElementType() == getInt1Ty());
|
|
|
126 return CreateAlignedLoad(getInt1Ty(), Addr, CharUnits::One(), Name);
|
|
|
127 }
|
|
|
128
|
|
|
129 /// Emit a store to an i1 flag variable.
|
|
|
130 llvm::StoreInst *CreateFlagStore(bool Value, llvm::Value *Addr) {
|
|
|
131 assert(Addr->getType()->getPointerElementType() == getInt1Ty());
|
|
|
132 return CreateAlignedStore(getInt1(Value), Addr, CharUnits::One());
|
|
|
133 }
|
|
|
134
|
|
|
135 using CGBuilderBaseTy::CreateBitCast;
|
|
|
136 Address CreateBitCast(Address Addr, llvm::Type *Ty,
|
|
|
137 const llvm::Twine &Name = "") {
|
|
|
138 return Address(CreateBitCast(Addr.getPointer(), Ty, Name),
|
|
|
139 Addr.getAlignment());
|
|
|
140 }
|
|
|
141
|
|
|
142 using CGBuilderBaseTy::CreateAddrSpaceCast;
|
|
|
143 Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty,
|
|
|
144 const llvm::Twine &Name = "") {
|
|
|
145 return Address(CreateAddrSpaceCast(Addr.getPointer(), Ty, Name),
|
|
|
146 Addr.getAlignment());
|
|
|
147 }
|
|
|
148
|
|
|
149 /// Cast the element type of the given address to a different type,
|
|
|
150 /// preserving information like the alignment and address space.
|
|
|
151 Address CreateElementBitCast(Address Addr, llvm::Type *Ty,
|
|
|
152 const llvm::Twine &Name = "") {
|
|
|
153 auto PtrTy = Ty->getPointerTo(Addr.getAddressSpace());
|
|
|
154 return CreateBitCast(Addr, PtrTy, Name);
|
|
|
155 }
|
|
|
156
|
|
|
157 using CGBuilderBaseTy::CreatePointerBitCastOrAddrSpaceCast;
|
|
|
158 Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty,
|
|
|
159 const llvm::Twine &Name = "") {
|
|
|
160 llvm::Value *Ptr =
|
|
|
161 CreatePointerBitCastOrAddrSpaceCast(Addr.getPointer(), Ty, Name);
|
|
|
162 return Address(Ptr, Addr.getAlignment());
|
|
|
163 }
|
|
|
164
|
|
|
165 /// Given
|
|
|
166 /// %addr = {T1, T2...}* ...
|
|
|
167 /// produce
|
|
|
168 /// %name = getelementptr inbounds %addr, i32 0, i32 index
|
|
|
169 ///
|
|
|
170 /// This API assumes that drilling into a struct like this is always an
|
|
|
171 /// inbounds operation.
|
|
|
172 using CGBuilderBaseTy::CreateStructGEP;
|
|
|
173 Address CreateStructGEP(Address Addr, unsigned Index,
|
|
|
174 const llvm::Twine &Name = "") {
|
|
|
175 llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType());
|
|
|
176 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
|
|
|
177 const llvm::StructLayout *Layout = DL.getStructLayout(ElTy);
|
|
|
178 auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
|
|
|
179
|
|
|
180 return Address(CreateStructGEP(Addr.getElementType(),
|
|
|
181 Addr.getPointer(), Index, Name),
|
|
|
182 Addr.getAlignment().alignmentAtOffset(Offset));
|
|
|
183 }
|
|
|
184
|
|
|
185 /// Given
|
|
|
186 /// %addr = [n x T]* ...
|
|
|
187 /// produce
|
|
|
188 /// %name = getelementptr inbounds %addr, i64 0, i64 index
|
|
|
189 /// where i64 is actually the target word size.
|
|
|
190 ///
|
|
|
191 /// This API assumes that drilling into an array like this is always
|
|
|
192 /// an inbounds operation.
|
|
|
193 Address CreateConstArrayGEP(Address Addr, uint64_t Index,
|
|
|
194 const llvm::Twine &Name = "") {
|
|
|
195 llvm::ArrayType *ElTy = cast<llvm::ArrayType>(Addr.getElementType());
|
|
|
196 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
|
|
|
197 CharUnits EltSize =
|
|
|
198 CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy->getElementType()));
|
|
|
199
|
|
|
200 return Address(
|
|
|
201 CreateInBoundsGEP(Addr.getPointer(),
|
|
|
202 {getSize(CharUnits::Zero()), getSize(Index)}, Name),
|
|
|
203 Addr.getAlignment().alignmentAtOffset(Index * EltSize));
|
|
|
204 }
|
|
|
205
|
|
|
206 /// Given
|
|
|
207 /// %addr = T* ...
|
|
|
208 /// produce
|
|
|
209 /// %name = getelementptr inbounds %addr, i64 index
|
|
|
210 /// where i64 is actually the target word size.
|
|
|
211 Address CreateConstInBoundsGEP(Address Addr, uint64_t Index,
|
|
|
212 const llvm::Twine &Name = "") {
|
|
|
213 llvm::Type *ElTy = Addr.getElementType();
|
|
|
214 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
|
|
|
215 CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy));
|
|
|
216
|
|
|
217 return Address(CreateInBoundsGEP(Addr.getElementType(), Addr.getPointer(),
|
|
|
218 getSize(Index), Name),
|
|
|
219 Addr.getAlignment().alignmentAtOffset(Index * EltSize));
|
|
|
220 }
|
|
|
221
|
|
|
222 /// Given
|
|
|
223 /// %addr = T* ...
|
|
|
224 /// produce
|
|
|
225 /// %name = getelementptr inbounds %addr, i64 index
|
|
|
226 /// where i64 is actually the target word size.
|
|
|
227 Address CreateConstGEP(Address Addr, uint64_t Index,
|
|
|
228 const llvm::Twine &Name = "") {
|
|
|
229 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
|
|
|
230 CharUnits EltSize =
|
|
|
231 CharUnits::fromQuantity(DL.getTypeAllocSize(Addr.getElementType()));
|
|
|
232
|
|
|
233 return Address(CreateGEP(Addr.getElementType(), Addr.getPointer(),
|
|
|
234 getSize(Index), Name),
|
|
|
235 Addr.getAlignment().alignmentAtOffset(Index * EltSize));
|
|
|
236 }
|
|
|
237
|
|
|
238 /// Given a pointer to i8, adjust it by a given constant offset.
|
|
|
239 Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset,
|
|
|
240 const llvm::Twine &Name = "") {
|
|
|
241 assert(Addr.getElementType() == TypeCache.Int8Ty);
|
|
|
242 return Address(CreateInBoundsGEP(Addr.getPointer(), getSize(Offset), Name),
|
|
|
243 Addr.getAlignment().alignmentAtOffset(Offset));
|
|
|
244 }
|
|
|
245 Address CreateConstByteGEP(Address Addr, CharUnits Offset,
|
|
|
246 const llvm::Twine &Name = "") {
|
|
|
247 assert(Addr.getElementType() == TypeCache.Int8Ty);
|
|
|
248 return Address(CreateGEP(Addr.getPointer(), getSize(Offset), Name),
|
|
|
249 Addr.getAlignment().alignmentAtOffset(Offset));
|
|
|
250 }
|
|
|
251
|
|
|
252 using CGBuilderBaseTy::CreateConstInBoundsGEP2_32;
|
|
|
253 Address CreateConstInBoundsGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
|
|
|
254 const llvm::Twine &Name = "") {
|
|
|
255 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
|
|
|
256
|
|
|
257 auto *GEP = cast<llvm::GetElementPtrInst>(CreateConstInBoundsGEP2_32(
|
|
|
258 Addr.getElementType(), Addr.getPointer(), Idx0, Idx1, Name));
|
|
|
259 llvm::APInt Offset(
|
|
|
260 DL.getIndexSizeInBits(Addr.getType()->getPointerAddressSpace()), 0,
|
|
|
261 /*isSigned=*/true);
|
|
|
262 if (!GEP->accumulateConstantOffset(DL, Offset))
|
|
|
263 llvm_unreachable("offset of GEP with constants is always computable");
|
|
|
264 return Address(GEP, Addr.getAlignment().alignmentAtOffset(
|
|
|
265 CharUnits::fromQuantity(Offset.getSExtValue())));
|
|
|
266 }
|
|
|
267
|
|
|
268 using CGBuilderBaseTy::CreateMemCpy;
|
|
|
269 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, llvm::Value *Size,
|
|
|
270 bool IsVolatile = false) {
|
|
|
271 return CreateMemCpy(Dest.getPointer(), Dest.getAlignment().getAsAlign(),
|
|
|
272 Src.getPointer(), Src.getAlignment().getAsAlign(), Size,
|
|
|
273 IsVolatile);
|
|
|
274 }
|
|
|
275 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, uint64_t Size,
|
|
|
276 bool IsVolatile = false) {
|
|
|
277 return CreateMemCpy(Dest.getPointer(), Dest.getAlignment().getAsAlign(),
|
|
|
278 Src.getPointer(), Src.getAlignment().getAsAlign(), Size,
|
|
|
279 IsVolatile);
|
|
|
280 }
|
|
|
281
|
|
|
282 using CGBuilderBaseTy::CreateMemCpyInline;
|
|
|
283 llvm::CallInst *CreateMemCpyInline(Address Dest, Address Src, uint64_t Size) {
|
|
|
284 return CreateMemCpyInline(
|
|
|
285 Dest.getPointer(), Dest.getAlignment().getAsAlign(), Src.getPointer(),
|
|
|
286 Src.getAlignment().getAsAlign(), getInt64(Size));
|
|
|
287 }
|
|
|
288
|
|
|
289 using CGBuilderBaseTy::CreateMemMove;
|
|
|
290 llvm::CallInst *CreateMemMove(Address Dest, Address Src, llvm::Value *Size,
|
|
|
291 bool IsVolatile = false) {
|
|
|
292 return CreateMemMove(Dest.getPointer(), Dest.getAlignment().getAsAlign(),
|
|
|
293 Src.getPointer(), Src.getAlignment().getAsAlign(),
|
|
|
294 Size, IsVolatile);
|
|
|
295 }
|
|
|
296
|
|
|
297 using CGBuilderBaseTy::CreateMemSet;
|
|
|
298 llvm::CallInst *CreateMemSet(Address Dest, llvm::Value *Value,
|
|
|
299 llvm::Value *Size, bool IsVolatile = false) {
|
|
|
300 return CreateMemSet(Dest.getPointer(), Value, Size,
|
|
|
301 Dest.getAlignment().getAsAlign(), IsVolatile);
|
|
|
302 }
|
|
|
303
|
|
|
304 using CGBuilderBaseTy::CreatePreserveStructAccessIndex;
|
|
|
305 Address CreatePreserveStructAccessIndex(Address Addr,
|
|
|
306 unsigned Index,
|
|
|
307 unsigned FieldIndex,
|
|
|
308 llvm::MDNode *DbgInfo) {
|
|
|
309 llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType());
|
|
|
310 const llvm::DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
|
|
|
311 const llvm::StructLayout *Layout = DL.getStructLayout(ElTy);
|
|
|
312 auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
|
|
|
313
|
|
|
314 return Address(CreatePreserveStructAccessIndex(ElTy, Addr.getPointer(),
|
|
|
315 Index, FieldIndex, DbgInfo),
|
|
|
316 Addr.getAlignment().alignmentAtOffset(Offset));
|
|
|
317 }
|
|
|
318 };
|
|
|
319
|
|
|
320 } // end namespace CodeGen
|
|
|
321 } // end namespace clang
|
|
|
322
|
|
|
323 #endif
|
