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