1//===--- CGNonTrivialStruct.cpp - Emit Special Functions for C Structs ----===//
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// This file defines functions to generate various special functions for C
10// structs.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CGDebugInfo.h"
15#include "CodeGenFunction.h"
16#include "CodeGenModule.h"
17#include "clang/AST/NonTrivialTypeVisitor.h"
18#include "clang/CodeGen/CodeGenABITypes.h"
19#include "llvm/Support/ScopedPrinter.h"
20#include <array>
21
22using namespace clang;
23using namespace CodeGen;
24
25// Return the size of a field in number of bits.
26static uint64_t getFieldSize(const FieldDecl *FD, QualType FT,
27 ASTContext &Ctx) {
28 if (FD && FD->isBitField())
29 return FD->getBitWidthValue();
30 return Ctx.getTypeSize(T: FT);
31}
32
33namespace {
34enum { DstIdx = 0, SrcIdx = 1 };
35const char *ValNameStr[2] = {"dst", "src"};
36
37template <class Derived> struct StructVisitor {
38 StructVisitor(ASTContext &Ctx) : Ctx(Ctx) {}
39
40 template <class... Ts>
41 void visitStructFields(QualType QT, CharUnits CurStructOffset, Ts... Args) {
42 const auto *RD = QT->castAsRecordDecl();
43
44 // Iterate over the fields of the struct.
45 for (const FieldDecl *FD : RD->fields()) {
46 QualType FT = FD->getType();
47 FT = QT.isVolatileQualified() ? FT.withVolatile() : FT;
48 asDerived().visit(FT, FD, CurStructOffset, Args...);
49 }
50
51 asDerived().flushTrivialFields(Args...);
52 }
53
54 template <class... Ts> void visitTrivial(Ts... Args) {}
55
56 template <class... Ts> void visitCXXDestructor(Ts... Args) {
57 llvm_unreachable("field of a C++ struct type is not expected");
58 }
59
60 template <class... Ts> void flushTrivialFields(Ts... Args) {}
61
62 uint64_t getFieldOffsetInBits(const FieldDecl *FD) {
63 return FD ? Ctx.getASTRecordLayout(D: FD->getParent())
64 .getFieldOffset(FieldNo: FD->getFieldIndex())
65 : 0;
66 }
67
68 CharUnits getFieldOffset(const FieldDecl *FD) {
69 return Ctx.toCharUnitsFromBits(BitSize: getFieldOffsetInBits(FD));
70 }
71
72 Derived &asDerived() { return static_cast<Derived &>(*this); }
73
74 ASTContext &getContext() { return Ctx; }
75 ASTContext &Ctx;
76};
77
78template <class Derived, bool IsMove>
79struct CopyStructVisitor : StructVisitor<Derived>,
80 CopiedTypeVisitor<Derived, IsMove> {
81 using StructVisitor<Derived>::asDerived;
82 using Super = CopiedTypeVisitor<Derived, IsMove>;
83
84 CopyStructVisitor(ASTContext &Ctx) : StructVisitor<Derived>(Ctx) {}
85
86 template <class... Ts>
87 void preVisit(QualType::PrimitiveCopyKind PCK, QualType FT,
88 const FieldDecl *FD, CharUnits CurStructOffset, Ts &&... Args) {
89 if (PCK)
90 asDerived().flushTrivialFields(std::forward<Ts>(Args)...);
91 }
92
93 template <class... Ts>
94 void visitWithKind(QualType::PrimitiveCopyKind PCK, QualType FT,
95 const FieldDecl *FD, CharUnits CurStructOffset,
96 Ts &&... Args) {
97 if (const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
98 asDerived().visitArray(PCK, AT, FT.isVolatileQualified(), FD,
99 CurStructOffset, std::forward<Ts>(Args)...);
100 return;
101 }
102
103 Super::visitWithKind(PCK, FT, FD, CurStructOffset,
104 std::forward<Ts>(Args)...);
105 }
106
107 template <class... Ts>
108 void visitTrivial(QualType FT, const FieldDecl *FD, CharUnits CurStructOffset,
109 Ts... Args) {
110 assert(!FT.isVolatileQualified() && "volatile field not expected");
111 ASTContext &Ctx = asDerived().getContext();
112 uint64_t FieldSize = getFieldSize(FD, FT, Ctx);
113
114 // Ignore zero-sized fields.
115 if (FieldSize == 0)
116 return;
117
118 uint64_t FStartInBits = asDerived().getFieldOffsetInBits(FD);
119 uint64_t FEndInBits = FStartInBits + FieldSize;
120 uint64_t RoundedFEnd = llvm::alignTo(Value: FEndInBits, Align: Ctx.getCharWidth());
121
122 // Set Start if this is the first field of a sequence of trivial fields.
123 if (Start == End)
124 Start = CurStructOffset + Ctx.toCharUnitsFromBits(BitSize: FStartInBits);
125 End = CurStructOffset + Ctx.toCharUnitsFromBits(BitSize: RoundedFEnd);
126 }
127
128 CharUnits Start = CharUnits::Zero(), End = CharUnits::Zero();
129};
130
131// This function creates the mangled name of a special function of a non-trivial
132// C struct. Since there is no ODR in C, the function is mangled based on the
133// struct contents and not the name. The mangled name has the following
134// structure:
135//
136// <function-name> ::= <prefix> <alignment-info> "_" <struct-field-info>
137// <prefix> ::= "__destructor_" | "__default_constructor_" |
138// "__copy_constructor_" | "__move_constructor_" |
139// "__copy_assignment_" | "__move_assignment_"
140// <alignment-info> ::= <dst-alignment> ["_" <src-alignment>]
141// <struct-field-info> ::= <field-info>+
142// <field-info> ::= <struct-or-scalar-field-info> | <array-field-info>
143// <struct-or-scalar-field-info> ::= "_S" <struct-field-info> |
144// <strong-field-info> | <trivial-field-info>
145// <array-field-info> ::= "_AB" <array-offset> "s" <element-size> "n"
146// <num-elements> <innermost-element-info> "_AE"
147// <innermost-element-info> ::= <struct-or-scalar-field-info>
148// <strong-field-info> ::= "_s" ["b"] ["v"] <field-offset>
149// <trivial-field-info> ::= "_t" ["v"] <field-offset> "_" <field-size>
150
151template <class Derived> struct GenFuncNameBase {
152 std::string getVolatileOffsetStr(bool IsVolatile, CharUnits Offset) {
153 std::string S;
154 if (IsVolatile)
155 S = "v";
156 S += llvm::to_string(Value: Offset.getQuantity());
157 return S;
158 }
159
160 void visitARCStrong(QualType FT, const FieldDecl *FD,
161 CharUnits CurStructOffset) {
162 appendStr(Str: "_s");
163 if (FT->isBlockPointerType())
164 appendStr(Str: "b");
165 CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
166 appendStr(Str: getVolatileOffsetStr(IsVolatile: FT.isVolatileQualified(), Offset: FieldOffset));
167 }
168
169 void visitARCWeak(QualType FT, const FieldDecl *FD,
170 CharUnits CurStructOffset) {
171 appendStr(Str: "_w");
172 CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
173 appendStr(Str: getVolatileOffsetStr(IsVolatile: FT.isVolatileQualified(), Offset: FieldOffset));
174 }
175
176 void visitStruct(QualType QT, const FieldDecl *FD,
177 CharUnits CurStructOffset) {
178 CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
179 appendStr(Str: "_S");
180 asDerived().visitStructFields(QT, FieldOffset);
181 }
182
183 template <class FieldKind>
184 void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
185 const FieldDecl *FD, CharUnits CurStructOffset) {
186 // String for non-volatile trivial fields is emitted when
187 // flushTrivialFields is called.
188 if (!FK)
189 return asDerived().visitTrivial(QualType(AT, 0), FD, CurStructOffset);
190
191 asDerived().flushTrivialFields();
192 CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
193 ASTContext &Ctx = asDerived().getContext();
194 const ConstantArrayType *CAT = cast<ConstantArrayType>(Val: AT);
195 unsigned NumElts = Ctx.getConstantArrayElementCount(CA: CAT);
196 QualType EltTy = Ctx.getBaseElementType(VAT: CAT);
197 CharUnits EltSize = Ctx.getTypeSizeInChars(T: EltTy);
198 appendStr(Str: "_AB" + llvm::to_string(Value: FieldOffset.getQuantity()) + "s" +
199 llvm::to_string(Value: EltSize.getQuantity()) + "n" +
200 llvm::to_string(Value: NumElts));
201 EltTy = IsVolatile ? EltTy.withVolatile() : EltTy;
202 asDerived().visitWithKind(FK, EltTy, nullptr, FieldOffset);
203 appendStr(Str: "_AE");
204 }
205
206 void appendStr(StringRef Str) { Name += Str; }
207
208 std::string getName(QualType QT, bool IsVolatile) {
209 QT = IsVolatile ? QT.withVolatile() : QT;
210 asDerived().visitStructFields(QT, CharUnits::Zero());
211 return Name;
212 }
213
214 Derived &asDerived() { return static_cast<Derived &>(*this); }
215
216 std::string Name;
217};
218
219template <class Derived>
220struct GenUnaryFuncName : StructVisitor<Derived>, GenFuncNameBase<Derived> {
221 GenUnaryFuncName(StringRef Prefix, CharUnits DstAlignment, ASTContext &Ctx)
222 : StructVisitor<Derived>(Ctx) {
223 this->appendStr(Prefix);
224 this->appendStr(llvm::to_string(Value: DstAlignment.getQuantity()));
225 }
226};
227
228// Helper function to create a null constant.
229static llvm::Constant *getNullForVariable(Address Addr) {
230 llvm::Type *Ty = Addr.getElementType();
231 return llvm::ConstantPointerNull::get(T: cast<llvm::PointerType>(Val: Ty));
232}
233
234template <bool IsMove>
235struct GenBinaryFuncName : CopyStructVisitor<GenBinaryFuncName<IsMove>, IsMove>,
236 GenFuncNameBase<GenBinaryFuncName<IsMove>> {
237
238 GenBinaryFuncName(StringRef Prefix, CharUnits DstAlignment,
239 CharUnits SrcAlignment, ASTContext &Ctx)
240 : CopyStructVisitor<GenBinaryFuncName<IsMove>, IsMove>(Ctx) {
241 this->appendStr(Prefix);
242 this->appendStr(llvm::to_string(Value: DstAlignment.getQuantity()));
243 this->appendStr("_" + llvm::to_string(Value: SrcAlignment.getQuantity()));
244 }
245
246 void flushTrivialFields() {
247 if (this->Start == this->End)
248 return;
249
250 this->appendStr("_t" + llvm::to_string(this->Start.getQuantity()) + "w" +
251 llvm::to_string((this->End - this->Start).getQuantity()));
252
253 this->Start = this->End = CharUnits::Zero();
254 }
255
256 void visitVolatileTrivial(QualType FT, const FieldDecl *FD,
257 CharUnits CurStructOffset) {
258 // Zero-length bit-fields don't need to be copied/assigned.
259 if (FD && FD->isZeroLengthBitField())
260 return;
261
262 // Because volatile fields can be bit-fields and are individually copied,
263 // their offset and width are in bits.
264 uint64_t OffsetInBits =
265 this->Ctx.toBits(CurStructOffset) + this->getFieldOffsetInBits(FD);
266 this->appendStr("_tv" + llvm::to_string(Value: OffsetInBits) + "w" +
267 llvm::to_string(getFieldSize(FD, FT, this->Ctx)));
268 }
269
270 void visitPtrAuth(QualType FT, const FieldDecl *FD,
271 CharUnits CurStructOffset) {
272 this->appendStr("_pa");
273 PointerAuthQualifier PtrAuth = FT.getPointerAuth().withoutKeyNone();
274 this->appendStr(llvm::to_string(Value: PtrAuth.getKey()) + "_");
275 this->appendStr(llvm::to_string(Value: PtrAuth.getExtraDiscriminator()) + "_");
276 if (PtrAuth.authenticatesNullValues())
277 this->appendStr("anv_");
278 CharUnits FieldOffset = CurStructOffset + this->getFieldOffset(FD);
279 this->appendStr(llvm::to_string(Value: FieldOffset.getQuantity()));
280 }
281};
282
283struct GenDefaultInitializeFuncName
284 : GenUnaryFuncName<GenDefaultInitializeFuncName>,
285 DefaultInitializedTypeVisitor<GenDefaultInitializeFuncName> {
286 using Super = DefaultInitializedTypeVisitor<GenDefaultInitializeFuncName>;
287 GenDefaultInitializeFuncName(CharUnits DstAlignment, ASTContext &Ctx)
288 : GenUnaryFuncName<GenDefaultInitializeFuncName>("__default_constructor_",
289 DstAlignment, Ctx) {}
290 void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
291 const FieldDecl *FD, CharUnits CurStructOffset) {
292 if (const auto *AT = getContext().getAsArrayType(T: FT)) {
293 visitArray(FK: PDIK, AT, IsVolatile: FT.isVolatileQualified(), FD, CurStructOffset);
294 return;
295 }
296
297 Super::visitWithKind(PDIK, FT, Args&: FD, Args&: CurStructOffset);
298 }
299};
300
301struct GenDestructorFuncName : GenUnaryFuncName<GenDestructorFuncName>,
302 DestructedTypeVisitor<GenDestructorFuncName> {
303 using Super = DestructedTypeVisitor<GenDestructorFuncName>;
304 GenDestructorFuncName(const char *Prefix, CharUnits DstAlignment,
305 ASTContext &Ctx)
306 : GenUnaryFuncName<GenDestructorFuncName>(Prefix, DstAlignment, Ctx) {}
307 void visitWithKind(QualType::DestructionKind DK, QualType FT,
308 const FieldDecl *FD, CharUnits CurStructOffset) {
309 if (const auto *AT = getContext().getAsArrayType(T: FT)) {
310 visitArray(FK: DK, AT, IsVolatile: FT.isVolatileQualified(), FD, CurStructOffset);
311 return;
312 }
313
314 Super::visitWithKind(DK, FT, Args&: FD, Args&: CurStructOffset);
315 }
316};
317
318// Helper function that creates CGFunctionInfo for an N-ary special function.
319template <size_t N>
320static const CGFunctionInfo &getFunctionInfo(CodeGenModule &CGM,
321 FunctionArgList &Args) {
322 ASTContext &Ctx = CGM.getContext();
323 llvm::SmallVector<ImplicitParamDecl *, N> Params;
324 QualType ParamTy = Ctx.getPointerType(T: Ctx.VoidPtrTy);
325
326 for (unsigned I = 0; I < N; ++I)
327 Params.push_back(ImplicitParamDecl::Create(
328 C&: Ctx, DC: nullptr, IdLoc: SourceLocation(), Id: &Ctx.Idents.get(Name: ValNameStr[I]), T: ParamTy,
329 ParamKind: ImplicitParamKind::Other));
330
331 llvm::append_range(Args, Params);
332
333 return CGM.getTypes().arrangeBuiltinFunctionDeclaration(resultType: Ctx.VoidTy, args: Args);
334}
335
336template <size_t N, size_t... Ints>
337static std::array<Address, N> getParamAddrs(std::index_sequence<Ints...> IntSeq,
338 std::array<CharUnits, N> Alignments,
339 const FunctionArgList &Args,
340 CodeGenFunction *CGF) {
341 return std::array<Address, N>{
342 {Address(CGF->Builder.CreateLoad(Addr: CGF->GetAddrOfLocalVar(VD: Args[Ints])),
343 CGF->VoidPtrTy, Alignments[Ints], KnownNonNull)...}};
344}
345
346// Template classes that are used as bases for classes that emit special
347// functions.
348template <class Derived> struct GenFuncBase {
349 template <size_t N>
350 void visitStruct(QualType FT, const FieldDecl *FD, CharUnits CurStructOffset,
351 std::array<Address, N> Addrs) {
352 this->asDerived().callSpecialFunction(
353 FT, CurStructOffset + asDerived().getFieldOffset(FD), Addrs);
354 }
355
356 template <class FieldKind, size_t N>
357 void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
358 const FieldDecl *FD, CharUnits CurStructOffset,
359 std::array<Address, N> Addrs) {
360 // Non-volatile trivial fields are copied when flushTrivialFields is called.
361 if (!FK)
362 return asDerived().visitTrivial(QualType(AT, 0), FD, CurStructOffset,
363 Addrs);
364
365 asDerived().flushTrivialFields(Addrs);
366 CodeGenFunction &CGF = *this->CGF;
367 ASTContext &Ctx = CGF.getContext();
368
369 // Compute the end address.
370 QualType BaseEltQT;
371 std::array<Address, N> StartAddrs = Addrs;
372 for (unsigned I = 0; I < N; ++I)
373 StartAddrs[I] = getAddrWithOffset(Addrs[I], CurStructOffset, FD);
374 Address DstAddr = StartAddrs[DstIdx];
375 llvm::Value *NumElts = CGF.emitArrayLength(arrayType: AT, baseType&: BaseEltQT, addr&: DstAddr);
376 unsigned BaseEltSize = Ctx.getTypeSizeInChars(T: BaseEltQT).getQuantity();
377 llvm::Value *BaseEltSizeVal =
378 llvm::ConstantInt::get(Ty: NumElts->getType(), V: BaseEltSize);
379 llvm::Value *SizeInBytes =
380 CGF.Builder.CreateNUWMul(LHS: BaseEltSizeVal, RHS: NumElts);
381 llvm::Value *DstArrayEnd = CGF.Builder.CreateInBoundsGEP(
382 Ty: CGF.Int8Ty, Ptr: DstAddr.emitRawPointer(CGF), IdxList: SizeInBytes);
383 llvm::BasicBlock *PreheaderBB = CGF.Builder.GetInsertBlock();
384
385 // Create the header block and insert the phi instructions.
386 llvm::BasicBlock *HeaderBB = CGF.createBasicBlock(name: "loop.header");
387 CGF.EmitBlock(BB: HeaderBB);
388 llvm::PHINode *PHIs[N];
389
390 for (unsigned I = 0; I < N; ++I) {
391 PHIs[I] = CGF.Builder.CreatePHI(Ty: CGF.CGM.Int8PtrPtrTy, NumReservedValues: 2, Name: "addr.cur");
392 PHIs[I]->addIncoming(StartAddrs[I].emitRawPointer(CGF), PreheaderBB);
393 }
394
395 // Create the exit and loop body blocks.
396 llvm::BasicBlock *ExitBB = CGF.createBasicBlock(name: "loop.exit");
397 llvm::BasicBlock *LoopBB = CGF.createBasicBlock(name: "loop.body");
398
399 // Emit the comparison and conditional branch instruction that jumps to
400 // either the exit or the loop body.
401 llvm::Value *Done =
402 CGF.Builder.CreateICmpEQ(LHS: PHIs[DstIdx], RHS: DstArrayEnd, Name: "done");
403 CGF.Builder.CreateCondBr(Cond: Done, True: ExitBB, False: LoopBB);
404
405 // Visit the element of the array in the loop body.
406 CGF.EmitBlock(BB: LoopBB);
407 QualType EltQT = AT->getElementType();
408 CharUnits EltSize = Ctx.getTypeSizeInChars(T: EltQT);
409 std::array<Address, N> NewAddrs = Addrs;
410
411 for (unsigned I = 0; I < N; ++I)
412 NewAddrs[I] =
413 Address(PHIs[I], CGF.Int8PtrTy,
414 StartAddrs[I].getAlignment().alignmentAtOffset(EltSize));
415
416 EltQT = IsVolatile ? EltQT.withVolatile() : EltQT;
417 this->asDerived().visitWithKind(FK, EltQT, nullptr, CharUnits::Zero(),
418 NewAddrs);
419
420 LoopBB = CGF.Builder.GetInsertBlock();
421
422 for (unsigned I = 0; I < N; ++I) {
423 // Instrs to update the destination and source addresses.
424 // Update phi instructions.
425 NewAddrs[I] = getAddrWithOffset(NewAddrs[I], EltSize);
426 PHIs[I]->addIncoming(NewAddrs[I].emitRawPointer(CGF), LoopBB);
427 }
428
429 // Insert an unconditional branch to the header block.
430 CGF.Builder.CreateBr(Dest: HeaderBB);
431 CGF.EmitBlock(BB: ExitBB);
432 }
433
434 /// Return an address with the specified offset from the passed address.
435 Address getAddrWithOffset(Address Addr, CharUnits Offset) {
436 assert(Addr.isValid() && "invalid address");
437 if (Offset.getQuantity() == 0)
438 return Addr;
439 Addr = Addr.withElementType(ElemTy: CGF->CGM.Int8Ty);
440 Addr = CGF->Builder.CreateConstInBoundsGEP(Addr, Index: Offset.getQuantity());
441 return Addr.withElementType(ElemTy: CGF->CGM.Int8PtrTy);
442 }
443
444 Address getAddrWithOffset(Address Addr, CharUnits StructFieldOffset,
445 const FieldDecl *FD) {
446 return getAddrWithOffset(Addr, StructFieldOffset +
447 asDerived().getFieldOffset(FD));
448 }
449
450 template <size_t N>
451 llvm::Function *getFunction(StringRef FuncName, QualType QT,
452 std::array<CharUnits, N> Alignments,
453 CodeGenModule &CGM) {
454 // If the special function already exists in the module, return it.
455 if (llvm::Function *F = CGM.getModule().getFunction(Name: FuncName)) {
456 bool WrongType = false;
457 if (!F->getReturnType()->isVoidTy())
458 WrongType = true;
459 else {
460 for (const llvm::Argument &Arg : F->args())
461 if (Arg.getType() != CGM.Int8PtrPtrTy)
462 WrongType = true;
463 }
464
465 if (WrongType) {
466 std::string FuncName = std::string(F->getName());
467 SourceLocation Loc = QT->castAs<RecordType>()->getDecl()->getLocation();
468 CGM.Error(loc: Loc, error: "special function " + FuncName +
469 " for non-trivial C struct has incorrect type");
470 return nullptr;
471 }
472 return F;
473 }
474
475 ASTContext &Ctx = CGM.getContext();
476 FunctionArgList Args;
477 const CGFunctionInfo &FI = getFunctionInfo<N>(CGM, Args);
478 llvm::FunctionType *FuncTy = CGM.getTypes().GetFunctionType(Info: FI);
479 llvm::Function *F =
480 llvm::Function::Create(Ty: FuncTy, Linkage: llvm::GlobalValue::LinkOnceODRLinkage,
481 N: FuncName, M: &CGM.getModule());
482 F->setVisibility(llvm::GlobalValue::HiddenVisibility);
483 CGM.SetLLVMFunctionAttributes(GD: GlobalDecl(), Info: FI, F, /*IsThunk=*/false);
484 CGM.SetLLVMFunctionAttributesForDefinition(D: nullptr, F);
485 CodeGenFunction NewCGF(CGM);
486 setCGF(&NewCGF);
487 CGF->StartFunction(GD: GlobalDecl(), RetTy: Ctx.VoidTy, Fn: F, FnInfo: FI, Args);
488 auto AL = ApplyDebugLocation::CreateArtificial(CGF&: *CGF);
489 std::array<Address, N> Addrs =
490 getParamAddrs<N>(std::make_index_sequence<N>{}, Alignments, Args, CGF);
491 asDerived().visitStructFields(QT, CharUnits::Zero(), Addrs);
492 CGF->FinishFunction();
493 return F;
494 }
495
496 template <size_t N>
497 void callFunc(StringRef FuncName, QualType QT, std::array<Address, N> Addrs,
498 CodeGenFunction &CallerCGF) {
499 std::array<CharUnits, N> Alignments;
500 llvm::Value *Ptrs[N];
501
502 for (unsigned I = 0; I < N; ++I) {
503 Alignments[I] = Addrs[I].getAlignment();
504 Ptrs[I] = Addrs[I].emitRawPointer(CallerCGF);
505 }
506
507 if (llvm::Function *F =
508 getFunction(FuncName, QT, Alignments, CallerCGF.CGM))
509 CallerCGF.EmitNounwindRuntimeCall(F, Ptrs);
510 }
511
512 Derived &asDerived() { return static_cast<Derived &>(*this); }
513
514 void setCGF(CodeGenFunction *F) { CGF = F; }
515
516 CodeGenFunction *CGF = nullptr;
517};
518
519template <class Derived, bool IsMove, bool IsCtor>
520struct GenBinaryFunc : CopyStructVisitor<Derived, IsMove>,
521 GenFuncBase<Derived> {
522 GenBinaryFunc(ASTContext &Ctx) : CopyStructVisitor<Derived, IsMove>(Ctx) {}
523
524 void flushTrivialFields(std::array<Address, 2> Addrs) {
525 CharUnits Size = this->End - this->Start;
526
527 if (Size.getQuantity() == 0)
528 return;
529
530 Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], this->Start);
531 Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], this->Start);
532
533 // Emit memcpy.
534 if (Size.getQuantity() >= 16 ||
535 !llvm::has_single_bit<uint32_t>(Value: Size.getQuantity())) {
536 llvm::Value *SizeVal =
537 llvm::ConstantInt::get(this->CGF->SizeTy, Size.getQuantity());
538 DstAddr = DstAddr.withElementType(ElemTy: this->CGF->Int8Ty);
539 SrcAddr = SrcAddr.withElementType(ElemTy: this->CGF->Int8Ty);
540 this->CGF->Builder.CreateMemCpy(DstAddr, SrcAddr, SizeVal, false);
541 } else {
542 llvm::Type *Ty = llvm::Type::getIntNTy(
543 C&: this->CGF->getLLVMContext(),
544 N: Size.getQuantity() * this->CGF->getContext().getCharWidth());
545 DstAddr = DstAddr.withElementType(ElemTy: Ty);
546 SrcAddr = SrcAddr.withElementType(ElemTy: Ty);
547 llvm::Value *SrcVal = this->CGF->Builder.CreateLoad(SrcAddr, false);
548 this->CGF->Builder.CreateStore(SrcVal, DstAddr, false);
549 }
550
551 this->Start = this->End = CharUnits::Zero();
552 }
553
554 template <class... Ts>
555 void visitVolatileTrivial(QualType FT, const FieldDecl *FD, CharUnits Offset,
556 std::array<Address, 2> Addrs) {
557 LValue DstLV, SrcLV;
558 if (FD) {
559 // No need to copy zero-length bit-fields.
560 if (FD->isZeroLengthBitField())
561 return;
562
563 CanQualType RT =
564 this->CGF->getContext().getCanonicalTagType(FD->getParent());
565 llvm::Type *Ty = this->CGF->ConvertType(RT);
566 // FT is volatile-qualified, so propagate that onto the base lvalue's
567 // type.
568 QualType QT = QualType(RT).withVolatile();
569 Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], Offset);
570 LValue DstBase =
571 this->CGF->MakeAddrLValue(DstAddr.withElementType(ElemTy: Ty), QT);
572 DstLV = this->CGF->EmitLValueForField(DstBase, FD);
573 Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], Offset);
574 LValue SrcBase =
575 this->CGF->MakeAddrLValue(SrcAddr.withElementType(ElemTy: Ty), QT);
576 SrcLV = this->CGF->EmitLValueForField(SrcBase, FD);
577 } else {
578 llvm::Type *Ty = this->CGF->ConvertTypeForMem(FT);
579 Address DstAddr = Addrs[DstIdx].withElementType(ElemTy: Ty);
580 Address SrcAddr = Addrs[SrcIdx].withElementType(ElemTy: Ty);
581 DstLV = this->CGF->MakeAddrLValue(DstAddr, FT);
582 SrcLV = this->CGF->MakeAddrLValue(SrcAddr, FT);
583 }
584 // Load the value from the source. For the aggregate case, load directly
585 // into DstLV's own storage via an AggValueSlot.
586 AggValueSlot Slot = AggValueSlot::forLValue(
587 LV: DstLV, isDestructed: AggValueSlot::IsDestructed, needsGC: AggValueSlot::DoesNotNeedGCBarriers,
588 isAliased: IsCtor ? AggValueSlot::IsNotAliased : AggValueSlot::IsAliased,
589 mayOverlap: AggValueSlot::DoesNotOverlap);
590 RValue SrcVal =
591 this->CGF->EmitLoadOfAnyValue(SrcLV, Slot, SourceLocation());
592 switch (CodeGenFunction::getEvaluationKind(T: FT)) {
593 case TEK_Aggregate:
594 break; // Already copied into DstLV via Slot above.
595 case TEK_Complex:
596 this->CGF->EmitStoreOfComplex(SrcVal.getComplexVal(), DstLV,
597 /*isInit=*/IsCtor);
598 break;
599 case TEK_Scalar:
600 this->CGF->EmitStoreThroughLValue(SrcVal, DstLV, /*isInit=*/IsCtor);
601 break;
602 }
603 }
604 void visitPtrAuth(QualType FT, const FieldDecl *FD, CharUnits CurStackOffset,
605 std::array<Address, 2> Addrs) {
606 PointerAuthQualifier PtrAuth = FT.getPointerAuth().withoutKeyNone();
607 Addrs[DstIdx] = this->getAddrWithOffset(Addrs[DstIdx], CurStackOffset, FD);
608 Addrs[SrcIdx] = this->getAddrWithOffset(Addrs[SrcIdx], CurStackOffset, FD);
609 this->CGF->EmitPointerAuthCopy(PtrAuth, FT, Addrs[DstIdx], Addrs[SrcIdx]);
610 }
611};
612
613// These classes that emit the special functions for a non-trivial struct.
614struct GenDestructor : StructVisitor<GenDestructor>,
615 GenFuncBase<GenDestructor>,
616 DestructedTypeVisitor<GenDestructor> {
617 using Super = DestructedTypeVisitor<GenDestructor>;
618 GenDestructor(ASTContext &Ctx) : StructVisitor<GenDestructor>(Ctx) {}
619
620 void visitWithKind(QualType::DestructionKind DK, QualType FT,
621 const FieldDecl *FD, CharUnits CurStructOffset,
622 std::array<Address, 1> Addrs) {
623 if (const auto *AT = getContext().getAsArrayType(T: FT)) {
624 visitArray(FK: DK, AT, IsVolatile: FT.isVolatileQualified(), FD, CurStructOffset, Addrs);
625 return;
626 }
627
628 Super::visitWithKind(DK, FT, Args&: FD, Args&: CurStructOffset, Args&: Addrs);
629 }
630
631 void visitARCStrong(QualType QT, const FieldDecl *FD,
632 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
633 CGF->destroyARCStrongImprecise(
634 *CGF, getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD), QT);
635 }
636
637 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
638 std::array<Address, 1> Addrs) {
639 CGF->destroyARCWeak(
640 *CGF, getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD), QT);
641 }
642
643 void callSpecialFunction(QualType FT, CharUnits Offset,
644 std::array<Address, 1> Addrs) {
645 CGF->callCStructDestructor(
646 Dst: CGF->MakeAddrLValue(Addr: getAddrWithOffset(Addr: Addrs[DstIdx], Offset), T: FT));
647 }
648};
649
650struct GenDefaultInitialize
651 : StructVisitor<GenDefaultInitialize>,
652 GenFuncBase<GenDefaultInitialize>,
653 DefaultInitializedTypeVisitor<GenDefaultInitialize> {
654 using Super = DefaultInitializedTypeVisitor<GenDefaultInitialize>;
655 typedef GenFuncBase<GenDefaultInitialize> GenFuncBaseTy;
656
657 GenDefaultInitialize(ASTContext &Ctx)
658 : StructVisitor<GenDefaultInitialize>(Ctx) {}
659
660 void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
661 const FieldDecl *FD, CharUnits CurStructOffset,
662 std::array<Address, 1> Addrs) {
663 if (const auto *AT = getContext().getAsArrayType(T: FT)) {
664 visitArray(FK: PDIK, AT, IsVolatile: FT.isVolatileQualified(), FD, CurStructOffset,
665 Addrs);
666 return;
667 }
668
669 Super::visitWithKind(PDIK, FT, Args&: FD, Args&: CurStructOffset, Args&: Addrs);
670 }
671
672 void visitARCStrong(QualType QT, const FieldDecl *FD,
673 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
674 CGF->EmitNullInitialization(
675 DestPtr: getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD), Ty: QT);
676 }
677
678 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
679 std::array<Address, 1> Addrs) {
680 CGF->EmitNullInitialization(
681 DestPtr: getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD), Ty: QT);
682 }
683
684 template <class FieldKind, size_t... Is>
685 void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
686 const FieldDecl *FD, CharUnits CurStructOffset,
687 std::array<Address, 1> Addrs) {
688 if (!FK)
689 return visitTrivial(Args: QualType(AT, 0), Args: FD, Args: CurStructOffset, Args: Addrs);
690
691 ASTContext &Ctx = getContext();
692 CharUnits Size = Ctx.getTypeSizeInChars(T: QualType(AT, 0));
693 QualType EltTy = Ctx.getBaseElementType(QT: QualType(AT, 0));
694
695 if (Size < CharUnits::fromQuantity(Quantity: 16) ||
696 EltTy->getAsCanonical<RecordType>()) {
697 GenFuncBaseTy::visitArray(FK, AT, IsVolatile, FD, CurStructOffset, Addrs);
698 return;
699 }
700
701 llvm::Constant *SizeVal = CGF->Builder.getInt64(C: Size.getQuantity());
702 Address DstAddr = getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD);
703 Address Loc = DstAddr.withElementType(ElemTy: CGF->Int8Ty);
704 CGF->Builder.CreateMemSet(Dest: Loc, Value: CGF->Builder.getInt8(C: 0), Size: SizeVal,
705 IsVolatile);
706 }
707
708 void callSpecialFunction(QualType FT, CharUnits Offset,
709 std::array<Address, 1> Addrs) {
710 CGF->callCStructDefaultConstructor(
711 Dst: CGF->MakeAddrLValue(Addr: getAddrWithOffset(Addr: Addrs[DstIdx], Offset), T: FT));
712 }
713};
714
715struct GenCopyConstructor : GenBinaryFunc<GenCopyConstructor, false, true> {
716 GenCopyConstructor(ASTContext &Ctx)
717 : GenBinaryFunc<GenCopyConstructor, false, true>(Ctx) {}
718
719 void visitARCStrong(QualType QT, const FieldDecl *FD,
720 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
721 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD);
722 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], StructFieldOffset: CurStructOffset, FD);
723 llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
724 Addr: Addrs[SrcIdx], Volatile: QT.isVolatileQualified(), Ty: QT, Loc: SourceLocation());
725 llvm::Value *Val = CGF->EmitARCRetain(type: QT, value: SrcVal);
726 CGF->EmitStoreOfScalar(value: Val, lvalue: CGF->MakeAddrLValue(Addr: Addrs[DstIdx], T: QT), isInit: true);
727 }
728
729 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
730 std::array<Address, 2> Addrs) {
731 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD);
732 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], StructFieldOffset: CurStructOffset, FD);
733 CGF->EmitARCCopyWeak(dst: Addrs[DstIdx], src: Addrs[SrcIdx]);
734 }
735
736 void callSpecialFunction(QualType FT, CharUnits Offset,
737 std::array<Address, 2> Addrs) {
738 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], Offset);
739 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], Offset);
740 CGF->callCStructCopyConstructor(Dst: CGF->MakeAddrLValue(Addr: Addrs[DstIdx], T: FT),
741 Src: CGF->MakeAddrLValue(Addr: Addrs[SrcIdx], T: FT));
742 }
743};
744
745struct GenMoveConstructor : GenBinaryFunc<GenMoveConstructor, true, true> {
746 GenMoveConstructor(ASTContext &Ctx)
747 : GenBinaryFunc<GenMoveConstructor, true, true>(Ctx) {}
748
749 void visitARCStrong(QualType QT, const FieldDecl *FD,
750 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
751 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD);
752 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], StructFieldOffset: CurStructOffset, FD);
753 LValue SrcLV = CGF->MakeAddrLValue(Addr: Addrs[SrcIdx], T: QT);
754 llvm::Value *SrcVal =
755 CGF->EmitLoadOfLValue(V: SrcLV, Loc: SourceLocation()).getScalarVal();
756 CGF->EmitStoreOfScalar(value: getNullForVariable(Addr: SrcLV.getAddress()), lvalue: SrcLV);
757 CGF->EmitStoreOfScalar(value: SrcVal, lvalue: CGF->MakeAddrLValue(Addr: Addrs[DstIdx], T: QT),
758 /* isInitialization */ isInit: true);
759 }
760
761 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
762 std::array<Address, 2> Addrs) {
763 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD);
764 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], StructFieldOffset: CurStructOffset, FD);
765 CGF->EmitARCMoveWeak(dst: Addrs[DstIdx], src: Addrs[SrcIdx]);
766 }
767
768 void callSpecialFunction(QualType FT, CharUnits Offset,
769 std::array<Address, 2> Addrs) {
770 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], Offset);
771 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], Offset);
772 CGF->callCStructMoveConstructor(Dst: CGF->MakeAddrLValue(Addr: Addrs[DstIdx], T: FT),
773 Src: CGF->MakeAddrLValue(Addr: Addrs[SrcIdx], T: FT));
774 }
775};
776
777struct GenCopyAssignment : GenBinaryFunc<GenCopyAssignment, false, false> {
778 GenCopyAssignment(ASTContext &Ctx)
779 : GenBinaryFunc<GenCopyAssignment, false, false>(Ctx) {}
780
781 void visitARCStrong(QualType QT, const FieldDecl *FD,
782 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
783 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD);
784 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], StructFieldOffset: CurStructOffset, FD);
785 llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
786 Addr: Addrs[SrcIdx], Volatile: QT.isVolatileQualified(), Ty: QT, Loc: SourceLocation());
787 CGF->EmitARCStoreStrong(lvalue: CGF->MakeAddrLValue(Addr: Addrs[DstIdx], T: QT), value: SrcVal,
788 resultIgnored: false);
789 }
790
791 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
792 std::array<Address, 2> Addrs) {
793 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD);
794 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], StructFieldOffset: CurStructOffset, FD);
795 CGF->emitARCCopyAssignWeak(Ty: QT, DstAddr: Addrs[DstIdx], SrcAddr: Addrs[SrcIdx]);
796 }
797
798 void callSpecialFunction(QualType FT, CharUnits Offset,
799 std::array<Address, 2> Addrs) {
800 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], Offset);
801 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], Offset);
802 CGF->callCStructCopyAssignmentOperator(
803 Dst: CGF->MakeAddrLValue(Addr: Addrs[DstIdx], T: FT),
804 Src: CGF->MakeAddrLValue(Addr: Addrs[SrcIdx], T: FT));
805 }
806};
807
808struct GenMoveAssignment : GenBinaryFunc<GenMoveAssignment, true, false> {
809 GenMoveAssignment(ASTContext &Ctx)
810 : GenBinaryFunc<GenMoveAssignment, true, false>(Ctx) {}
811
812 void visitARCStrong(QualType QT, const FieldDecl *FD,
813 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
814 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD);
815 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], StructFieldOffset: CurStructOffset, FD);
816 LValue SrcLV = CGF->MakeAddrLValue(Addr: Addrs[SrcIdx], T: QT);
817 llvm::Value *SrcVal =
818 CGF->EmitLoadOfLValue(V: SrcLV, Loc: SourceLocation()).getScalarVal();
819 CGF->EmitStoreOfScalar(value: getNullForVariable(Addr: SrcLV.getAddress()), lvalue: SrcLV);
820 LValue DstLV = CGF->MakeAddrLValue(Addr: Addrs[DstIdx], T: QT);
821 llvm::Value *DstVal =
822 CGF->EmitLoadOfLValue(V: DstLV, Loc: SourceLocation()).getScalarVal();
823 CGF->EmitStoreOfScalar(value: SrcVal, lvalue: DstLV);
824 CGF->EmitARCRelease(value: DstVal, precise: ARCImpreciseLifetime);
825 }
826
827 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
828 std::array<Address, 2> Addrs) {
829 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], StructFieldOffset: CurStructOffset, FD);
830 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], StructFieldOffset: CurStructOffset, FD);
831 CGF->emitARCMoveAssignWeak(Ty: QT, DstAddr: Addrs[DstIdx], SrcAddr: Addrs[SrcIdx]);
832 }
833
834 void callSpecialFunction(QualType FT, CharUnits Offset,
835 std::array<Address, 2> Addrs) {
836 Addrs[DstIdx] = getAddrWithOffset(Addr: Addrs[DstIdx], Offset);
837 Addrs[SrcIdx] = getAddrWithOffset(Addr: Addrs[SrcIdx], Offset);
838 CGF->callCStructMoveAssignmentOperator(
839 Dst: CGF->MakeAddrLValue(Addr: Addrs[DstIdx], T: FT),
840 Src: CGF->MakeAddrLValue(Addr: Addrs[SrcIdx], T: FT));
841 }
842};
843
844} // namespace
845
846void CodeGenFunction::destroyNonTrivialCStruct(CodeGenFunction &CGF,
847 Address Addr, QualType Type) {
848 CGF.callCStructDestructor(Dst: CGF.MakeAddrLValue(Addr, T: Type));
849}
850
851// Default-initialize a variable that is a non-trivial struct or an array of
852// such structure.
853void CodeGenFunction::defaultInitNonTrivialCStructVar(LValue Dst) {
854 GenDefaultInitialize Gen(getContext());
855 Address DstPtr = Dst.getAddress().withElementType(ElemTy: CGM.Int8PtrTy);
856 Gen.setCGF(this);
857 QualType QT = Dst.getType();
858 QT = Dst.isVolatile() ? QT.withVolatile() : QT;
859 Gen.visit(FT: QT, Args: nullptr, Args: CharUnits::Zero(), Args: std::array<Address, 1>({._M_elems: {DstPtr}}));
860}
861
862template <class G, size_t N>
863static void callSpecialFunction(G &&Gen, StringRef FuncName, QualType QT,
864 bool IsVolatile, CodeGenFunction &CGF,
865 std::array<Address, N> Addrs) {
866 auto SetArtificialLoc = ApplyDebugLocation::CreateArtificial(CGF);
867 for (unsigned I = 0; I < N; ++I)
868 Addrs[I] = Addrs[I].withElementType(CGF.CGM.Int8PtrTy);
869 QT = IsVolatile ? QT.withVolatile() : QT;
870 Gen.callFunc(FuncName, QT, Addrs, CGF);
871}
872
873template <class G, size_t N>
874static llvm::Function *
875getSpecialFunction(G &&Gen, StringRef FuncName, QualType QT, bool IsVolatile,
876 std::array<CharUnits, N> Alignments, CodeGenModule &CGM) {
877 QT = IsVolatile ? QT.withVolatile() : QT;
878 // The following call requires an array of addresses as arguments, but doesn't
879 // actually use them (it overwrites them with the addresses of the arguments
880 // of the created function).
881 return Gen.getFunction(FuncName, QT, Alignments, CGM);
882}
883
884// Functions to emit calls to the special functions of a non-trivial C struct.
885void CodeGenFunction::callCStructDefaultConstructor(LValue Dst) {
886 bool IsVolatile = Dst.isVolatile();
887 Address DstPtr = Dst.getAddress();
888 QualType QT = Dst.getType();
889 GenDefaultInitializeFuncName GenName(DstPtr.getAlignment(), getContext());
890 std::string FuncName = GenName.getName(QT, IsVolatile);
891 callSpecialFunction(Gen: GenDefaultInitialize(getContext()), FuncName, QT,
892 IsVolatile, CGF&: *this, Addrs: std::array<Address, 1>({._M_elems: {DstPtr}}));
893}
894
895std::string CodeGenFunction::getNonTrivialCopyConstructorStr(
896 QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx) {
897 GenBinaryFuncName<false> GenName("", Alignment, Alignment, Ctx);
898 return GenName.getName(QT, IsVolatile);
899}
900
901std::string CodeGenFunction::getNonTrivialDestructorStr(QualType QT,
902 CharUnits Alignment,
903 bool IsVolatile,
904 ASTContext &Ctx) {
905 GenDestructorFuncName GenName("", Alignment, Ctx);
906 return GenName.getName(QT, IsVolatile);
907}
908
909void CodeGenFunction::callCStructDestructor(LValue Dst) {
910 bool IsVolatile = Dst.isVolatile();
911 Address DstPtr = Dst.getAddress();
912 QualType QT = Dst.getType();
913 GenDestructorFuncName GenName("__destructor_", DstPtr.getAlignment(),
914 getContext());
915 std::string FuncName = GenName.getName(QT, IsVolatile);
916 callSpecialFunction(Gen: GenDestructor(getContext()), FuncName, QT, IsVolatile,
917 CGF&: *this, Addrs: std::array<Address, 1>({._M_elems: {DstPtr}}));
918}
919
920void CodeGenFunction::callCStructCopyConstructor(LValue Dst, LValue Src) {
921 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
922 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
923 QualType QT = Dst.getType();
924 GenBinaryFuncName<false> GenName("__copy_constructor_", DstPtr.getAlignment(),
925 SrcPtr.getAlignment(), getContext());
926 std::string FuncName = GenName.getName(QT, IsVolatile);
927 callSpecialFunction(Gen: GenCopyConstructor(getContext()), FuncName, QT,
928 IsVolatile, CGF&: *this,
929 Addrs: std::array<Address, 2>({._M_elems: {DstPtr, SrcPtr}}));
930}
931
932void CodeGenFunction::callCStructCopyAssignmentOperator(LValue Dst, LValue Src
933
934) {
935 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
936 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
937 QualType QT = Dst.getType();
938 GenBinaryFuncName<false> GenName("__copy_assignment_", DstPtr.getAlignment(),
939 SrcPtr.getAlignment(), getContext());
940 std::string FuncName = GenName.getName(QT, IsVolatile);
941 callSpecialFunction(Gen: GenCopyAssignment(getContext()), FuncName, QT, IsVolatile,
942 CGF&: *this, Addrs: std::array<Address, 2>({._M_elems: {DstPtr, SrcPtr}}));
943}
944
945void CodeGenFunction::callCStructMoveConstructor(LValue Dst, LValue Src) {
946 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
947 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
948 QualType QT = Dst.getType();
949 GenBinaryFuncName<true> GenName("__move_constructor_", DstPtr.getAlignment(),
950 SrcPtr.getAlignment(), getContext());
951 std::string FuncName = GenName.getName(QT, IsVolatile);
952 callSpecialFunction(Gen: GenMoveConstructor(getContext()), FuncName, QT,
953 IsVolatile, CGF&: *this,
954 Addrs: std::array<Address, 2>({._M_elems: {DstPtr, SrcPtr}}));
955}
956
957void CodeGenFunction::callCStructMoveAssignmentOperator(LValue Dst, LValue Src
958
959) {
960 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
961 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
962 QualType QT = Dst.getType();
963 GenBinaryFuncName<true> GenName("__move_assignment_", DstPtr.getAlignment(),
964 SrcPtr.getAlignment(), getContext());
965 std::string FuncName = GenName.getName(QT, IsVolatile);
966 callSpecialFunction(Gen: GenMoveAssignment(getContext()), FuncName, QT, IsVolatile,
967 CGF&: *this, Addrs: std::array<Address, 2>({._M_elems: {DstPtr, SrcPtr}}));
968}
969
970llvm::Function *clang::CodeGen::getNonTrivialCStructDefaultConstructor(
971 CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
972 ASTContext &Ctx = CGM.getContext();
973 GenDefaultInitializeFuncName GenName(DstAlignment, Ctx);
974 std::string FuncName = GenName.getName(QT, IsVolatile);
975 return getSpecialFunction(Gen: GenDefaultInitialize(Ctx), FuncName, QT, IsVolatile,
976 Alignments: std::array<CharUnits, 1>({._M_elems: {DstAlignment}}), CGM);
977}
978
979llvm::Function *clang::CodeGen::getNonTrivialCStructCopyConstructor(
980 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
981 bool IsVolatile, QualType QT) {
982 ASTContext &Ctx = CGM.getContext();
983 GenBinaryFuncName<false> GenName("__copy_constructor_", DstAlignment,
984 SrcAlignment, Ctx);
985 std::string FuncName = GenName.getName(QT, IsVolatile);
986 return getSpecialFunction(
987 Gen: GenCopyConstructor(Ctx), FuncName, QT, IsVolatile,
988 Alignments: std::array<CharUnits, 2>({._M_elems: {DstAlignment, SrcAlignment}}), CGM);
989}
990
991llvm::Function *clang::CodeGen::getNonTrivialCStructMoveConstructor(
992 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
993 bool IsVolatile, QualType QT) {
994 ASTContext &Ctx = CGM.getContext();
995 GenBinaryFuncName<true> GenName("__move_constructor_", DstAlignment,
996 SrcAlignment, Ctx);
997 std::string FuncName = GenName.getName(QT, IsVolatile);
998 return getSpecialFunction(
999 Gen: GenMoveConstructor(Ctx), FuncName, QT, IsVolatile,
1000 Alignments: std::array<CharUnits, 2>({._M_elems: {DstAlignment, SrcAlignment}}), CGM);
1001}
1002
1003llvm::Function *clang::CodeGen::getNonTrivialCStructCopyAssignmentOperator(
1004 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
1005 bool IsVolatile, QualType QT) {
1006 ASTContext &Ctx = CGM.getContext();
1007 GenBinaryFuncName<false> GenName("__copy_assignment_", DstAlignment,
1008 SrcAlignment, Ctx);
1009 std::string FuncName = GenName.getName(QT, IsVolatile);
1010 return getSpecialFunction(
1011 Gen: GenCopyAssignment(Ctx), FuncName, QT, IsVolatile,
1012 Alignments: std::array<CharUnits, 2>({._M_elems: {DstAlignment, SrcAlignment}}), CGM);
1013}
1014
1015llvm::Function *clang::CodeGen::getNonTrivialCStructMoveAssignmentOperator(
1016 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
1017 bool IsVolatile, QualType QT) {
1018 ASTContext &Ctx = CGM.getContext();
1019 GenBinaryFuncName<true> GenName("__move_assignment_", DstAlignment,
1020 SrcAlignment, Ctx);
1021 std::string FuncName = GenName.getName(QT, IsVolatile);
1022 return getSpecialFunction(
1023 Gen: GenMoveAssignment(Ctx), FuncName, QT, IsVolatile,
1024 Alignments: std::array<CharUnits, 2>({._M_elems: {DstAlignment, SrcAlignment}}), CGM);
1025}
1026
1027llvm::Function *clang::CodeGen::getNonTrivialCStructDestructor(
1028 CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
1029 ASTContext &Ctx = CGM.getContext();
1030 GenDestructorFuncName GenName("__destructor_", DstAlignment, Ctx);
1031 std::string FuncName = GenName.getName(QT, IsVolatile);
1032 return getSpecialFunction(Gen: GenDestructor(Ctx), FuncName, QT, IsVolatile,
1033 Alignments: std::array<CharUnits, 1>({._M_elems: {DstAlignment}}), CGM);
1034}
1035