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
17namespace clang {
18namespace CodeGen {
19
20class CodeGenFunction;
21
22/// This is an IRBuilder insertion helper that forwards to
23/// CodeGenFunction::InsertHelper, which adds necessary metadata to
24/// instructions.
25class CGBuilderInserter final : public llvm::IRBuilderDefaultInserter {
26public:
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,
33                    llvm::BasicBlock::iterator InsertPt) const override;
34private:
35  CodeGenFunction *CGF = nullptr;
36};
37
38typedef CGBuilderInserter CGBuilderInserterTy;
39
40typedef llvm::IRBuilder<llvm::ConstantFolder, CGBuilderInserterTy>
41    CGBuilderBaseTy;
42
43class 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;
47public:
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
324