1004 lines
41 KiB
C++
1004 lines
41 KiB
C++
//===--- CGNonTrivialStruct.cpp - Emit Special Functions for C Structs ----===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines functions to generate various special functions for C
|
|
// structs.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "CodeGenFunction.h"
|
|
#include "CodeGenModule.h"
|
|
#include "clang/AST/NonTrivialTypeVisitor.h"
|
|
#include "clang/CodeGen/CodeGenABITypes.h"
|
|
#include "llvm/Support/ScopedPrinter.h"
|
|
#include <array>
|
|
|
|
using namespace clang;
|
|
using namespace CodeGen;
|
|
|
|
// Return the size of a field in number of bits.
|
|
static uint64_t getFieldSize(const FieldDecl *FD, QualType FT,
|
|
ASTContext &Ctx) {
|
|
if (FD && FD->isBitField())
|
|
return FD->getBitWidthValue(Ctx);
|
|
return Ctx.getTypeSize(FT);
|
|
}
|
|
|
|
namespace {
|
|
enum { DstIdx = 0, SrcIdx = 1 };
|
|
const char *ValNameStr[2] = {"dst", "src"};
|
|
|
|
template <class Derived> struct StructVisitor {
|
|
StructVisitor(ASTContext &Ctx) : Ctx(Ctx) {}
|
|
|
|
template <class... Ts>
|
|
void visitStructFields(QualType QT, CharUnits CurStructOffset, Ts... Args) {
|
|
const RecordDecl *RD = QT->castAs<RecordType>()->getDecl();
|
|
|
|
// Iterate over the fields of the struct.
|
|
for (const FieldDecl *FD : RD->fields()) {
|
|
QualType FT = FD->getType();
|
|
FT = QT.isVolatileQualified() ? FT.withVolatile() : FT;
|
|
asDerived().visit(FT, FD, CurStructOffset, Args...);
|
|
}
|
|
|
|
asDerived().flushTrivialFields(Args...);
|
|
}
|
|
|
|
template <class... Ts> void visitTrivial(Ts... Args) {}
|
|
|
|
template <class... Ts> void visitCXXDestructor(Ts... Args) {
|
|
llvm_unreachable("field of a C++ struct type is not expected");
|
|
}
|
|
|
|
template <class... Ts> void flushTrivialFields(Ts... Args) {}
|
|
|
|
uint64_t getFieldOffsetInBits(const FieldDecl *FD) {
|
|
return FD ? Ctx.getASTRecordLayout(FD->getParent())
|
|
.getFieldOffset(FD->getFieldIndex())
|
|
: 0;
|
|
}
|
|
|
|
CharUnits getFieldOffset(const FieldDecl *FD) {
|
|
return Ctx.toCharUnitsFromBits(getFieldOffsetInBits(FD));
|
|
}
|
|
|
|
Derived &asDerived() { return static_cast<Derived &>(*this); }
|
|
|
|
ASTContext &getContext() { return Ctx; }
|
|
ASTContext &Ctx;
|
|
};
|
|
|
|
template <class Derived, bool IsMove>
|
|
struct CopyStructVisitor : StructVisitor<Derived>,
|
|
CopiedTypeVisitor<Derived, IsMove> {
|
|
using StructVisitor<Derived>::asDerived;
|
|
using Super = CopiedTypeVisitor<Derived, IsMove>;
|
|
|
|
CopyStructVisitor(ASTContext &Ctx) : StructVisitor<Derived>(Ctx) {}
|
|
|
|
template <class... Ts>
|
|
void preVisit(QualType::PrimitiveCopyKind PCK, QualType FT,
|
|
const FieldDecl *FD, CharUnits CurStructOffset, Ts &&... Args) {
|
|
if (PCK)
|
|
asDerived().flushTrivialFields(std::forward<Ts>(Args)...);
|
|
}
|
|
|
|
template <class... Ts>
|
|
void visitWithKind(QualType::PrimitiveCopyKind PCK, QualType FT,
|
|
const FieldDecl *FD, CharUnits CurStructOffset,
|
|
Ts &&... Args) {
|
|
if (const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
|
|
asDerived().visitArray(PCK, AT, FT.isVolatileQualified(), FD,
|
|
CurStructOffset, std::forward<Ts>(Args)...);
|
|
return;
|
|
}
|
|
|
|
Super::visitWithKind(PCK, FT, FD, CurStructOffset,
|
|
std::forward<Ts>(Args)...);
|
|
}
|
|
|
|
template <class... Ts>
|
|
void visitTrivial(QualType FT, const FieldDecl *FD, CharUnits CurStructOffset,
|
|
Ts... Args) {
|
|
assert(!FT.isVolatileQualified() && "volatile field not expected");
|
|
ASTContext &Ctx = asDerived().getContext();
|
|
uint64_t FieldSize = getFieldSize(FD, FT, Ctx);
|
|
|
|
// Ignore zero-sized fields.
|
|
if (FieldSize == 0)
|
|
return;
|
|
|
|
uint64_t FStartInBits = asDerived().getFieldOffsetInBits(FD);
|
|
uint64_t FEndInBits = FStartInBits + FieldSize;
|
|
uint64_t RoundedFEnd = llvm::alignTo(FEndInBits, Ctx.getCharWidth());
|
|
|
|
// Set Start if this is the first field of a sequence of trivial fields.
|
|
if (Start == End)
|
|
Start = CurStructOffset + Ctx.toCharUnitsFromBits(FStartInBits);
|
|
End = CurStructOffset + Ctx.toCharUnitsFromBits(RoundedFEnd);
|
|
}
|
|
|
|
CharUnits Start = CharUnits::Zero(), End = CharUnits::Zero();
|
|
};
|
|
|
|
// This function creates the mangled name of a special function of a non-trivial
|
|
// C struct. Since there is no ODR in C, the function is mangled based on the
|
|
// struct contents and not the name. The mangled name has the following
|
|
// structure:
|
|
//
|
|
// <function-name> ::= <prefix> <alignment-info> "_" <struct-field-info>
|
|
// <prefix> ::= "__destructor_" | "__default_constructor_" |
|
|
// "__copy_constructor_" | "__move_constructor_" |
|
|
// "__copy_assignment_" | "__move_assignment_"
|
|
// <alignment-info> ::= <dst-alignment> ["_" <src-alignment>]
|
|
// <struct-field-info> ::= <field-info>+
|
|
// <field-info> ::= <struct-or-scalar-field-info> | <array-field-info>
|
|
// <struct-or-scalar-field-info> ::= "_S" <struct-field-info> |
|
|
// <strong-field-info> | <trivial-field-info>
|
|
// <array-field-info> ::= "_AB" <array-offset> "s" <element-size> "n"
|
|
// <num-elements> <innermost-element-info> "_AE"
|
|
// <innermost-element-info> ::= <struct-or-scalar-field-info>
|
|
// <strong-field-info> ::= "_s" ["b"] ["v"] <field-offset>
|
|
// <trivial-field-info> ::= "_t" ["v"] <field-offset> "_" <field-size>
|
|
|
|
template <class Derived> struct GenFuncNameBase {
|
|
std::string getVolatileOffsetStr(bool IsVolatile, CharUnits Offset) {
|
|
std::string S;
|
|
if (IsVolatile)
|
|
S = "v";
|
|
S += llvm::to_string(Offset.getQuantity());
|
|
return S;
|
|
}
|
|
|
|
void visitARCStrong(QualType FT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset) {
|
|
appendStr("_s");
|
|
if (FT->isBlockPointerType())
|
|
appendStr("b");
|
|
CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
|
|
appendStr(getVolatileOffsetStr(FT.isVolatileQualified(), FieldOffset));
|
|
}
|
|
|
|
void visitARCWeak(QualType FT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset) {
|
|
appendStr("_w");
|
|
CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
|
|
appendStr(getVolatileOffsetStr(FT.isVolatileQualified(), FieldOffset));
|
|
}
|
|
|
|
void visitStruct(QualType QT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset) {
|
|
CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
|
|
appendStr("_S");
|
|
asDerived().visitStructFields(QT, FieldOffset);
|
|
}
|
|
|
|
template <class FieldKind>
|
|
void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
|
|
const FieldDecl *FD, CharUnits CurStructOffset) {
|
|
// String for non-volatile trivial fields is emitted when
|
|
// flushTrivialFields is called.
|
|
if (!FK)
|
|
return asDerived().visitTrivial(QualType(AT, 0), FD, CurStructOffset);
|
|
|
|
asDerived().flushTrivialFields();
|
|
CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
|
|
ASTContext &Ctx = asDerived().getContext();
|
|
const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
|
|
unsigned NumElts = Ctx.getConstantArrayElementCount(CAT);
|
|
QualType EltTy = Ctx.getBaseElementType(CAT);
|
|
CharUnits EltSize = Ctx.getTypeSizeInChars(EltTy);
|
|
appendStr("_AB" + llvm::to_string(FieldOffset.getQuantity()) + "s" +
|
|
llvm::to_string(EltSize.getQuantity()) + "n" +
|
|
llvm::to_string(NumElts));
|
|
EltTy = IsVolatile ? EltTy.withVolatile() : EltTy;
|
|
asDerived().visitWithKind(FK, EltTy, nullptr, FieldOffset);
|
|
appendStr("_AE");
|
|
}
|
|
|
|
void appendStr(StringRef Str) { Name += Str; }
|
|
|
|
std::string getName(QualType QT, bool IsVolatile) {
|
|
QT = IsVolatile ? QT.withVolatile() : QT;
|
|
asDerived().visitStructFields(QT, CharUnits::Zero());
|
|
return Name;
|
|
}
|
|
|
|
Derived &asDerived() { return static_cast<Derived &>(*this); }
|
|
|
|
std::string Name;
|
|
};
|
|
|
|
template <class Derived>
|
|
struct GenUnaryFuncName : StructVisitor<Derived>, GenFuncNameBase<Derived> {
|
|
GenUnaryFuncName(StringRef Prefix, CharUnits DstAlignment, ASTContext &Ctx)
|
|
: StructVisitor<Derived>(Ctx) {
|
|
this->appendStr(Prefix);
|
|
this->appendStr(llvm::to_string(DstAlignment.getQuantity()));
|
|
}
|
|
};
|
|
|
|
// Helper function to create a null constant.
|
|
static llvm::Constant *getNullForVariable(Address Addr) {
|
|
llvm::Type *Ty = Addr.getElementType();
|
|
return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(Ty));
|
|
}
|
|
|
|
template <bool IsMove>
|
|
struct GenBinaryFuncName : CopyStructVisitor<GenBinaryFuncName<IsMove>, IsMove>,
|
|
GenFuncNameBase<GenBinaryFuncName<IsMove>> {
|
|
|
|
GenBinaryFuncName(StringRef Prefix, CharUnits DstAlignment,
|
|
CharUnits SrcAlignment, ASTContext &Ctx)
|
|
: CopyStructVisitor<GenBinaryFuncName<IsMove>, IsMove>(Ctx) {
|
|
this->appendStr(Prefix);
|
|
this->appendStr(llvm::to_string(DstAlignment.getQuantity()));
|
|
this->appendStr("_" + llvm::to_string(SrcAlignment.getQuantity()));
|
|
}
|
|
|
|
void flushTrivialFields() {
|
|
if (this->Start == this->End)
|
|
return;
|
|
|
|
this->appendStr("_t" + llvm::to_string(this->Start.getQuantity()) + "w" +
|
|
llvm::to_string((this->End - this->Start).getQuantity()));
|
|
|
|
this->Start = this->End = CharUnits::Zero();
|
|
}
|
|
|
|
void visitVolatileTrivial(QualType FT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset) {
|
|
// Zero-length bit-fields don't need to be copied/assigned.
|
|
if (FD && FD->isZeroLengthBitField(this->Ctx))
|
|
return;
|
|
|
|
// Because volatile fields can be bit-fields and are individually copied,
|
|
// their offset and width are in bits.
|
|
uint64_t OffsetInBits =
|
|
this->Ctx.toBits(CurStructOffset) + this->getFieldOffsetInBits(FD);
|
|
this->appendStr("_tv" + llvm::to_string(OffsetInBits) + "w" +
|
|
llvm::to_string(getFieldSize(FD, FT, this->Ctx)));
|
|
}
|
|
};
|
|
|
|
struct GenDefaultInitializeFuncName
|
|
: GenUnaryFuncName<GenDefaultInitializeFuncName>,
|
|
DefaultInitializedTypeVisitor<GenDefaultInitializeFuncName> {
|
|
using Super = DefaultInitializedTypeVisitor<GenDefaultInitializeFuncName>;
|
|
GenDefaultInitializeFuncName(CharUnits DstAlignment, ASTContext &Ctx)
|
|
: GenUnaryFuncName<GenDefaultInitializeFuncName>("__default_constructor_",
|
|
DstAlignment, Ctx) {}
|
|
void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
|
|
const FieldDecl *FD, CharUnits CurStructOffset) {
|
|
if (const auto *AT = getContext().getAsArrayType(FT)) {
|
|
visitArray(PDIK, AT, FT.isVolatileQualified(), FD, CurStructOffset);
|
|
return;
|
|
}
|
|
|
|
Super::visitWithKind(PDIK, FT, FD, CurStructOffset);
|
|
}
|
|
};
|
|
|
|
struct GenDestructorFuncName : GenUnaryFuncName<GenDestructorFuncName>,
|
|
DestructedTypeVisitor<GenDestructorFuncName> {
|
|
using Super = DestructedTypeVisitor<GenDestructorFuncName>;
|
|
GenDestructorFuncName(const char *Prefix, CharUnits DstAlignment,
|
|
ASTContext &Ctx)
|
|
: GenUnaryFuncName<GenDestructorFuncName>(Prefix, DstAlignment, Ctx) {}
|
|
void visitWithKind(QualType::DestructionKind DK, QualType FT,
|
|
const FieldDecl *FD, CharUnits CurStructOffset) {
|
|
if (const auto *AT = getContext().getAsArrayType(FT)) {
|
|
visitArray(DK, AT, FT.isVolatileQualified(), FD, CurStructOffset);
|
|
return;
|
|
}
|
|
|
|
Super::visitWithKind(DK, FT, FD, CurStructOffset);
|
|
}
|
|
};
|
|
|
|
// Helper function that creates CGFunctionInfo for an N-ary special function.
|
|
template <size_t N>
|
|
static const CGFunctionInfo &getFunctionInfo(CodeGenModule &CGM,
|
|
FunctionArgList &Args) {
|
|
ASTContext &Ctx = CGM.getContext();
|
|
llvm::SmallVector<ImplicitParamDecl *, N> Params;
|
|
QualType ParamTy = Ctx.getPointerType(Ctx.VoidPtrTy);
|
|
|
|
for (unsigned I = 0; I < N; ++I)
|
|
Params.push_back(ImplicitParamDecl::Create(
|
|
Ctx, nullptr, SourceLocation(), &Ctx.Idents.get(ValNameStr[I]), ParamTy,
|
|
ImplicitParamDecl::Other));
|
|
|
|
for (auto &P : Params)
|
|
Args.push_back(P);
|
|
|
|
return CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args);
|
|
}
|
|
|
|
template <size_t N, size_t... Ints>
|
|
static std::array<Address, N> getParamAddrs(std::index_sequence<Ints...> IntSeq,
|
|
std::array<CharUnits, N> Alignments,
|
|
FunctionArgList Args,
|
|
CodeGenFunction *CGF) {
|
|
return std::array<Address, N>{{
|
|
Address(CGF->Builder.CreateLoad(CGF->GetAddrOfLocalVar(Args[Ints])),
|
|
Alignments[Ints])...}};
|
|
}
|
|
|
|
// Template classes that are used as bases for classes that emit special
|
|
// functions.
|
|
template <class Derived> struct GenFuncBase {
|
|
template <size_t N>
|
|
void visitStruct(QualType FT, const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, N> Addrs) {
|
|
this->asDerived().callSpecialFunction(
|
|
FT, CurStructOffset + asDerived().getFieldOffset(FD), Addrs);
|
|
}
|
|
|
|
template <class FieldKind, size_t N>
|
|
void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
|
|
const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, N> Addrs) {
|
|
// Non-volatile trivial fields are copied when flushTrivialFields is called.
|
|
if (!FK)
|
|
return asDerived().visitTrivial(QualType(AT, 0), FD, CurStructOffset,
|
|
Addrs);
|
|
|
|
asDerived().flushTrivialFields(Addrs);
|
|
CodeGenFunction &CGF = *this->CGF;
|
|
ASTContext &Ctx = CGF.getContext();
|
|
|
|
// Compute the end address.
|
|
QualType BaseEltQT;
|
|
std::array<Address, N> StartAddrs = Addrs;
|
|
for (unsigned I = 0; I < N; ++I)
|
|
StartAddrs[I] = getAddrWithOffset(Addrs[I], CurStructOffset, FD);
|
|
Address DstAddr = StartAddrs[DstIdx];
|
|
llvm::Value *NumElts = CGF.emitArrayLength(AT, BaseEltQT, DstAddr);
|
|
unsigned BaseEltSize = Ctx.getTypeSizeInChars(BaseEltQT).getQuantity();
|
|
llvm::Value *BaseEltSizeVal =
|
|
llvm::ConstantInt::get(NumElts->getType(), BaseEltSize);
|
|
llvm::Value *SizeInBytes =
|
|
CGF.Builder.CreateNUWMul(BaseEltSizeVal, NumElts);
|
|
Address BC = CGF.Builder.CreateBitCast(DstAddr, CGF.CGM.Int8PtrTy);
|
|
llvm::Value *DstArrayEnd =
|
|
CGF.Builder.CreateInBoundsGEP(BC.getPointer(), SizeInBytes);
|
|
DstArrayEnd = CGF.Builder.CreateBitCast(DstArrayEnd, CGF.CGM.Int8PtrPtrTy,
|
|
"dstarray.end");
|
|
llvm::BasicBlock *PreheaderBB = CGF.Builder.GetInsertBlock();
|
|
|
|
// Create the header block and insert the phi instructions.
|
|
llvm::BasicBlock *HeaderBB = CGF.createBasicBlock("loop.header");
|
|
CGF.EmitBlock(HeaderBB);
|
|
llvm::PHINode *PHIs[N];
|
|
|
|
for (unsigned I = 0; I < N; ++I) {
|
|
PHIs[I] = CGF.Builder.CreatePHI(CGF.CGM.Int8PtrPtrTy, 2, "addr.cur");
|
|
PHIs[I]->addIncoming(StartAddrs[I].getPointer(), PreheaderBB);
|
|
}
|
|
|
|
// Create the exit and loop body blocks.
|
|
llvm::BasicBlock *ExitBB = CGF.createBasicBlock("loop.exit");
|
|
llvm::BasicBlock *LoopBB = CGF.createBasicBlock("loop.body");
|
|
|
|
// Emit the comparison and conditional branch instruction that jumps to
|
|
// either the exit or the loop body.
|
|
llvm::Value *Done =
|
|
CGF.Builder.CreateICmpEQ(PHIs[DstIdx], DstArrayEnd, "done");
|
|
CGF.Builder.CreateCondBr(Done, ExitBB, LoopBB);
|
|
|
|
// Visit the element of the array in the loop body.
|
|
CGF.EmitBlock(LoopBB);
|
|
QualType EltQT = AT->getElementType();
|
|
CharUnits EltSize = Ctx.getTypeSizeInChars(EltQT);
|
|
std::array<Address, N> NewAddrs = Addrs;
|
|
|
|
for (unsigned I = 0; I < N; ++I)
|
|
NewAddrs[I] = Address(
|
|
PHIs[I], StartAddrs[I].getAlignment().alignmentAtOffset(EltSize));
|
|
|
|
EltQT = IsVolatile ? EltQT.withVolatile() : EltQT;
|
|
this->asDerived().visitWithKind(FK, EltQT, nullptr, CharUnits::Zero(),
|
|
NewAddrs);
|
|
|
|
LoopBB = CGF.Builder.GetInsertBlock();
|
|
|
|
for (unsigned I = 0; I < N; ++I) {
|
|
// Instrs to update the destination and source addresses.
|
|
// Update phi instructions.
|
|
NewAddrs[I] = getAddrWithOffset(NewAddrs[I], EltSize);
|
|
PHIs[I]->addIncoming(NewAddrs[I].getPointer(), LoopBB);
|
|
}
|
|
|
|
// Insert an unconditional branch to the header block.
|
|
CGF.Builder.CreateBr(HeaderBB);
|
|
CGF.EmitBlock(ExitBB);
|
|
}
|
|
|
|
/// Return an address with the specified offset from the passed address.
|
|
Address getAddrWithOffset(Address Addr, CharUnits Offset) {
|
|
assert(Addr.isValid() && "invalid address");
|
|
if (Offset.getQuantity() == 0)
|
|
return Addr;
|
|
Addr = CGF->Builder.CreateBitCast(Addr, CGF->CGM.Int8PtrTy);
|
|
Addr = CGF->Builder.CreateConstInBoundsGEP(Addr, Offset.getQuantity());
|
|
return CGF->Builder.CreateBitCast(Addr, CGF->CGM.Int8PtrPtrTy);
|
|
}
|
|
|
|
Address getAddrWithOffset(Address Addr, CharUnits StructFieldOffset,
|
|
const FieldDecl *FD) {
|
|
return getAddrWithOffset(Addr, StructFieldOffset +
|
|
asDerived().getFieldOffset(FD));
|
|
}
|
|
|
|
template <size_t N>
|
|
llvm::Function *getFunction(StringRef FuncName, QualType QT,
|
|
std::array<CharUnits, N> Alignments,
|
|
CodeGenModule &CGM) {
|
|
// If the special function already exists in the module, return it.
|
|
if (llvm::Function *F = CGM.getModule().getFunction(FuncName)) {
|
|
bool WrongType = false;
|
|
if (!F->getReturnType()->isVoidTy())
|
|
WrongType = true;
|
|
else {
|
|
for (const llvm::Argument &Arg : F->args())
|
|
if (Arg.getType() != CGM.Int8PtrPtrTy)
|
|
WrongType = true;
|
|
}
|
|
|
|
if (WrongType) {
|
|
std::string FuncName = std::string(F->getName());
|
|
SourceLocation Loc = QT->castAs<RecordType>()->getDecl()->getLocation();
|
|
CGM.Error(Loc, "special function " + FuncName +
|
|
" for non-trivial C struct has incorrect type");
|
|
return nullptr;
|
|
}
|
|
return F;
|
|
}
|
|
|
|
ASTContext &Ctx = CGM.getContext();
|
|
FunctionArgList Args;
|
|
const CGFunctionInfo &FI = getFunctionInfo<N>(CGM, Args);
|
|
llvm::FunctionType *FuncTy = CGM.getTypes().GetFunctionType(FI);
|
|
llvm::Function *F =
|
|
llvm::Function::Create(FuncTy, llvm::GlobalValue::LinkOnceODRLinkage,
|
|
FuncName, &CGM.getModule());
|
|
F->setVisibility(llvm::GlobalValue::HiddenVisibility);
|
|
CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, F);
|
|
CGM.SetLLVMFunctionAttributesForDefinition(nullptr, F);
|
|
IdentifierInfo *II = &Ctx.Idents.get(FuncName);
|
|
FunctionDecl *FD = FunctionDecl::Create(
|
|
Ctx, Ctx.getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
|
|
II, Ctx.getFunctionType(Ctx.VoidTy, llvm::None, {}), nullptr,
|
|
SC_PrivateExtern, false, false);
|
|
CodeGenFunction NewCGF(CGM);
|
|
setCGF(&NewCGF);
|
|
CGF->StartFunction(FD, Ctx.VoidTy, F, FI, Args);
|
|
std::array<Address, N> Addrs =
|
|
getParamAddrs<N>(std::make_index_sequence<N>{}, Alignments, Args, CGF);
|
|
asDerived().visitStructFields(QT, CharUnits::Zero(), Addrs);
|
|
CGF->FinishFunction();
|
|
return F;
|
|
}
|
|
|
|
template <size_t N>
|
|
void callFunc(StringRef FuncName, QualType QT, std::array<Address, N> Addrs,
|
|
CodeGenFunction &CallerCGF) {
|
|
std::array<CharUnits, N> Alignments;
|
|
llvm::Value *Ptrs[N];
|
|
|
|
for (unsigned I = 0; I < N; ++I) {
|
|
Alignments[I] = Addrs[I].getAlignment();
|
|
Ptrs[I] =
|
|
CallerCGF.Builder.CreateBitCast(Addrs[I], CallerCGF.CGM.Int8PtrPtrTy)
|
|
.getPointer();
|
|
}
|
|
|
|
if (llvm::Function *F =
|
|
getFunction(FuncName, QT, Alignments, CallerCGF.CGM))
|
|
CallerCGF.EmitNounwindRuntimeCall(F, Ptrs);
|
|
}
|
|
|
|
Derived &asDerived() { return static_cast<Derived &>(*this); }
|
|
|
|
void setCGF(CodeGenFunction *F) { CGF = F; }
|
|
|
|
CodeGenFunction *CGF = nullptr;
|
|
};
|
|
|
|
template <class Derived, bool IsMove>
|
|
struct GenBinaryFunc : CopyStructVisitor<Derived, IsMove>,
|
|
GenFuncBase<Derived> {
|
|
GenBinaryFunc(ASTContext &Ctx) : CopyStructVisitor<Derived, IsMove>(Ctx) {}
|
|
|
|
void flushTrivialFields(std::array<Address, 2> Addrs) {
|
|
CharUnits Size = this->End - this->Start;
|
|
|
|
if (Size.getQuantity() == 0)
|
|
return;
|
|
|
|
Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], this->Start);
|
|
Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], this->Start);
|
|
|
|
// Emit memcpy.
|
|
if (Size.getQuantity() >= 16 || !llvm::isPowerOf2_32(Size.getQuantity())) {
|
|
llvm::Value *SizeVal =
|
|
llvm::ConstantInt::get(this->CGF->SizeTy, Size.getQuantity());
|
|
DstAddr =
|
|
this->CGF->Builder.CreateElementBitCast(DstAddr, this->CGF->Int8Ty);
|
|
SrcAddr =
|
|
this->CGF->Builder.CreateElementBitCast(SrcAddr, this->CGF->Int8Ty);
|
|
this->CGF->Builder.CreateMemCpy(DstAddr, SrcAddr, SizeVal, false);
|
|
} else {
|
|
llvm::Type *Ty = llvm::Type::getIntNTy(
|
|
this->CGF->getLLVMContext(),
|
|
Size.getQuantity() * this->CGF->getContext().getCharWidth());
|
|
DstAddr = this->CGF->Builder.CreateElementBitCast(DstAddr, Ty);
|
|
SrcAddr = this->CGF->Builder.CreateElementBitCast(SrcAddr, Ty);
|
|
llvm::Value *SrcVal = this->CGF->Builder.CreateLoad(SrcAddr, false);
|
|
this->CGF->Builder.CreateStore(SrcVal, DstAddr, false);
|
|
}
|
|
|
|
this->Start = this->End = CharUnits::Zero();
|
|
}
|
|
|
|
template <class... Ts>
|
|
void visitVolatileTrivial(QualType FT, const FieldDecl *FD, CharUnits Offset,
|
|
std::array<Address, 2> Addrs) {
|
|
LValue DstLV, SrcLV;
|
|
if (FD) {
|
|
// No need to copy zero-length bit-fields.
|
|
if (FD->isZeroLengthBitField(this->CGF->getContext()))
|
|
return;
|
|
|
|
QualType RT = QualType(FD->getParent()->getTypeForDecl(), 0);
|
|
llvm::PointerType *PtrTy = this->CGF->ConvertType(RT)->getPointerTo();
|
|
Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], Offset);
|
|
LValue DstBase = this->CGF->MakeAddrLValue(
|
|
this->CGF->Builder.CreateBitCast(DstAddr, PtrTy), FT);
|
|
DstLV = this->CGF->EmitLValueForField(DstBase, FD);
|
|
Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], Offset);
|
|
LValue SrcBase = this->CGF->MakeAddrLValue(
|
|
this->CGF->Builder.CreateBitCast(SrcAddr, PtrTy), FT);
|
|
SrcLV = this->CGF->EmitLValueForField(SrcBase, FD);
|
|
} else {
|
|
llvm::PointerType *Ty = this->CGF->ConvertType(FT)->getPointerTo();
|
|
Address DstAddr = this->CGF->Builder.CreateBitCast(Addrs[DstIdx], Ty);
|
|
Address SrcAddr = this->CGF->Builder.CreateBitCast(Addrs[SrcIdx], Ty);
|
|
DstLV = this->CGF->MakeAddrLValue(DstAddr, FT);
|
|
SrcLV = this->CGF->MakeAddrLValue(SrcAddr, FT);
|
|
}
|
|
RValue SrcVal = this->CGF->EmitLoadOfLValue(SrcLV, SourceLocation());
|
|
this->CGF->EmitStoreThroughLValue(SrcVal, DstLV);
|
|
}
|
|
};
|
|
|
|
// These classes that emit the special functions for a non-trivial struct.
|
|
struct GenDestructor : StructVisitor<GenDestructor>,
|
|
GenFuncBase<GenDestructor>,
|
|
DestructedTypeVisitor<GenDestructor> {
|
|
using Super = DestructedTypeVisitor<GenDestructor>;
|
|
GenDestructor(ASTContext &Ctx) : StructVisitor<GenDestructor>(Ctx) {}
|
|
|
|
void visitWithKind(QualType::DestructionKind DK, QualType FT,
|
|
const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, 1> Addrs) {
|
|
if (const auto *AT = getContext().getAsArrayType(FT)) {
|
|
visitArray(DK, AT, FT.isVolatileQualified(), FD, CurStructOffset, Addrs);
|
|
return;
|
|
}
|
|
|
|
Super::visitWithKind(DK, FT, FD, CurStructOffset, Addrs);
|
|
}
|
|
|
|
void visitARCStrong(QualType QT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
|
|
CGF->destroyARCStrongImprecise(
|
|
*CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
|
|
}
|
|
|
|
void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, 1> Addrs) {
|
|
CGF->destroyARCWeak(
|
|
*CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
|
|
}
|
|
|
|
void callSpecialFunction(QualType FT, CharUnits Offset,
|
|
std::array<Address, 1> Addrs) {
|
|
CGF->callCStructDestructor(
|
|
CGF->MakeAddrLValue(getAddrWithOffset(Addrs[DstIdx], Offset), FT));
|
|
}
|
|
};
|
|
|
|
struct GenDefaultInitialize
|
|
: StructVisitor<GenDefaultInitialize>,
|
|
GenFuncBase<GenDefaultInitialize>,
|
|
DefaultInitializedTypeVisitor<GenDefaultInitialize> {
|
|
using Super = DefaultInitializedTypeVisitor<GenDefaultInitialize>;
|
|
typedef GenFuncBase<GenDefaultInitialize> GenFuncBaseTy;
|
|
|
|
GenDefaultInitialize(ASTContext &Ctx)
|
|
: StructVisitor<GenDefaultInitialize>(Ctx) {}
|
|
|
|
void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
|
|
const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, 1> Addrs) {
|
|
if (const auto *AT = getContext().getAsArrayType(FT)) {
|
|
visitArray(PDIK, AT, FT.isVolatileQualified(), FD, CurStructOffset,
|
|
Addrs);
|
|
return;
|
|
}
|
|
|
|
Super::visitWithKind(PDIK, FT, FD, CurStructOffset, Addrs);
|
|
}
|
|
|
|
void visitARCStrong(QualType QT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
|
|
CGF->EmitNullInitialization(
|
|
getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
|
|
}
|
|
|
|
void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, 1> Addrs) {
|
|
CGF->EmitNullInitialization(
|
|
getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
|
|
}
|
|
|
|
template <class FieldKind, size_t... Is>
|
|
void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
|
|
const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, 1> Addrs) {
|
|
if (!FK)
|
|
return visitTrivial(QualType(AT, 0), FD, CurStructOffset, Addrs);
|
|
|
|
ASTContext &Ctx = getContext();
|
|
CharUnits Size = Ctx.getTypeSizeInChars(QualType(AT, 0));
|
|
QualType EltTy = Ctx.getBaseElementType(QualType(AT, 0));
|
|
|
|
if (Size < CharUnits::fromQuantity(16) || EltTy->getAs<RecordType>()) {
|
|
GenFuncBaseTy::visitArray(FK, AT, IsVolatile, FD, CurStructOffset, Addrs);
|
|
return;
|
|
}
|
|
|
|
llvm::Constant *SizeVal = CGF->Builder.getInt64(Size.getQuantity());
|
|
Address DstAddr = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
|
|
Address Loc = CGF->Builder.CreateElementBitCast(DstAddr, CGF->Int8Ty);
|
|
CGF->Builder.CreateMemSet(Loc, CGF->Builder.getInt8(0), SizeVal,
|
|
IsVolatile);
|
|
}
|
|
|
|
void callSpecialFunction(QualType FT, CharUnits Offset,
|
|
std::array<Address, 1> Addrs) {
|
|
CGF->callCStructDefaultConstructor(
|
|
CGF->MakeAddrLValue(getAddrWithOffset(Addrs[DstIdx], Offset), FT));
|
|
}
|
|
};
|
|
|
|
struct GenCopyConstructor : GenBinaryFunc<GenCopyConstructor, false> {
|
|
GenCopyConstructor(ASTContext &Ctx)
|
|
: GenBinaryFunc<GenCopyConstructor, false>(Ctx) {}
|
|
|
|
void visitARCStrong(QualType QT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
|
|
llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
|
|
Addrs[SrcIdx], QT.isVolatileQualified(), QT, SourceLocation());
|
|
llvm::Value *Val = CGF->EmitARCRetain(QT, SrcVal);
|
|
CGF->EmitStoreOfScalar(Val, CGF->MakeAddrLValue(Addrs[DstIdx], QT), true);
|
|
}
|
|
|
|
void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
|
|
CGF->EmitARCCopyWeak(Addrs[DstIdx], Addrs[SrcIdx]);
|
|
}
|
|
|
|
void callSpecialFunction(QualType FT, CharUnits Offset,
|
|
std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
|
|
CGF->callCStructCopyConstructor(CGF->MakeAddrLValue(Addrs[DstIdx], FT),
|
|
CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
|
|
}
|
|
};
|
|
|
|
struct GenMoveConstructor : GenBinaryFunc<GenMoveConstructor, true> {
|
|
GenMoveConstructor(ASTContext &Ctx)
|
|
: GenBinaryFunc<GenMoveConstructor, true>(Ctx) {}
|
|
|
|
void visitARCStrong(QualType QT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
|
|
LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
|
|
llvm::Value *SrcVal =
|
|
CGF->EmitLoadOfLValue(SrcLV, SourceLocation()).getScalarVal();
|
|
CGF->EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress(*CGF)), SrcLV);
|
|
CGF->EmitStoreOfScalar(SrcVal, CGF->MakeAddrLValue(Addrs[DstIdx], QT),
|
|
/* isInitialization */ true);
|
|
}
|
|
|
|
void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
|
|
CGF->EmitARCMoveWeak(Addrs[DstIdx], Addrs[SrcIdx]);
|
|
}
|
|
|
|
void callSpecialFunction(QualType FT, CharUnits Offset,
|
|
std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
|
|
CGF->callCStructMoveConstructor(CGF->MakeAddrLValue(Addrs[DstIdx], FT),
|
|
CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
|
|
}
|
|
};
|
|
|
|
struct GenCopyAssignment : GenBinaryFunc<GenCopyAssignment, false> {
|
|
GenCopyAssignment(ASTContext &Ctx)
|
|
: GenBinaryFunc<GenCopyAssignment, false>(Ctx) {}
|
|
|
|
void visitARCStrong(QualType QT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
|
|
llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
|
|
Addrs[SrcIdx], QT.isVolatileQualified(), QT, SourceLocation());
|
|
CGF->EmitARCStoreStrong(CGF->MakeAddrLValue(Addrs[DstIdx], QT), SrcVal,
|
|
false);
|
|
}
|
|
|
|
void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
|
|
CGF->emitARCCopyAssignWeak(QT, Addrs[DstIdx], Addrs[SrcIdx]);
|
|
}
|
|
|
|
void callSpecialFunction(QualType FT, CharUnits Offset,
|
|
std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
|
|
CGF->callCStructCopyAssignmentOperator(
|
|
CGF->MakeAddrLValue(Addrs[DstIdx], FT),
|
|
CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
|
|
}
|
|
};
|
|
|
|
struct GenMoveAssignment : GenBinaryFunc<GenMoveAssignment, true> {
|
|
GenMoveAssignment(ASTContext &Ctx)
|
|
: GenBinaryFunc<GenMoveAssignment, true>(Ctx) {}
|
|
|
|
void visitARCStrong(QualType QT, const FieldDecl *FD,
|
|
CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
|
|
LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
|
|
llvm::Value *SrcVal =
|
|
CGF->EmitLoadOfLValue(SrcLV, SourceLocation()).getScalarVal();
|
|
CGF->EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress(*CGF)), SrcLV);
|
|
LValue DstLV = CGF->MakeAddrLValue(Addrs[DstIdx], QT);
|
|
llvm::Value *DstVal =
|
|
CGF->EmitLoadOfLValue(DstLV, SourceLocation()).getScalarVal();
|
|
CGF->EmitStoreOfScalar(SrcVal, DstLV);
|
|
CGF->EmitARCRelease(DstVal, ARCImpreciseLifetime);
|
|
}
|
|
|
|
void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
|
|
std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
|
|
CGF->emitARCMoveAssignWeak(QT, Addrs[DstIdx], Addrs[SrcIdx]);
|
|
}
|
|
|
|
void callSpecialFunction(QualType FT, CharUnits Offset,
|
|
std::array<Address, 2> Addrs) {
|
|
Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
|
|
Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
|
|
CGF->callCStructMoveAssignmentOperator(
|
|
CGF->MakeAddrLValue(Addrs[DstIdx], FT),
|
|
CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
void CodeGenFunction::destroyNonTrivialCStruct(CodeGenFunction &CGF,
|
|
Address Addr, QualType Type) {
|
|
CGF.callCStructDestructor(CGF.MakeAddrLValue(Addr, Type));
|
|
}
|
|
|
|
// Default-initialize a variable that is a non-trivial struct or an array of
|
|
// such structure.
|
|
void CodeGenFunction::defaultInitNonTrivialCStructVar(LValue Dst) {
|
|
GenDefaultInitialize Gen(getContext());
|
|
Address DstPtr =
|
|
Builder.CreateBitCast(Dst.getAddress(*this), CGM.Int8PtrPtrTy);
|
|
Gen.setCGF(this);
|
|
QualType QT = Dst.getType();
|
|
QT = Dst.isVolatile() ? QT.withVolatile() : QT;
|
|
Gen.visit(QT, nullptr, CharUnits::Zero(), std::array<Address, 1>({{DstPtr}}));
|
|
}
|
|
|
|
template <class G, size_t N>
|
|
static void callSpecialFunction(G &&Gen, StringRef FuncName, QualType QT,
|
|
bool IsVolatile, CodeGenFunction &CGF,
|
|
std::array<Address, N> Addrs) {
|
|
auto SetArtificialLoc = ApplyDebugLocation::CreateArtificial(CGF);
|
|
for (unsigned I = 0; I < N; ++I)
|
|
Addrs[I] = CGF.Builder.CreateBitCast(Addrs[I], CGF.CGM.Int8PtrPtrTy);
|
|
QT = IsVolatile ? QT.withVolatile() : QT;
|
|
Gen.callFunc(FuncName, QT, Addrs, CGF);
|
|
}
|
|
|
|
template <class G, size_t N>
|
|
static llvm::Function *
|
|
getSpecialFunction(G &&Gen, StringRef FuncName, QualType QT, bool IsVolatile,
|
|
std::array<CharUnits, N> Alignments, CodeGenModule &CGM) {
|
|
QT = IsVolatile ? QT.withVolatile() : QT;
|
|
// The following call requires an array of addresses as arguments, but doesn't
|
|
// actually use them (it overwrites them with the addresses of the arguments
|
|
// of the created function).
|
|
return Gen.getFunction(FuncName, QT, Alignments, CGM);
|
|
}
|
|
|
|
// Functions to emit calls to the special functions of a non-trivial C struct.
|
|
void CodeGenFunction::callCStructDefaultConstructor(LValue Dst) {
|
|
bool IsVolatile = Dst.isVolatile();
|
|
Address DstPtr = Dst.getAddress(*this);
|
|
QualType QT = Dst.getType();
|
|
GenDefaultInitializeFuncName GenName(DstPtr.getAlignment(), getContext());
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
callSpecialFunction(GenDefaultInitialize(getContext()), FuncName, QT,
|
|
IsVolatile, *this, std::array<Address, 1>({{DstPtr}}));
|
|
}
|
|
|
|
std::string CodeGenFunction::getNonTrivialCopyConstructorStr(
|
|
QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx) {
|
|
GenBinaryFuncName<false> GenName("", Alignment, Alignment, Ctx);
|
|
return GenName.getName(QT, IsVolatile);
|
|
}
|
|
|
|
std::string CodeGenFunction::getNonTrivialDestructorStr(QualType QT,
|
|
CharUnits Alignment,
|
|
bool IsVolatile,
|
|
ASTContext &Ctx) {
|
|
GenDestructorFuncName GenName("", Alignment, Ctx);
|
|
return GenName.getName(QT, IsVolatile);
|
|
}
|
|
|
|
void CodeGenFunction::callCStructDestructor(LValue Dst) {
|
|
bool IsVolatile = Dst.isVolatile();
|
|
Address DstPtr = Dst.getAddress(*this);
|
|
QualType QT = Dst.getType();
|
|
GenDestructorFuncName GenName("__destructor_", DstPtr.getAlignment(),
|
|
getContext());
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
callSpecialFunction(GenDestructor(getContext()), FuncName, QT, IsVolatile,
|
|
*this, std::array<Address, 1>({{DstPtr}}));
|
|
}
|
|
|
|
void CodeGenFunction::callCStructCopyConstructor(LValue Dst, LValue Src) {
|
|
bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
|
|
Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
|
|
QualType QT = Dst.getType();
|
|
GenBinaryFuncName<false> GenName("__copy_constructor_", DstPtr.getAlignment(),
|
|
SrcPtr.getAlignment(), getContext());
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
callSpecialFunction(GenCopyConstructor(getContext()), FuncName, QT,
|
|
IsVolatile, *this,
|
|
std::array<Address, 2>({{DstPtr, SrcPtr}}));
|
|
}
|
|
|
|
void CodeGenFunction::callCStructCopyAssignmentOperator(LValue Dst, LValue Src
|
|
|
|
) {
|
|
bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
|
|
Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
|
|
QualType QT = Dst.getType();
|
|
GenBinaryFuncName<false> GenName("__copy_assignment_", DstPtr.getAlignment(),
|
|
SrcPtr.getAlignment(), getContext());
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
callSpecialFunction(GenCopyAssignment(getContext()), FuncName, QT, IsVolatile,
|
|
*this, std::array<Address, 2>({{DstPtr, SrcPtr}}));
|
|
}
|
|
|
|
void CodeGenFunction::callCStructMoveConstructor(LValue Dst, LValue Src) {
|
|
bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
|
|
Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
|
|
QualType QT = Dst.getType();
|
|
GenBinaryFuncName<true> GenName("__move_constructor_", DstPtr.getAlignment(),
|
|
SrcPtr.getAlignment(), getContext());
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
callSpecialFunction(GenMoveConstructor(getContext()), FuncName, QT,
|
|
IsVolatile, *this,
|
|
std::array<Address, 2>({{DstPtr, SrcPtr}}));
|
|
}
|
|
|
|
void CodeGenFunction::callCStructMoveAssignmentOperator(LValue Dst, LValue Src
|
|
|
|
) {
|
|
bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
|
|
Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
|
|
QualType QT = Dst.getType();
|
|
GenBinaryFuncName<true> GenName("__move_assignment_", DstPtr.getAlignment(),
|
|
SrcPtr.getAlignment(), getContext());
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
callSpecialFunction(GenMoveAssignment(getContext()), FuncName, QT, IsVolatile,
|
|
*this, std::array<Address, 2>({{DstPtr, SrcPtr}}));
|
|
}
|
|
|
|
llvm::Function *clang::CodeGen::getNonTrivialCStructDefaultConstructor(
|
|
CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
|
|
ASTContext &Ctx = CGM.getContext();
|
|
GenDefaultInitializeFuncName GenName(DstAlignment, Ctx);
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
return getSpecialFunction(GenDefaultInitialize(Ctx), FuncName, QT, IsVolatile,
|
|
std::array<CharUnits, 1>({{DstAlignment}}), CGM);
|
|
}
|
|
|
|
llvm::Function *clang::CodeGen::getNonTrivialCStructCopyConstructor(
|
|
CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
|
|
bool IsVolatile, QualType QT) {
|
|
ASTContext &Ctx = CGM.getContext();
|
|
GenBinaryFuncName<false> GenName("__copy_constructor_", DstAlignment,
|
|
SrcAlignment, Ctx);
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
return getSpecialFunction(
|
|
GenCopyConstructor(Ctx), FuncName, QT, IsVolatile,
|
|
std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
|
|
}
|
|
|
|
llvm::Function *clang::CodeGen::getNonTrivialCStructMoveConstructor(
|
|
CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
|
|
bool IsVolatile, QualType QT) {
|
|
ASTContext &Ctx = CGM.getContext();
|
|
GenBinaryFuncName<true> GenName("__move_constructor_", DstAlignment,
|
|
SrcAlignment, Ctx);
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
return getSpecialFunction(
|
|
GenMoveConstructor(Ctx), FuncName, QT, IsVolatile,
|
|
std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
|
|
}
|
|
|
|
llvm::Function *clang::CodeGen::getNonTrivialCStructCopyAssignmentOperator(
|
|
CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
|
|
bool IsVolatile, QualType QT) {
|
|
ASTContext &Ctx = CGM.getContext();
|
|
GenBinaryFuncName<false> GenName("__copy_assignment_", DstAlignment,
|
|
SrcAlignment, Ctx);
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
return getSpecialFunction(
|
|
GenCopyAssignment(Ctx), FuncName, QT, IsVolatile,
|
|
std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
|
|
}
|
|
|
|
llvm::Function *clang::CodeGen::getNonTrivialCStructMoveAssignmentOperator(
|
|
CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
|
|
bool IsVolatile, QualType QT) {
|
|
ASTContext &Ctx = CGM.getContext();
|
|
GenBinaryFuncName<true> GenName("__move_assignment_", DstAlignment,
|
|
SrcAlignment, Ctx);
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
return getSpecialFunction(
|
|
GenMoveAssignment(Ctx), FuncName, QT, IsVolatile,
|
|
std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
|
|
}
|
|
|
|
llvm::Function *clang::CodeGen::getNonTrivialCStructDestructor(
|
|
CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
|
|
ASTContext &Ctx = CGM.getContext();
|
|
GenDestructorFuncName GenName("__destructor_", DstAlignment, Ctx);
|
|
std::string FuncName = GenName.getName(QT, IsVolatile);
|
|
return getSpecialFunction(GenDestructor(Ctx), FuncName, QT, IsVolatile,
|
|
std::array<CharUnits, 1>({{DstAlignment}}), CGM);
|
|
}
|