1 //===-- CGBuilder.h - Choose IRBuilder implementation ----------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 #ifndef LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H
10 #define LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H
12 #include "llvm/IR/DataLayout.h"
13 #include "llvm/IR/IRBuilder.h"
15 #include "CodeGenTypeCache.h"
20 class CodeGenFunction;
22 /// This is an IRBuilder insertion helper that forwards to
23 /// CodeGenFunction::InsertHelper, which adds necessary metadata to
25 class CGBuilderInserter final : public llvm::IRBuilderDefaultInserter {
27 CGBuilderInserter() = default;
28 explicit CGBuilderInserter(CodeGenFunction *CGF) : CGF(CGF) {}
30 /// This forwards to CodeGenFunction::InsertHelper.
31 void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
33 llvm::BasicBlock::iterator InsertPt) const override;
35 CodeGenFunction *CGF = nullptr;
38 typedef CGBuilderInserter CGBuilderInserterTy;
40 typedef llvm::IRBuilder<llvm::ConstantFolder, CGBuilderInserterTy>
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;
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) {}
59 llvm::ConstantInt *getSize(CharUnits N) {
60 return llvm::ConstantInt::get(TypeCache.SizeTy, N.getQuantity());
62 llvm::ConstantInt *getSize(uint64_t N) {
63 return llvm::ConstantInt::get(TypeCache.SizeTy, N);
66 // Note that we intentionally hide the CreateLoad APIs that don't
68 llvm::LoadInst *CreateLoad(Address Addr, const llvm::Twine &Name = "") {
69 return CreateAlignedLoad(Addr.getPointer(),
70 Addr.getAlignment().getAsAlign(), Name);
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);
78 llvm::LoadInst *CreateLoad(Address Addr, bool IsVolatile,
79 const llvm::Twine &Name = "") {
80 return CreateAlignedLoad(
81 Addr.getPointer(), Addr.getAlignment().getAsAlign(), IsVolatile, Name);
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);
89 llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align,
91 return CreateAlignedLoad(Addr, Align.getAsAlign(), Name);
93 llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr,
95 const llvm::Twine &Name = "") {
96 assert(Addr->getType()->getPointerElementType() == Ty);
97 return CreateAlignedLoad(Addr, Align.getAsAlign(), Name);
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);
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);
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,
118 bool IsVolatile = false) {
119 return CGBuilderBaseTy::CreateStore(Val, Addr, IsVolatile);
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);
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());
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());
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());
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);
157 using CGBuilderBaseTy::CreatePointerBitCastOrAddrSpaceCast;
158 Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty,
159 const llvm::Twine &Name = "") {
161 CreatePointerBitCastOrAddrSpaceCast(Addr.getPointer(), Ty, Name);
162 return Address(Ptr, Addr.getAlignment());
166 /// %addr = {T1, T2...}* ...
168 /// %name = getelementptr inbounds %addr, i32 0, i32 index
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));
180 return Address(CreateStructGEP(Addr.getElementType(),
181 Addr.getPointer(), Index, Name),
182 Addr.getAlignment().alignmentAtOffset(Offset));
186 /// %addr = [n x T]* ...
188 /// %name = getelementptr inbounds %addr, i64 0, i64 index
189 /// where i64 is actually the target word size.
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();
198 CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy->getElementType()));
201 CreateInBoundsGEP(Addr.getPointer(),
202 {getSize(CharUnits::Zero()), getSize(Index)}, Name),
203 Addr.getAlignment().alignmentAtOffset(Index * EltSize));
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));
217 return Address(CreateInBoundsGEP(Addr.getElementType(), Addr.getPointer(),
218 getSize(Index), Name),
219 Addr.getAlignment().alignmentAtOffset(Index * EltSize));
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();
231 CharUnits::fromQuantity(DL.getTypeAllocSize(Addr.getElementType()));
233 return Address(CreateGEP(Addr.getElementType(), Addr.getPointer(),
234 getSize(Index), Name),
235 Addr.getAlignment().alignmentAtOffset(Index * EltSize));
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));
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));
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();
257 auto *GEP = cast<llvm::GetElementPtrInst>(CreateConstInBoundsGEP2_32(
258 Addr.getElementType(), Addr.getPointer(), Idx0, Idx1, Name));
260 DL.getIndexSizeInBits(Addr.getType()->getPointerAddressSpace()), 0,
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())));
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,
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,
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));
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(),
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);
304 using CGBuilderBaseTy::CreatePreserveStructAccessIndex;
305 Address CreatePreserveStructAccessIndex(Address Addr,
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));
314 return Address(CreatePreserveStructAccessIndex(ElTy, Addr.getPointer(),
315 Index, FieldIndex, DbgInfo),
316 Addr.getAlignment().alignmentAtOffset(Offset));
320 } // end namespace CodeGen
321 } // end namespace clang