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 "CGValue.h"
14#include "CodeGenModule.h"
15#include "CodeGenTypeCache.h"
16#include "llvm/Analysis/TargetFolder.h"
17#include "llvm/Analysis/Utils/Local.h"
18#include "llvm/IR/DataLayout.h"
19#include "llvm/IR/GEPNoWrapFlags.h"
20#include "llvm/IR/IRBuilder.h"
21#include "llvm/IR/Type.h"
22
23namespace clang {
24namespace CodeGen {
25
26class CGBuilderTy;
27class CodeGenFunction;
28
29/// This is an IRBuilder insertion helper that forwards to
30/// CodeGenFunction::InsertHelper, which adds necessary metadata to
31/// instructions.
32class CGBuilderInserter final : public llvm::IRBuilderDefaultInserter {
33 friend CGBuilderTy;
34
35public:
36 CGBuilderInserter() = default;
37 explicit CGBuilderInserter(CodeGenFunction *CGF) : CGF(CGF) {}
38
39 /// This forwards to CodeGenFunction::InsertHelper.
40 void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
41 llvm::BasicBlock::iterator InsertPt) const;
42
43private:
44 CodeGenFunction *CGF = nullptr;
45};
46
47typedef CGBuilderInserter CGBuilderInserterTy;
48
49typedef llvm::IRBuilder<llvm::TargetFolder, CGBuilderInserterTy>
50 CGBuilderBaseTy;
51
52class CGBuilderTy : public CGBuilderBaseTy {
53 friend class Address;
54
55 /// Storing a reference to the type cache here makes it a lot easier
56 /// to build natural-feeling, target-specific IR.
57 const CodeGenTypeCache &TypeCache;
58
59 CodeGenFunction *getCGF() const { return getInserter().CGF; }
60
61 llvm::Value *emitRawPointerFromAddress(Address Addr) const {
62 return Addr.getBasePointer();
63 }
64
65 template <bool IsInBounds>
66 Address createConstGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
67 const llvm::Twine &Name) {
68 const llvm::DataLayout &DL = getDataLayout();
69 llvm::Value *V;
70 if (IsInBounds)
71 V = CreateConstInBoundsGEP2_32(Ty: Addr.getElementType(),
72 Ptr: emitRawPointerFromAddress(Addr), Idx0,
73 Idx1, Name);
74 else
75 V = CreateConstGEP2_32(Ty: Addr.getElementType(),
76 Ptr: emitRawPointerFromAddress(Addr), Idx0, Idx1, Name);
77 llvm::APInt Offset(
78 DL.getIndexSizeInBits(AS: Addr.getType()->getPointerAddressSpace()), 0,
79 /*isSigned=*/true);
80 if (!llvm::GEPOperator::accumulateConstantOffset(
81 SourceType: Addr.getElementType(), Index: {getInt32(C: Idx0), getInt32(C: Idx1)}, DL,
82 Offset))
83 llvm_unreachable(
84 "accumulateConstantOffset with constant indices should not fail.");
85 llvm::Type *ElementTy = llvm::GetElementPtrInst::getIndexedType(
86 Ty: Addr.getElementType(), IdxList: {Idx0, Idx1});
87 return Address(V, ElementTy,
88 Addr.getAlignment().alignmentAtOffset(
89 offset: CharUnits::fromQuantity(Quantity: Offset.getSExtValue())),
90 IsInBounds ? Addr.isKnownNonNull() : NotKnownNonNull);
91 }
92
93public:
94 CGBuilderTy(const CodeGenModule &CGM, llvm::LLVMContext &C)
95 : CGBuilderBaseTy(CGM.getModule(),
96 llvm::TargetFolder(CGM.getDataLayout())),
97 TypeCache(CGM) {
98 disableGEPCanonicalization();
99 }
100 CGBuilderTy(const CodeGenModule &CGM, llvm::LLVMContext &C,
101 const CGBuilderInserterTy &Inserter)
102 : CGBuilderBaseTy(CGM.getModule(),
103 llvm::TargetFolder(CGM.getDataLayout()), Inserter),
104 TypeCache(CGM) {
105 disableGEPCanonicalization();
106 }
107 CGBuilderTy(const CodeGenModule &CGM, llvm::Instruction *I)
108 : CGBuilderBaseTy(I->getIterator(),
109 llvm::TargetFolder(CGM.getDataLayout())),
110 TypeCache(CGM) {
111 disableGEPCanonicalization();
112 }
113 CGBuilderTy(const CodeGenModule &CGM, llvm::BasicBlock *BB)
114 : CGBuilderBaseTy(BB, llvm::TargetFolder(CGM.getDataLayout())),
115 TypeCache(CGM) {
116 disableGEPCanonicalization();
117 }
118
119 llvm::ConstantInt *getSize(CharUnits N) {
120 return llvm::ConstantInt::getSigned(Ty: TypeCache.SizeTy, V: N.getQuantity());
121 }
122 llvm::ConstantInt *getSize(uint64_t N) {
123 return llvm::ConstantInt::get(Ty: TypeCache.SizeTy, V: N);
124 }
125
126 // Note that we intentionally hide the CreateLoad APIs that don't
127 // take an alignment.
128 llvm::LoadInst *CreateLoad(Address Addr, const llvm::Twine &Name = "") {
129 return CreateAlignedLoad(Ty: Addr.getElementType(),
130 Ptr: emitRawPointerFromAddress(Addr),
131 Align: Addr.getAlignment().getAsAlign(), Name);
132 }
133 llvm::LoadInst *CreateLoad(Address Addr, const char *Name) {
134 // This overload is required to prevent string literals from
135 // ending up in the IsVolatile overload.
136 return CreateAlignedLoad(Ty: Addr.getElementType(),
137 Ptr: emitRawPointerFromAddress(Addr),
138 Align: Addr.getAlignment().getAsAlign(), Name);
139 }
140 llvm::LoadInst *CreateLoad(Address Addr, bool IsVolatile,
141 const llvm::Twine &Name = "") {
142 return CreateAlignedLoad(
143 Ty: Addr.getElementType(), Ptr: emitRawPointerFromAddress(Addr),
144 Align: Addr.getAlignment().getAsAlign(), isVolatile: IsVolatile, Name);
145 }
146
147 using CGBuilderBaseTy::CreateAlignedLoad;
148 llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr,
149 CharUnits Align,
150 const llvm::Twine &Name = "") {
151 return CreateAlignedLoad(Ty, Ptr: Addr, Align: Align.getAsAlign(), Name);
152 }
153
154 // Note that we intentionally hide the CreateStore APIs that don't
155 // take an alignment.
156 llvm::StoreInst *CreateStore(llvm::Value *Val, Address Addr,
157 bool IsVolatile = false) {
158 return CreateAlignedStore(Val, Ptr: emitRawPointerFromAddress(Addr),
159 Align: Addr.getAlignment().getAsAlign(), isVolatile: IsVolatile);
160 }
161
162 using CGBuilderBaseTy::CreateAlignedStore;
163 llvm::StoreInst *CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr,
164 CharUnits Align,
165 bool IsVolatile = false) {
166 return CreateAlignedStore(Val, Ptr: Addr, Align: Align.getAsAlign(), isVolatile: IsVolatile);
167 }
168
169 // FIXME: these "default-aligned" APIs should be removed,
170 // but I don't feel like fixing all the builtin code right now.
171 llvm::StoreInst *CreateDefaultAlignedStore(llvm::Value *Val,
172 llvm::Value *Addr,
173 bool IsVolatile = false) {
174 return CGBuilderBaseTy::CreateStore(Val, Ptr: Addr, isVolatile: IsVolatile);
175 }
176
177 /// Emit a load from an i1 flag variable.
178 llvm::LoadInst *CreateFlagLoad(llvm::Value *Addr,
179 const llvm::Twine &Name = "") {
180 return CreateAlignedLoad(Ty: getInt1Ty(), Addr, Align: CharUnits::One(), Name);
181 }
182
183 /// Emit a store to an i1 flag variable.
184 llvm::StoreInst *CreateFlagStore(bool Value, llvm::Value *Addr) {
185 return CreateAlignedStore(Val: getInt1(V: Value), Addr, Align: CharUnits::One());
186 }
187
188 llvm::AtomicCmpXchgInst *
189 CreateAtomicCmpXchg(Address Addr, llvm::Value *Cmp, llvm::Value *New,
190 llvm::AtomicOrdering SuccessOrdering,
191 llvm::AtomicOrdering FailureOrdering,
192 llvm::SyncScope::ID SSID = llvm::SyncScope::System) {
193 return CGBuilderBaseTy::CreateAtomicCmpXchg(
194 Ptr: Addr.emitRawPointer(CGF&: *getCGF()), Cmp, New,
195 Align: Addr.getAlignment().getAsAlign(), SuccessOrdering, FailureOrdering,
196 SSID);
197 }
198
199 llvm::AtomicRMWInst *
200 CreateAtomicRMW(llvm::AtomicRMWInst::BinOp Op, Address Addr, llvm::Value *Val,
201 llvm::AtomicOrdering Ordering,
202 llvm::SyncScope::ID SSID = llvm::SyncScope::System) {
203 return CGBuilderBaseTy::CreateAtomicRMW(
204 Op, Ptr: Addr.emitRawPointer(CGF&: *getCGF()), Val,
205 Align: Addr.getAlignment().getAsAlign(), Ordering, SSID);
206 }
207
208 using CGBuilderBaseTy::CreateAddrSpaceCast;
209 Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty,
210 llvm::Type *ElementTy,
211 const llvm::Twine &Name = "") {
212 if (!Addr.hasOffset())
213 return Address(CreateAddrSpaceCast(V: Addr.getBasePointer(), DestTy: Ty, Name),
214 ElementTy, Addr.getAlignment(), Addr.getPointerAuthInfo(),
215 /*Offset=*/nullptr, Addr.isKnownNonNull());
216 // Eagerly force a raw address if these is an offset.
217 return RawAddress(
218 CreateAddrSpaceCast(V: Addr.emitRawPointer(CGF&: *getCGF()), DestTy: Ty, Name),
219 ElementTy, Addr.getAlignment(), Addr.isKnownNonNull());
220 }
221
222 using CGBuilderBaseTy::CreatePointerBitCastOrAddrSpaceCast;
223 Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty,
224 llvm::Type *ElementTy,
225 const llvm::Twine &Name = "") {
226 if (Addr.getType()->getAddressSpace() == Ty->getPointerAddressSpace())
227 return Addr.withElementType(ElemTy: ElementTy);
228 return CreateAddrSpaceCast(Addr, Ty, ElementTy, Name);
229 }
230
231 /// Given
232 /// %addr = {T1, T2...}* ...
233 /// produce
234 /// %name = getelementptr inbounds nuw %addr, i32 0, i32 index
235 ///
236 /// This API assumes that drilling into a struct like this is always an
237 /// inbounds and nuw operation.
238 using CGBuilderBaseTy::CreateStructGEP;
239 Address CreateStructGEP(Address Addr, unsigned Index,
240 const llvm::Twine &Name = "") {
241 llvm::StructType *ElTy = cast<llvm::StructType>(Val: Addr.getElementType());
242 const llvm::DataLayout &DL = getDataLayout();
243 const llvm::StructLayout *Layout = DL.getStructLayout(Ty: ElTy);
244 auto Offset = CharUnits::fromQuantity(Quantity: Layout->getElementOffset(Idx: Index));
245
246 return Address(CreateStructGEP(Ty: Addr.getElementType(), Ptr: Addr.getBasePointer(),
247 Idx: Index, Name),
248 ElTy->getElementType(N: Index),
249 Addr.getAlignment().alignmentAtOffset(offset: Offset),
250 Addr.isKnownNonNull());
251 }
252
253 /// Given
254 /// %addr = [n x T]* ...
255 /// produce
256 /// %name = getelementptr inbounds %addr, i64 0, i64 index
257 /// where i64 is actually the target word size.
258 ///
259 /// This API assumes that drilling into an array like this is always
260 /// an inbounds operation.
261 Address CreateConstArrayGEP(Address Addr, uint64_t Index,
262 const llvm::Twine &Name = "") {
263 llvm::ArrayType *ElTy = cast<llvm::ArrayType>(Val: Addr.getElementType());
264 const llvm::DataLayout &DL = getDataLayout();
265 CharUnits EltSize =
266 CharUnits::fromQuantity(Quantity: DL.getTypeAllocSize(Ty: ElTy->getElementType()));
267
268 return Address(
269 CreateInBoundsGEP(Ty: Addr.getElementType(), Ptr: Addr.getBasePointer(),
270 IdxList: {getSize(N: CharUnits::Zero()), getSize(N: Index)}, Name),
271 ElTy->getElementType(),
272 Addr.getAlignment().alignmentAtOffset(offset: Index * EltSize),
273 Addr.isKnownNonNull());
274 }
275
276 /// Given
277 /// %addr = T* ...
278 /// produce
279 /// %name = getelementptr inbounds %addr, i64 index
280 /// where i64 is actually the target word size.
281 Address CreateConstInBoundsGEP(Address Addr, uint64_t Index,
282 const llvm::Twine &Name = "") {
283 llvm::Type *ElTy = Addr.getElementType();
284 const llvm::DataLayout &DL = getDataLayout();
285 CharUnits EltSize = CharUnits::fromQuantity(Quantity: DL.getTypeAllocSize(Ty: ElTy));
286
287 return Address(
288 CreateInBoundsGEP(Ty: ElTy, Ptr: Addr.getBasePointer(), IdxList: getSize(N: Index), Name),
289 ElTy, Addr.getAlignment().alignmentAtOffset(offset: Index * EltSize),
290 Addr.isKnownNonNull());
291 }
292
293 /// Given
294 /// %addr = T* ...
295 /// produce
296 /// %name = getelementptr inbounds %addr, i64 index
297 /// where i64 is actually the target word size.
298 Address CreateConstGEP(Address Addr, uint64_t Index,
299 const llvm::Twine &Name = "") {
300 llvm::Type *ElTy = Addr.getElementType();
301 const llvm::DataLayout &DL = getDataLayout();
302 CharUnits EltSize = CharUnits::fromQuantity(Quantity: DL.getTypeAllocSize(Ty: ElTy));
303
304 return Address(CreateGEP(Ty: ElTy, Ptr: Addr.getBasePointer(), IdxList: getSize(N: Index), Name),
305 Addr.getElementType(),
306 Addr.getAlignment().alignmentAtOffset(offset: Index * EltSize));
307 }
308
309 /// Create GEP with single dynamic index. The address alignment is reduced
310 /// according to the element size.
311 using CGBuilderBaseTy::CreateGEP;
312 Address CreateGEP(CodeGenFunction &CGF, Address Addr, llvm::Value *Index,
313 const llvm::Twine &Name = "") {
314 const llvm::DataLayout &DL = getDataLayout();
315 CharUnits EltSize =
316 CharUnits::fromQuantity(Quantity: DL.getTypeAllocSize(Ty: Addr.getElementType()));
317
318 return Address(
319 CreateGEP(Ty: Addr.getElementType(), Ptr: Addr.emitRawPointer(CGF), IdxList: Index, Name),
320 Addr.getElementType(),
321 Addr.getAlignment().alignmentOfArrayElement(elementSize: EltSize));
322 }
323
324 /// Given a pointer to i8, adjust it by a given constant offset.
325 Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset,
326 const llvm::Twine &Name = "") {
327 assert(Addr.getElementType() == TypeCache.Int8Ty);
328 return Address(
329 CreateInBoundsGEP(Ty: Addr.getElementType(), Ptr: Addr.getBasePointer(),
330 IdxList: getSize(N: Offset), Name),
331 Addr.getElementType(), Addr.getAlignment().alignmentAtOffset(offset: Offset),
332 Addr.isKnownNonNull());
333 }
334
335 Address CreateConstByteGEP(Address Addr, CharUnits Offset,
336 const llvm::Twine &Name = "") {
337 assert(Addr.getElementType() == TypeCache.Int8Ty);
338 return Address(CreateGEP(Ty: Addr.getElementType(), Ptr: Addr.getBasePointer(),
339 IdxList: getSize(N: Offset), Name),
340 Addr.getElementType(),
341 Addr.getAlignment().alignmentAtOffset(offset: Offset));
342 }
343
344 using CGBuilderBaseTy::CreateConstInBoundsGEP2_32;
345 Address CreateConstInBoundsGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
346 const llvm::Twine &Name = "") {
347 return createConstGEP2_32<true>(Addr, Idx0, Idx1, Name);
348 }
349
350 using CGBuilderBaseTy::CreateConstGEP2_32;
351 Address CreateConstGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
352 const llvm::Twine &Name = "") {
353 return createConstGEP2_32<false>(Addr, Idx0, Idx1, Name);
354 }
355
356 Address CreateGEP(Address Addr, ArrayRef<llvm::Value *> IdxList,
357 llvm::Type *ElementType, CharUnits Align,
358 const Twine &Name = "",
359 llvm::GEPNoWrapFlags NW = llvm::GEPNoWrapFlags::none()) {
360 llvm::Value *Ptr = emitRawPointerFromAddress(Addr);
361 return RawAddress(CreateGEP(Ty: Addr.getElementType(), Ptr, IdxList, Name, NW),
362 ElementType, Align);
363 }
364
365 using CGBuilderBaseTy::CreateInBoundsGEP;
366 Address CreateInBoundsGEP(Address Addr, ArrayRef<llvm::Value *> IdxList,
367 llvm::Type *ElementType, CharUnits Align,
368 const Twine &Name = "") {
369 return RawAddress(CreateInBoundsGEP(Ty: Addr.getElementType(),
370 Ptr: emitRawPointerFromAddress(Addr),
371 IdxList, Name),
372 ElementType, Align, Addr.isKnownNonNull());
373 }
374
375 using CGBuilderBaseTy::CreateStructuredGEP;
376 llvm::Value *CreateAccessChain(bool Logical, llvm::Type *BaseType,
377 llvm::Value *PtrBase,
378 ArrayRef<llvm::Value *> IdxList,
379 const Twine &Name = "") {
380
381 if (Logical)
382 return CreateStructuredGEP(BaseType, PtrBase, Indices: IdxList, Name);
383 return CreateInBoundsGEP(Ty: BaseType, Ptr: PtrBase, IdxList, Name);
384 }
385
386 Address CreateAccessChain(bool Logical, Address Addr,
387 ArrayRef<llvm::Value *> IdxList,
388 llvm::Type *ElementType, CharUnits Align,
389 const Twine &Name = "") {
390
391 return RawAddress(CreateAccessChain(Logical, BaseType: Addr.getElementType(),
392 PtrBase: emitRawPointerFromAddress(Addr),
393 IdxList, Name),
394 ElementType, Align, Addr.isKnownNonNull());
395 }
396
397 using CGBuilderBaseTy::CreateIsNull;
398 llvm::Value *CreateIsNull(Address Addr, const Twine &Name = "") {
399 if (!Addr.hasOffset())
400 return CreateIsNull(Arg: Addr.getBasePointer(), Name);
401 // The pointer isn't null if Addr has an offset since offsets can always
402 // be applied inbound.
403 return llvm::ConstantInt::getFalse(Context);
404 }
405
406 using CGBuilderBaseTy::CreateMemCpy;
407 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, llvm::Value *Size,
408 bool IsVolatile = false) {
409 llvm::Value *DestPtr = emitRawPointerFromAddress(Addr: Dest);
410 llvm::Value *SrcPtr = emitRawPointerFromAddress(Addr: Src);
411 return CreateMemCpy(Dst: DestPtr, DstAlign: Dest.getAlignment().getAsAlign(), Src: SrcPtr,
412 SrcAlign: Src.getAlignment().getAsAlign(), Size, isVolatile: IsVolatile);
413 }
414 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, uint64_t Size,
415 bool IsVolatile = false) {
416 llvm::Value *DestPtr = emitRawPointerFromAddress(Addr: Dest);
417 llvm::Value *SrcPtr = emitRawPointerFromAddress(Addr: Src);
418 return CreateMemCpy(Dst: DestPtr, DstAlign: Dest.getAlignment().getAsAlign(), Src: SrcPtr,
419 SrcAlign: Src.getAlignment().getAsAlign(), Size, isVolatile: IsVolatile);
420 }
421
422 using CGBuilderBaseTy::CreateMemCpyInline;
423 llvm::CallInst *CreateMemCpyInline(Address Dest, Address Src, uint64_t Size) {
424 llvm::Value *DestPtr = emitRawPointerFromAddress(Addr: Dest);
425 llvm::Value *SrcPtr = emitRawPointerFromAddress(Addr: Src);
426 return CreateMemCpyInline(Dst: DestPtr, DstAlign: Dest.getAlignment().getAsAlign(), Src: SrcPtr,
427 SrcAlign: Src.getAlignment().getAsAlign(), Size: getInt64(C: Size));
428 }
429
430 using CGBuilderBaseTy::CreateMemMove;
431 llvm::CallInst *CreateMemMove(Address Dest, Address Src, llvm::Value *Size,
432 bool IsVolatile = false) {
433 llvm::Value *DestPtr = emitRawPointerFromAddress(Addr: Dest);
434 llvm::Value *SrcPtr = emitRawPointerFromAddress(Addr: Src);
435 return CreateMemMove(Dst: DestPtr, DstAlign: Dest.getAlignment().getAsAlign(), Src: SrcPtr,
436 SrcAlign: Src.getAlignment().getAsAlign(), Size, isVolatile: IsVolatile);
437 }
438
439 using CGBuilderBaseTy::CreateMemSet;
440 llvm::CallInst *CreateMemSet(Address Dest, llvm::Value *Value,
441 llvm::Value *Size, bool IsVolatile = false) {
442 return CreateMemSet(Ptr: emitRawPointerFromAddress(Addr: Dest), Val: Value, Size,
443 Align: Dest.getAlignment().getAsAlign(), isVolatile: IsVolatile);
444 }
445
446 using CGBuilderBaseTy::CreateMemSetInline;
447 llvm::CallInst *CreateMemSetInline(Address Dest, llvm::Value *Value,
448 uint64_t Size) {
449 return CreateMemSetInline(Dst: emitRawPointerFromAddress(Addr: Dest),
450 DstAlign: Dest.getAlignment().getAsAlign(), Val: Value,
451 Size: getInt64(C: Size));
452 }
453
454 using CGBuilderBaseTy::CreatePreserveStructAccessIndex;
455 Address CreatePreserveStructAccessIndex(Address Addr, unsigned Index,
456 unsigned FieldIndex,
457 llvm::MDNode *DbgInfo) {
458 llvm::StructType *ElTy = cast<llvm::StructType>(Val: Addr.getElementType());
459 const llvm::DataLayout &DL = getDataLayout();
460 const llvm::StructLayout *Layout = DL.getStructLayout(Ty: ElTy);
461 auto Offset = CharUnits::fromQuantity(Quantity: Layout->getElementOffset(Idx: Index));
462
463 return Address(
464 CreatePreserveStructAccessIndex(ElTy, Base: emitRawPointerFromAddress(Addr),
465 Index, FieldIndex, DbgInfo),
466 ElTy->getElementType(N: Index),
467 Addr.getAlignment().alignmentAtOffset(offset: Offset));
468 }
469
470 using CGBuilderBaseTy::CreatePreserveUnionAccessIndex;
471 Address CreatePreserveUnionAccessIndex(Address Addr, unsigned FieldIndex,
472 llvm::MDNode *DbgInfo) {
473 Addr.replaceBasePointer(P: CreatePreserveUnionAccessIndex(
474 Base: Addr.getBasePointer(), FieldIndex, DbgInfo));
475 return Addr;
476 }
477
478 using CGBuilderBaseTy::CreateLaunderInvariantGroup;
479 Address CreateLaunderInvariantGroup(Address Addr) {
480 Addr.replaceBasePointer(P: CreateLaunderInvariantGroup(Ptr: Addr.getBasePointer()));
481 return Addr;
482 }
483};
484
485} // end namespace CodeGen
486} // end namespace clang
487
488#endif
489