b3d99ac2cd
Use the DataLayout-aware TargetFolder instead of ConstantFolder in Clang's CGBuilder. The primary impact of this change is that GEP constant expressions are now emitted in canonical `getelementptr i8` form. This is in preparation for the migration to ptradd, which requires this form. Part of the test updates were performed by Claude Code and reviewed by me.
463 lines
19 KiB
C++
463 lines
19 KiB
C++
//===-- CGBuilder.h - Choose IRBuilder implementation ----------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H
|
|
#define LLVM_CLANG_LIB_CODEGEN_CGBUILDER_H
|
|
|
|
#include "Address.h"
|
|
#include "CGValue.h"
|
|
#include "CodeGenModule.h"
|
|
#include "CodeGenTypeCache.h"
|
|
#include "llvm/Analysis/TargetFolder.h"
|
|
#include "llvm/Analysis/Utils/Local.h"
|
|
#include "llvm/IR/DataLayout.h"
|
|
#include "llvm/IR/GEPNoWrapFlags.h"
|
|
#include "llvm/IR/IRBuilder.h"
|
|
#include "llvm/IR/Type.h"
|
|
|
|
namespace clang {
|
|
namespace CodeGen {
|
|
|
|
class CGBuilderTy;
|
|
class CodeGenFunction;
|
|
|
|
/// This is an IRBuilder insertion helper that forwards to
|
|
/// CodeGenFunction::InsertHelper, which adds necessary metadata to
|
|
/// instructions.
|
|
class CGBuilderInserter final : public llvm::IRBuilderDefaultInserter {
|
|
friend CGBuilderTy;
|
|
|
|
public:
|
|
CGBuilderInserter() = default;
|
|
explicit CGBuilderInserter(CodeGenFunction *CGF) : CGF(CGF) {}
|
|
|
|
/// This forwards to CodeGenFunction::InsertHelper.
|
|
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
|
|
llvm::BasicBlock::iterator InsertPt) const override;
|
|
|
|
private:
|
|
CodeGenFunction *CGF = nullptr;
|
|
};
|
|
|
|
typedef CGBuilderInserter CGBuilderInserterTy;
|
|
|
|
typedef llvm::IRBuilder<llvm::TargetFolder, CGBuilderInserterTy>
|
|
CGBuilderBaseTy;
|
|
|
|
class CGBuilderTy : public CGBuilderBaseTy {
|
|
friend class Address;
|
|
|
|
/// Storing a reference to the type cache here makes it a lot easier
|
|
/// to build natural-feeling, target-specific IR.
|
|
const CodeGenTypeCache &TypeCache;
|
|
|
|
CodeGenFunction *getCGF() const { return getInserter().CGF; }
|
|
|
|
llvm::Value *emitRawPointerFromAddress(Address Addr) const {
|
|
return Addr.getBasePointer();
|
|
}
|
|
|
|
template <bool IsInBounds>
|
|
Address createConstGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
|
|
const llvm::Twine &Name) {
|
|
const llvm::DataLayout &DL = BB->getDataLayout();
|
|
llvm::Value *V;
|
|
if (IsInBounds)
|
|
V = CreateConstInBoundsGEP2_32(Addr.getElementType(),
|
|
emitRawPointerFromAddress(Addr), Idx0,
|
|
Idx1, Name);
|
|
else
|
|
V = CreateConstGEP2_32(Addr.getElementType(),
|
|
emitRawPointerFromAddress(Addr), Idx0, Idx1, Name);
|
|
llvm::APInt Offset(
|
|
DL.getIndexSizeInBits(Addr.getType()->getPointerAddressSpace()), 0,
|
|
/*isSigned=*/true);
|
|
if (!llvm::GEPOperator::accumulateConstantOffset(
|
|
Addr.getElementType(), {getInt32(Idx0), getInt32(Idx1)}, DL,
|
|
Offset))
|
|
llvm_unreachable(
|
|
"accumulateConstantOffset with constant indices should not fail.");
|
|
llvm::Type *ElementTy = llvm::GetElementPtrInst::getIndexedType(
|
|
Addr.getElementType(), {Idx0, Idx1});
|
|
return Address(V, ElementTy,
|
|
Addr.getAlignment().alignmentAtOffset(
|
|
CharUnits::fromQuantity(Offset.getSExtValue())),
|
|
IsInBounds ? Addr.isKnownNonNull() : NotKnownNonNull);
|
|
}
|
|
|
|
public:
|
|
CGBuilderTy(const CodeGenModule &CGM, llvm::LLVMContext &C)
|
|
: CGBuilderBaseTy(C, llvm::TargetFolder(CGM.getDataLayout())),
|
|
TypeCache(CGM) {}
|
|
CGBuilderTy(const CodeGenModule &CGM, llvm::LLVMContext &C,
|
|
const CGBuilderInserterTy &Inserter)
|
|
: CGBuilderBaseTy(C, llvm::TargetFolder(CGM.getDataLayout()), Inserter),
|
|
TypeCache(CGM) {}
|
|
CGBuilderTy(const CodeGenModule &CGM, llvm::Instruction *I)
|
|
: CGBuilderBaseTy(I->getParent(), I->getIterator(),
|
|
llvm::TargetFolder(CGM.getDataLayout())),
|
|
TypeCache(CGM) {}
|
|
CGBuilderTy(const CodeGenModule &CGM, llvm::BasicBlock *BB)
|
|
: CGBuilderBaseTy(BB, llvm::TargetFolder(CGM.getDataLayout())),
|
|
TypeCache(CGM) {}
|
|
|
|
llvm::ConstantInt *getSize(CharUnits N) {
|
|
return llvm::ConstantInt::getSigned(TypeCache.SizeTy, N.getQuantity());
|
|
}
|
|
llvm::ConstantInt *getSize(uint64_t N) {
|
|
return llvm::ConstantInt::get(TypeCache.SizeTy, N);
|
|
}
|
|
|
|
// Note that we intentionally hide the CreateLoad APIs that don't
|
|
// take an alignment.
|
|
llvm::LoadInst *CreateLoad(Address Addr, const llvm::Twine &Name = "") {
|
|
return CreateAlignedLoad(Addr.getElementType(),
|
|
emitRawPointerFromAddress(Addr),
|
|
Addr.getAlignment().getAsAlign(), Name);
|
|
}
|
|
llvm::LoadInst *CreateLoad(Address Addr, const char *Name) {
|
|
// This overload is required to prevent string literals from
|
|
// ending up in the IsVolatile overload.
|
|
return CreateAlignedLoad(Addr.getElementType(),
|
|
emitRawPointerFromAddress(Addr),
|
|
Addr.getAlignment().getAsAlign(), Name);
|
|
}
|
|
llvm::LoadInst *CreateLoad(Address Addr, bool IsVolatile,
|
|
const llvm::Twine &Name = "") {
|
|
return CreateAlignedLoad(
|
|
Addr.getElementType(), emitRawPointerFromAddress(Addr),
|
|
Addr.getAlignment().getAsAlign(), IsVolatile, Name);
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateAlignedLoad;
|
|
llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr,
|
|
CharUnits Align,
|
|
const llvm::Twine &Name = "") {
|
|
return CreateAlignedLoad(Ty, Addr, Align.getAsAlign(), Name);
|
|
}
|
|
|
|
// Note that we intentionally hide the CreateStore APIs that don't
|
|
// take an alignment.
|
|
llvm::StoreInst *CreateStore(llvm::Value *Val, Address Addr,
|
|
bool IsVolatile = false) {
|
|
return CreateAlignedStore(Val, emitRawPointerFromAddress(Addr),
|
|
Addr.getAlignment().getAsAlign(), IsVolatile);
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateAlignedStore;
|
|
llvm::StoreInst *CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr,
|
|
CharUnits Align,
|
|
bool IsVolatile = false) {
|
|
return CreateAlignedStore(Val, Addr, Align.getAsAlign(), IsVolatile);
|
|
}
|
|
|
|
// FIXME: these "default-aligned" APIs should be removed,
|
|
// but I don't feel like fixing all the builtin code right now.
|
|
llvm::StoreInst *CreateDefaultAlignedStore(llvm::Value *Val,
|
|
llvm::Value *Addr,
|
|
bool IsVolatile = false) {
|
|
return CGBuilderBaseTy::CreateStore(Val, Addr, IsVolatile);
|
|
}
|
|
|
|
/// Emit a load from an i1 flag variable.
|
|
llvm::LoadInst *CreateFlagLoad(llvm::Value *Addr,
|
|
const llvm::Twine &Name = "") {
|
|
return CreateAlignedLoad(getInt1Ty(), Addr, CharUnits::One(), Name);
|
|
}
|
|
|
|
/// Emit a store to an i1 flag variable.
|
|
llvm::StoreInst *CreateFlagStore(bool Value, llvm::Value *Addr) {
|
|
return CreateAlignedStore(getInt1(Value), Addr, CharUnits::One());
|
|
}
|
|
|
|
llvm::AtomicCmpXchgInst *
|
|
CreateAtomicCmpXchg(Address Addr, llvm::Value *Cmp, llvm::Value *New,
|
|
llvm::AtomicOrdering SuccessOrdering,
|
|
llvm::AtomicOrdering FailureOrdering,
|
|
llvm::SyncScope::ID SSID = llvm::SyncScope::System) {
|
|
return CGBuilderBaseTy::CreateAtomicCmpXchg(
|
|
Addr.emitRawPointer(*getCGF()), Cmp, New,
|
|
Addr.getAlignment().getAsAlign(), SuccessOrdering, FailureOrdering,
|
|
SSID);
|
|
}
|
|
|
|
llvm::AtomicRMWInst *
|
|
CreateAtomicRMW(llvm::AtomicRMWInst::BinOp Op, Address Addr, llvm::Value *Val,
|
|
llvm::AtomicOrdering Ordering,
|
|
llvm::SyncScope::ID SSID = llvm::SyncScope::System) {
|
|
return CGBuilderBaseTy::CreateAtomicRMW(
|
|
Op, Addr.emitRawPointer(*getCGF()), Val,
|
|
Addr.getAlignment().getAsAlign(), Ordering, SSID);
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateAddrSpaceCast;
|
|
Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty,
|
|
llvm::Type *ElementTy,
|
|
const llvm::Twine &Name = "") {
|
|
if (!Addr.hasOffset())
|
|
return Address(CreateAddrSpaceCast(Addr.getBasePointer(), Ty, Name),
|
|
ElementTy, Addr.getAlignment(), Addr.getPointerAuthInfo(),
|
|
/*Offset=*/nullptr, Addr.isKnownNonNull());
|
|
// Eagerly force a raw address if these is an offset.
|
|
return RawAddress(
|
|
CreateAddrSpaceCast(Addr.emitRawPointer(*getCGF()), Ty, Name),
|
|
ElementTy, Addr.getAlignment(), Addr.isKnownNonNull());
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreatePointerBitCastOrAddrSpaceCast;
|
|
Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty,
|
|
llvm::Type *ElementTy,
|
|
const llvm::Twine &Name = "") {
|
|
if (Addr.getType()->getAddressSpace() == Ty->getPointerAddressSpace())
|
|
return Addr.withElementType(ElementTy);
|
|
return CreateAddrSpaceCast(Addr, Ty, ElementTy, Name);
|
|
}
|
|
|
|
/// Given
|
|
/// %addr = {T1, T2...}* ...
|
|
/// produce
|
|
/// %name = getelementptr inbounds nuw %addr, i32 0, i32 index
|
|
///
|
|
/// This API assumes that drilling into a struct like this is always an
|
|
/// inbounds and nuw operation.
|
|
using CGBuilderBaseTy::CreateStructGEP;
|
|
Address CreateStructGEP(Address Addr, unsigned Index,
|
|
const llvm::Twine &Name = "") {
|
|
llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType());
|
|
const llvm::DataLayout &DL = BB->getDataLayout();
|
|
const llvm::StructLayout *Layout = DL.getStructLayout(ElTy);
|
|
auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
|
|
|
|
return Address(CreateStructGEP(Addr.getElementType(), Addr.getBasePointer(),
|
|
Index, Name),
|
|
ElTy->getElementType(Index),
|
|
Addr.getAlignment().alignmentAtOffset(Offset),
|
|
Addr.isKnownNonNull());
|
|
}
|
|
|
|
/// Given
|
|
/// %addr = [n x T]* ...
|
|
/// produce
|
|
/// %name = getelementptr inbounds %addr, i64 0, i64 index
|
|
/// where i64 is actually the target word size.
|
|
///
|
|
/// This API assumes that drilling into an array like this is always
|
|
/// an inbounds operation.
|
|
Address CreateConstArrayGEP(Address Addr, uint64_t Index,
|
|
const llvm::Twine &Name = "") {
|
|
llvm::ArrayType *ElTy = cast<llvm::ArrayType>(Addr.getElementType());
|
|
const llvm::DataLayout &DL = BB->getDataLayout();
|
|
CharUnits EltSize =
|
|
CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy->getElementType()));
|
|
|
|
return Address(
|
|
CreateInBoundsGEP(Addr.getElementType(), Addr.getBasePointer(),
|
|
{getSize(CharUnits::Zero()), getSize(Index)}, Name),
|
|
ElTy->getElementType(),
|
|
Addr.getAlignment().alignmentAtOffset(Index * EltSize),
|
|
Addr.isKnownNonNull());
|
|
}
|
|
|
|
/// Given
|
|
/// %addr = T* ...
|
|
/// produce
|
|
/// %name = getelementptr inbounds %addr, i64 index
|
|
/// where i64 is actually the target word size.
|
|
Address CreateConstInBoundsGEP(Address Addr, uint64_t Index,
|
|
const llvm::Twine &Name = "") {
|
|
llvm::Type *ElTy = Addr.getElementType();
|
|
const llvm::DataLayout &DL = BB->getDataLayout();
|
|
CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy));
|
|
|
|
return Address(
|
|
CreateInBoundsGEP(ElTy, Addr.getBasePointer(), getSize(Index), Name),
|
|
ElTy, Addr.getAlignment().alignmentAtOffset(Index * EltSize),
|
|
Addr.isKnownNonNull());
|
|
}
|
|
|
|
/// Given
|
|
/// %addr = T* ...
|
|
/// produce
|
|
/// %name = getelementptr inbounds %addr, i64 index
|
|
/// where i64 is actually the target word size.
|
|
Address CreateConstGEP(Address Addr, uint64_t Index,
|
|
const llvm::Twine &Name = "") {
|
|
llvm::Type *ElTy = Addr.getElementType();
|
|
const llvm::DataLayout &DL = BB->getDataLayout();
|
|
CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy));
|
|
|
|
return Address(CreateGEP(ElTy, Addr.getBasePointer(), getSize(Index), Name),
|
|
Addr.getElementType(),
|
|
Addr.getAlignment().alignmentAtOffset(Index * EltSize));
|
|
}
|
|
|
|
/// Create GEP with single dynamic index. The address alignment is reduced
|
|
/// according to the element size.
|
|
using CGBuilderBaseTy::CreateGEP;
|
|
Address CreateGEP(CodeGenFunction &CGF, Address Addr, llvm::Value *Index,
|
|
const llvm::Twine &Name = "") {
|
|
const llvm::DataLayout &DL = BB->getDataLayout();
|
|
CharUnits EltSize =
|
|
CharUnits::fromQuantity(DL.getTypeAllocSize(Addr.getElementType()));
|
|
|
|
return Address(
|
|
CreateGEP(Addr.getElementType(), Addr.emitRawPointer(CGF), Index, Name),
|
|
Addr.getElementType(),
|
|
Addr.getAlignment().alignmentOfArrayElement(EltSize));
|
|
}
|
|
|
|
/// Given a pointer to i8, adjust it by a given constant offset.
|
|
Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset,
|
|
const llvm::Twine &Name = "") {
|
|
assert(Addr.getElementType() == TypeCache.Int8Ty);
|
|
return Address(
|
|
CreateInBoundsGEP(Addr.getElementType(), Addr.getBasePointer(),
|
|
getSize(Offset), Name),
|
|
Addr.getElementType(), Addr.getAlignment().alignmentAtOffset(Offset),
|
|
Addr.isKnownNonNull());
|
|
}
|
|
|
|
Address CreateConstByteGEP(Address Addr, CharUnits Offset,
|
|
const llvm::Twine &Name = "") {
|
|
assert(Addr.getElementType() == TypeCache.Int8Ty);
|
|
return Address(CreateGEP(Addr.getElementType(), Addr.getBasePointer(),
|
|
getSize(Offset), Name),
|
|
Addr.getElementType(),
|
|
Addr.getAlignment().alignmentAtOffset(Offset));
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateConstInBoundsGEP2_32;
|
|
Address CreateConstInBoundsGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
|
|
const llvm::Twine &Name = "") {
|
|
return createConstGEP2_32<true>(Addr, Idx0, Idx1, Name);
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateConstGEP2_32;
|
|
Address CreateConstGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1,
|
|
const llvm::Twine &Name = "") {
|
|
return createConstGEP2_32<false>(Addr, Idx0, Idx1, Name);
|
|
}
|
|
|
|
Address CreateGEP(Address Addr, ArrayRef<llvm::Value *> IdxList,
|
|
llvm::Type *ElementType, CharUnits Align,
|
|
const Twine &Name = "",
|
|
llvm::GEPNoWrapFlags NW = llvm::GEPNoWrapFlags::none()) {
|
|
llvm::Value *Ptr = emitRawPointerFromAddress(Addr);
|
|
return RawAddress(CreateGEP(Addr.getElementType(), Ptr, IdxList, Name, NW),
|
|
ElementType, Align);
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateInBoundsGEP;
|
|
Address CreateInBoundsGEP(Address Addr, ArrayRef<llvm::Value *> IdxList,
|
|
llvm::Type *ElementType, CharUnits Align,
|
|
const Twine &Name = "") {
|
|
return RawAddress(CreateInBoundsGEP(Addr.getElementType(),
|
|
emitRawPointerFromAddress(Addr),
|
|
IdxList, Name),
|
|
ElementType, Align, Addr.isKnownNonNull());
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateIsNull;
|
|
llvm::Value *CreateIsNull(Address Addr, const Twine &Name = "") {
|
|
if (!Addr.hasOffset())
|
|
return CreateIsNull(Addr.getBasePointer(), Name);
|
|
// The pointer isn't null if Addr has an offset since offsets can always
|
|
// be applied inbound.
|
|
return llvm::ConstantInt::getFalse(Context);
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateMemCpy;
|
|
llvm::CallInst *CreateMemCpy(Address Dest, Address Src, llvm::Value *Size,
|
|
bool IsVolatile = false) {
|
|
llvm::Value *DestPtr = emitRawPointerFromAddress(Dest);
|
|
llvm::Value *SrcPtr = emitRawPointerFromAddress(Src);
|
|
return CreateMemCpy(DestPtr, Dest.getAlignment().getAsAlign(), SrcPtr,
|
|
Src.getAlignment().getAsAlign(), Size, IsVolatile);
|
|
}
|
|
llvm::CallInst *CreateMemCpy(Address Dest, Address Src, uint64_t Size,
|
|
bool IsVolatile = false) {
|
|
llvm::Value *DestPtr = emitRawPointerFromAddress(Dest);
|
|
llvm::Value *SrcPtr = emitRawPointerFromAddress(Src);
|
|
return CreateMemCpy(DestPtr, Dest.getAlignment().getAsAlign(), SrcPtr,
|
|
Src.getAlignment().getAsAlign(), Size, IsVolatile);
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateMemCpyInline;
|
|
llvm::CallInst *CreateMemCpyInline(Address Dest, Address Src, uint64_t Size) {
|
|
llvm::Value *DestPtr = emitRawPointerFromAddress(Dest);
|
|
llvm::Value *SrcPtr = emitRawPointerFromAddress(Src);
|
|
return CreateMemCpyInline(DestPtr, Dest.getAlignment().getAsAlign(), SrcPtr,
|
|
Src.getAlignment().getAsAlign(), getInt64(Size));
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateMemMove;
|
|
llvm::CallInst *CreateMemMove(Address Dest, Address Src, llvm::Value *Size,
|
|
bool IsVolatile = false) {
|
|
llvm::Value *DestPtr = emitRawPointerFromAddress(Dest);
|
|
llvm::Value *SrcPtr = emitRawPointerFromAddress(Src);
|
|
return CreateMemMove(DestPtr, Dest.getAlignment().getAsAlign(), SrcPtr,
|
|
Src.getAlignment().getAsAlign(), Size, IsVolatile);
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateMemSet;
|
|
llvm::CallInst *CreateMemSet(Address Dest, llvm::Value *Value,
|
|
llvm::Value *Size, bool IsVolatile = false) {
|
|
return CreateMemSet(emitRawPointerFromAddress(Dest), Value, Size,
|
|
Dest.getAlignment().getAsAlign(), IsVolatile);
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateMemSetInline;
|
|
llvm::CallInst *CreateMemSetInline(Address Dest, llvm::Value *Value,
|
|
uint64_t Size) {
|
|
return CreateMemSetInline(emitRawPointerFromAddress(Dest),
|
|
Dest.getAlignment().getAsAlign(), Value,
|
|
getInt64(Size));
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreatePreserveStructAccessIndex;
|
|
Address CreatePreserveStructAccessIndex(Address Addr, unsigned Index,
|
|
unsigned FieldIndex,
|
|
llvm::MDNode *DbgInfo) {
|
|
llvm::StructType *ElTy = cast<llvm::StructType>(Addr.getElementType());
|
|
const llvm::DataLayout &DL = BB->getDataLayout();
|
|
const llvm::StructLayout *Layout = DL.getStructLayout(ElTy);
|
|
auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
|
|
|
|
return Address(
|
|
CreatePreserveStructAccessIndex(ElTy, emitRawPointerFromAddress(Addr),
|
|
Index, FieldIndex, DbgInfo),
|
|
ElTy->getElementType(Index),
|
|
Addr.getAlignment().alignmentAtOffset(Offset));
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreatePreserveUnionAccessIndex;
|
|
Address CreatePreserveUnionAccessIndex(Address Addr, unsigned FieldIndex,
|
|
llvm::MDNode *DbgInfo) {
|
|
Addr.replaceBasePointer(CreatePreserveUnionAccessIndex(
|
|
Addr.getBasePointer(), FieldIndex, DbgInfo));
|
|
return Addr;
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateLaunderInvariantGroup;
|
|
Address CreateLaunderInvariantGroup(Address Addr) {
|
|
Addr.replaceBasePointer(CreateLaunderInvariantGroup(Addr.getBasePointer()));
|
|
return Addr;
|
|
}
|
|
|
|
using CGBuilderBaseTy::CreateStripInvariantGroup;
|
|
Address CreateStripInvariantGroup(Address Addr) {
|
|
Addr.replaceBasePointer(CreateStripInvariantGroup(Addr.getBasePointer()));
|
|
return Addr;
|
|
}
|
|
};
|
|
|
|
} // end namespace CodeGen
|
|
} // end namespace clang
|
|
|
|
#endif
|