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