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   llvm::append_range(Args, Params);
319 
320   return CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args);
321 }
322 
323 template <size_t N, size_t... Ints>
324 static std::array<Address, N> getParamAddrs(std::index_sequence<Ints...> IntSeq,
325                                             std::array<CharUnits, N> Alignments,
326                                             FunctionArgList Args,
327                                             CodeGenFunction *CGF) {
328   return std::array<Address, N>{
329       {Address(CGF->Builder.CreateLoad(CGF->GetAddrOfLocalVar(Args[Ints])),
330                CGF->VoidPtrTy, Alignments[Ints])...}};
331 }
332 
333 // Template classes that are used as bases for classes that emit special
334 // functions.
335 template <class Derived> struct GenFuncBase {
336   template <size_t N>
337   void visitStruct(QualType FT, const FieldDecl *FD, CharUnits CurStructOffset,
338                    std::array<Address, N> Addrs) {
339     this->asDerived().callSpecialFunction(
340         FT, CurStructOffset + asDerived().getFieldOffset(FD), Addrs);
341   }
342 
343   template <class FieldKind, size_t N>
344   void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
345                   const FieldDecl *FD, CharUnits CurStructOffset,
346                   std::array<Address, N> Addrs) {
347     // Non-volatile trivial fields are copied when flushTrivialFields is called.
348     if (!FK)
349       return asDerived().visitTrivial(QualType(AT, 0), FD, CurStructOffset,
350                                       Addrs);
351 
352     asDerived().flushTrivialFields(Addrs);
353     CodeGenFunction &CGF = *this->CGF;
354     ASTContext &Ctx = CGF.getContext();
355 
356     // Compute the end address.
357     QualType BaseEltQT;
358     std::array<Address, N> StartAddrs = Addrs;
359     for (unsigned I = 0; I < N; ++I)
360       StartAddrs[I] = getAddrWithOffset(Addrs[I], CurStructOffset, FD);
361     Address DstAddr = StartAddrs[DstIdx];
362     llvm::Value *NumElts = CGF.emitArrayLength(AT, BaseEltQT, DstAddr);
363     unsigned BaseEltSize = Ctx.getTypeSizeInChars(BaseEltQT).getQuantity();
364     llvm::Value *BaseEltSizeVal =
365         llvm::ConstantInt::get(NumElts->getType(), BaseEltSize);
366     llvm::Value *SizeInBytes =
367         CGF.Builder.CreateNUWMul(BaseEltSizeVal, NumElts);
368     Address BC = CGF.Builder.CreateElementBitCast(DstAddr, CGF.CGM.Int8Ty);
369     llvm::Value *DstArrayEnd =
370         CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, BC.getPointer(), SizeInBytes);
371     DstArrayEnd = CGF.Builder.CreateBitCast(
372         DstArrayEnd, CGF.CGM.Int8PtrPtrTy, "dstarray.end");
373     llvm::BasicBlock *PreheaderBB = CGF.Builder.GetInsertBlock();
374 
375     // Create the header block and insert the phi instructions.
376     llvm::BasicBlock *HeaderBB = CGF.createBasicBlock("loop.header");
377     CGF.EmitBlock(HeaderBB);
378     llvm::PHINode *PHIs[N];
379 
380     for (unsigned I = 0; I < N; ++I) {
381       PHIs[I] = CGF.Builder.CreatePHI(CGF.CGM.Int8PtrPtrTy, 2, "addr.cur");
382       PHIs[I]->addIncoming(StartAddrs[I].getPointer(), PreheaderBB);
383     }
384 
385     // Create the exit and loop body blocks.
386     llvm::BasicBlock *ExitBB = CGF.createBasicBlock("loop.exit");
387     llvm::BasicBlock *LoopBB = CGF.createBasicBlock("loop.body");
388 
389     // Emit the comparison and conditional branch instruction that jumps to
390     // either the exit or the loop body.
391     llvm::Value *Done =
392         CGF.Builder.CreateICmpEQ(PHIs[DstIdx], DstArrayEnd, "done");
393     CGF.Builder.CreateCondBr(Done, ExitBB, LoopBB);
394 
395     // Visit the element of the array in the loop body.
396     CGF.EmitBlock(LoopBB);
397     QualType EltQT = AT->getElementType();
398     CharUnits EltSize = Ctx.getTypeSizeInChars(EltQT);
399     std::array<Address, N> NewAddrs = Addrs;
400 
401     for (unsigned I = 0; I < N; ++I)
402       NewAddrs[I] =
403             Address(PHIs[I], CGF.Int8PtrTy,
404                     StartAddrs[I].getAlignment().alignmentAtOffset(EltSize));
405 
406     EltQT = IsVolatile ? EltQT.withVolatile() : EltQT;
407     this->asDerived().visitWithKind(FK, EltQT, nullptr, CharUnits::Zero(),
408                                     NewAddrs);
409 
410     LoopBB = CGF.Builder.GetInsertBlock();
411 
412     for (unsigned I = 0; I < N; ++I) {
413       // Instrs to update the destination and source addresses.
414       // Update phi instructions.
415       NewAddrs[I] = getAddrWithOffset(NewAddrs[I], EltSize);
416       PHIs[I]->addIncoming(NewAddrs[I].getPointer(), LoopBB);
417     }
418 
419     // Insert an unconditional branch to the header block.
420     CGF.Builder.CreateBr(HeaderBB);
421     CGF.EmitBlock(ExitBB);
422   }
423 
424   /// Return an address with the specified offset from the passed address.
425   Address getAddrWithOffset(Address Addr, CharUnits Offset) {
426     assert(Addr.isValid() && "invalid address");
427     if (Offset.getQuantity() == 0)
428       return Addr;
429     Addr = CGF->Builder.CreateElementBitCast(Addr, CGF->CGM.Int8Ty);
430     Addr = CGF->Builder.CreateConstInBoundsGEP(Addr, Offset.getQuantity());
431     return CGF->Builder.CreateElementBitCast(Addr, CGF->CGM.Int8PtrTy);
432   }
433 
434   Address getAddrWithOffset(Address Addr, CharUnits StructFieldOffset,
435                             const FieldDecl *FD) {
436     return getAddrWithOffset(Addr, StructFieldOffset +
437                                        asDerived().getFieldOffset(FD));
438   }
439 
440   template <size_t N>
441   llvm::Function *getFunction(StringRef FuncName, QualType QT,
442                               std::array<CharUnits, N> Alignments,
443                               CodeGenModule &CGM) {
444     // If the special function already exists in the module, return it.
445     if (llvm::Function *F = CGM.getModule().getFunction(FuncName)) {
446       bool WrongType = false;
447       if (!F->getReturnType()->isVoidTy())
448         WrongType = true;
449       else {
450         for (const llvm::Argument &Arg : F->args())
451           if (Arg.getType() != CGM.Int8PtrPtrTy)
452             WrongType = true;
453       }
454 
455       if (WrongType) {
456         std::string FuncName = std::string(F->getName());
457         SourceLocation Loc = QT->castAs<RecordType>()->getDecl()->getLocation();
458         CGM.Error(Loc, "special function " + FuncName +
459                            " for non-trivial C struct has incorrect type");
460         return nullptr;
461       }
462       return F;
463     }
464 
465     ASTContext &Ctx = CGM.getContext();
466     FunctionArgList Args;
467     const CGFunctionInfo &FI = getFunctionInfo<N>(CGM, Args);
468     llvm::FunctionType *FuncTy = CGM.getTypes().GetFunctionType(FI);
469     llvm::Function *F =
470         llvm::Function::Create(FuncTy, llvm::GlobalValue::LinkOnceODRLinkage,
471                                FuncName, &CGM.getModule());
472     F->setVisibility(llvm::GlobalValue::HiddenVisibility);
473     CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, F, /*IsThunk=*/false);
474     CGM.SetLLVMFunctionAttributesForDefinition(nullptr, F);
475     CodeGenFunction NewCGF(CGM);
476     setCGF(&NewCGF);
477     CGF->StartFunction(GlobalDecl(), Ctx.VoidTy, F, FI, Args);
478     auto AL = ApplyDebugLocation::CreateArtificial(*CGF);
479     std::array<Address, N> Addrs =
480         getParamAddrs<N>(std::make_index_sequence<N>{}, Alignments, Args, CGF);
481     asDerived().visitStructFields(QT, CharUnits::Zero(), Addrs);
482     CGF->FinishFunction();
483     return F;
484   }
485 
486   template <size_t N>
487   void callFunc(StringRef FuncName, QualType QT, std::array<Address, N> Addrs,
488                 CodeGenFunction &CallerCGF) {
489     std::array<CharUnits, N> Alignments;
490     llvm::Value *Ptrs[N];
491 
492     for (unsigned I = 0; I < N; ++I) {
493       Alignments[I] = Addrs[I].getAlignment();
494       Ptrs[I] = CallerCGF.Builder.CreateElementBitCast(
495           Addrs[I], CallerCGF.CGM.Int8PtrTy).getPointer();
496     }
497 
498     if (llvm::Function *F =
499             getFunction(FuncName, QT, Alignments, CallerCGF.CGM))
500       CallerCGF.EmitNounwindRuntimeCall(F, Ptrs);
501   }
502 
503   Derived &asDerived() { return static_cast<Derived &>(*this); }
504 
505   void setCGF(CodeGenFunction *F) { CGF = F; }
506 
507   CodeGenFunction *CGF = nullptr;
508 };
509 
510 template <class Derived, bool IsMove>
511 struct GenBinaryFunc : CopyStructVisitor<Derived, IsMove>,
512                        GenFuncBase<Derived> {
513   GenBinaryFunc(ASTContext &Ctx) : CopyStructVisitor<Derived, IsMove>(Ctx) {}
514 
515   void flushTrivialFields(std::array<Address, 2> Addrs) {
516     CharUnits Size = this->End - this->Start;
517 
518     if (Size.getQuantity() == 0)
519       return;
520 
521     Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], this->Start);
522     Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], this->Start);
523 
524     // Emit memcpy.
525     if (Size.getQuantity() >= 16 || !llvm::isPowerOf2_32(Size.getQuantity())) {
526       llvm::Value *SizeVal =
527           llvm::ConstantInt::get(this->CGF->SizeTy, Size.getQuantity());
528       DstAddr =
529           this->CGF->Builder.CreateElementBitCast(DstAddr, this->CGF->Int8Ty);
530       SrcAddr =
531           this->CGF->Builder.CreateElementBitCast(SrcAddr, this->CGF->Int8Ty);
532       this->CGF->Builder.CreateMemCpy(DstAddr, SrcAddr, SizeVal, false);
533     } else {
534       llvm::Type *Ty = llvm::Type::getIntNTy(
535           this->CGF->getLLVMContext(),
536           Size.getQuantity() * this->CGF->getContext().getCharWidth());
537       DstAddr = this->CGF->Builder.CreateElementBitCast(DstAddr, Ty);
538       SrcAddr = this->CGF->Builder.CreateElementBitCast(SrcAddr, Ty);
539       llvm::Value *SrcVal = this->CGF->Builder.CreateLoad(SrcAddr, false);
540       this->CGF->Builder.CreateStore(SrcVal, DstAddr, false);
541     }
542 
543     this->Start = this->End = CharUnits::Zero();
544   }
545 
546   template <class... Ts>
547   void visitVolatileTrivial(QualType FT, const FieldDecl *FD, CharUnits Offset,
548                             std::array<Address, 2> Addrs) {
549     LValue DstLV, SrcLV;
550     if (FD) {
551       // No need to copy zero-length bit-fields.
552       if (FD->isZeroLengthBitField(this->CGF->getContext()))
553         return;
554 
555       QualType RT = QualType(FD->getParent()->getTypeForDecl(), 0);
556       llvm::Type *Ty = this->CGF->ConvertType(RT);
557       Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], Offset);
558       LValue DstBase = this->CGF->MakeAddrLValue(
559           this->CGF->Builder.CreateElementBitCast(DstAddr, Ty), FT);
560       DstLV = this->CGF->EmitLValueForField(DstBase, FD);
561       Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], Offset);
562       LValue SrcBase = this->CGF->MakeAddrLValue(
563           this->CGF->Builder.CreateElementBitCast(SrcAddr, Ty), FT);
564       SrcLV = this->CGF->EmitLValueForField(SrcBase, FD);
565     } else {
566       llvm::Type *Ty = this->CGF->ConvertTypeForMem(FT);
567       Address DstAddr =
568           this->CGF->Builder.CreateElementBitCast(Addrs[DstIdx], Ty);
569       Address SrcAddr =
570           this->CGF->Builder.CreateElementBitCast(Addrs[SrcIdx], Ty);
571       DstLV = this->CGF->MakeAddrLValue(DstAddr, FT);
572       SrcLV = this->CGF->MakeAddrLValue(SrcAddr, FT);
573     }
574     RValue SrcVal = this->CGF->EmitLoadOfLValue(SrcLV, SourceLocation());
575     this->CGF->EmitStoreThroughLValue(SrcVal, DstLV);
576   }
577 };
578 
579 // These classes that emit the special functions for a non-trivial struct.
580 struct GenDestructor : StructVisitor<GenDestructor>,
581                        GenFuncBase<GenDestructor>,
582                        DestructedTypeVisitor<GenDestructor> {
583   using Super = DestructedTypeVisitor<GenDestructor>;
584   GenDestructor(ASTContext &Ctx) : StructVisitor<GenDestructor>(Ctx) {}
585 
586   void visitWithKind(QualType::DestructionKind DK, QualType FT,
587                      const FieldDecl *FD, CharUnits CurStructOffset,
588                      std::array<Address, 1> Addrs) {
589     if (const auto *AT = getContext().getAsArrayType(FT)) {
590       visitArray(DK, AT, FT.isVolatileQualified(), FD, CurStructOffset, Addrs);
591       return;
592     }
593 
594     Super::visitWithKind(DK, FT, FD, CurStructOffset, Addrs);
595   }
596 
597   void visitARCStrong(QualType QT, const FieldDecl *FD,
598                       CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
599     CGF->destroyARCStrongImprecise(
600         *CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
601   }
602 
603   void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
604                     std::array<Address, 1> Addrs) {
605     CGF->destroyARCWeak(
606         *CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
607   }
608 
609   void callSpecialFunction(QualType FT, CharUnits Offset,
610                            std::array<Address, 1> Addrs) {
611     CGF->callCStructDestructor(
612         CGF->MakeAddrLValue(getAddrWithOffset(Addrs[DstIdx], Offset), FT));
613   }
614 };
615 
616 struct GenDefaultInitialize
617     : StructVisitor<GenDefaultInitialize>,
618       GenFuncBase<GenDefaultInitialize>,
619       DefaultInitializedTypeVisitor<GenDefaultInitialize> {
620   using Super = DefaultInitializedTypeVisitor<GenDefaultInitialize>;
621   typedef GenFuncBase<GenDefaultInitialize> GenFuncBaseTy;
622 
623   GenDefaultInitialize(ASTContext &Ctx)
624       : StructVisitor<GenDefaultInitialize>(Ctx) {}
625 
626   void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
627                      const FieldDecl *FD, CharUnits CurStructOffset,
628                      std::array<Address, 1> Addrs) {
629     if (const auto *AT = getContext().getAsArrayType(FT)) {
630       visitArray(PDIK, AT, FT.isVolatileQualified(), FD, CurStructOffset,
631                  Addrs);
632       return;
633     }
634 
635     Super::visitWithKind(PDIK, FT, FD, CurStructOffset, Addrs);
636   }
637 
638   void visitARCStrong(QualType QT, const FieldDecl *FD,
639                       CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
640     CGF->EmitNullInitialization(
641         getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
642   }
643 
644   void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
645                     std::array<Address, 1> Addrs) {
646     CGF->EmitNullInitialization(
647         getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
648   }
649 
650   template <class FieldKind, size_t... Is>
651   void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
652                   const FieldDecl *FD, CharUnits CurStructOffset,
653                   std::array<Address, 1> Addrs) {
654     if (!FK)
655       return visitTrivial(QualType(AT, 0), FD, CurStructOffset, Addrs);
656 
657     ASTContext &Ctx = getContext();
658     CharUnits Size = Ctx.getTypeSizeInChars(QualType(AT, 0));
659     QualType EltTy = Ctx.getBaseElementType(QualType(AT, 0));
660 
661     if (Size < CharUnits::fromQuantity(16) || EltTy->getAs<RecordType>()) {
662       GenFuncBaseTy::visitArray(FK, AT, IsVolatile, FD, CurStructOffset, Addrs);
663       return;
664     }
665 
666     llvm::Constant *SizeVal = CGF->Builder.getInt64(Size.getQuantity());
667     Address DstAddr = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
668     Address Loc = CGF->Builder.CreateElementBitCast(DstAddr, CGF->Int8Ty);
669     CGF->Builder.CreateMemSet(Loc, CGF->Builder.getInt8(0), SizeVal,
670                               IsVolatile);
671   }
672 
673   void callSpecialFunction(QualType FT, CharUnits Offset,
674                            std::array<Address, 1> Addrs) {
675     CGF->callCStructDefaultConstructor(
676         CGF->MakeAddrLValue(getAddrWithOffset(Addrs[DstIdx], Offset), FT));
677   }
678 };
679 
680 struct GenCopyConstructor : GenBinaryFunc<GenCopyConstructor, false> {
681   GenCopyConstructor(ASTContext &Ctx)
682       : GenBinaryFunc<GenCopyConstructor, false>(Ctx) {}
683 
684   void visitARCStrong(QualType QT, const FieldDecl *FD,
685                       CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
686     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
687     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
688     llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
689         Addrs[SrcIdx], QT.isVolatileQualified(), QT, SourceLocation());
690     llvm::Value *Val = CGF->EmitARCRetain(QT, SrcVal);
691     CGF->EmitStoreOfScalar(Val, CGF->MakeAddrLValue(Addrs[DstIdx], QT), true);
692   }
693 
694   void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
695                     std::array<Address, 2> Addrs) {
696     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
697     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
698     CGF->EmitARCCopyWeak(Addrs[DstIdx], Addrs[SrcIdx]);
699   }
700 
701   void callSpecialFunction(QualType FT, CharUnits Offset,
702                            std::array<Address, 2> Addrs) {
703     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
704     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
705     CGF->callCStructCopyConstructor(CGF->MakeAddrLValue(Addrs[DstIdx], FT),
706                                     CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
707   }
708 };
709 
710 struct GenMoveConstructor : GenBinaryFunc<GenMoveConstructor, true> {
711   GenMoveConstructor(ASTContext &Ctx)
712       : GenBinaryFunc<GenMoveConstructor, true>(Ctx) {}
713 
714   void visitARCStrong(QualType QT, const FieldDecl *FD,
715                       CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
716     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
717     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
718     LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
719     llvm::Value *SrcVal =
720         CGF->EmitLoadOfLValue(SrcLV, SourceLocation()).getScalarVal();
721     CGF->EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress(*CGF)), SrcLV);
722     CGF->EmitStoreOfScalar(SrcVal, CGF->MakeAddrLValue(Addrs[DstIdx], QT),
723                            /* isInitialization */ true);
724   }
725 
726   void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
727                     std::array<Address, 2> Addrs) {
728     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
729     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
730     CGF->EmitARCMoveWeak(Addrs[DstIdx], Addrs[SrcIdx]);
731   }
732 
733   void callSpecialFunction(QualType FT, CharUnits Offset,
734                            std::array<Address, 2> Addrs) {
735     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
736     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
737     CGF->callCStructMoveConstructor(CGF->MakeAddrLValue(Addrs[DstIdx], FT),
738                                     CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
739   }
740 };
741 
742 struct GenCopyAssignment : GenBinaryFunc<GenCopyAssignment, false> {
743   GenCopyAssignment(ASTContext &Ctx)
744       : GenBinaryFunc<GenCopyAssignment, false>(Ctx) {}
745 
746   void visitARCStrong(QualType QT, const FieldDecl *FD,
747                       CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
748     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
749     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
750     llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
751         Addrs[SrcIdx], QT.isVolatileQualified(), QT, SourceLocation());
752     CGF->EmitARCStoreStrong(CGF->MakeAddrLValue(Addrs[DstIdx], QT), SrcVal,
753                             false);
754   }
755 
756   void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
757                     std::array<Address, 2> Addrs) {
758     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
759     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
760     CGF->emitARCCopyAssignWeak(QT, Addrs[DstIdx], Addrs[SrcIdx]);
761   }
762 
763   void callSpecialFunction(QualType FT, CharUnits Offset,
764                            std::array<Address, 2> Addrs) {
765     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
766     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
767     CGF->callCStructCopyAssignmentOperator(
768         CGF->MakeAddrLValue(Addrs[DstIdx], FT),
769         CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
770   }
771 };
772 
773 struct GenMoveAssignment : GenBinaryFunc<GenMoveAssignment, true> {
774   GenMoveAssignment(ASTContext &Ctx)
775       : GenBinaryFunc<GenMoveAssignment, true>(Ctx) {}
776 
777   void visitARCStrong(QualType QT, const FieldDecl *FD,
778                       CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
779     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
780     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
781     LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
782     llvm::Value *SrcVal =
783         CGF->EmitLoadOfLValue(SrcLV, SourceLocation()).getScalarVal();
784     CGF->EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress(*CGF)), SrcLV);
785     LValue DstLV = CGF->MakeAddrLValue(Addrs[DstIdx], QT);
786     llvm::Value *DstVal =
787         CGF->EmitLoadOfLValue(DstLV, SourceLocation()).getScalarVal();
788     CGF->EmitStoreOfScalar(SrcVal, DstLV);
789     CGF->EmitARCRelease(DstVal, ARCImpreciseLifetime);
790   }
791 
792   void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
793                     std::array<Address, 2> Addrs) {
794     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
795     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
796     CGF->emitARCMoveAssignWeak(QT, Addrs[DstIdx], Addrs[SrcIdx]);
797   }
798 
799   void callSpecialFunction(QualType FT, CharUnits Offset,
800                            std::array<Address, 2> Addrs) {
801     Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
802     Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
803     CGF->callCStructMoveAssignmentOperator(
804         CGF->MakeAddrLValue(Addrs[DstIdx], FT),
805         CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
806   }
807 };
808 
809 } // namespace
810 
811 void CodeGenFunction::destroyNonTrivialCStruct(CodeGenFunction &CGF,
812                                                Address Addr, QualType Type) {
813   CGF.callCStructDestructor(CGF.MakeAddrLValue(Addr, Type));
814 }
815 
816 // Default-initialize a variable that is a non-trivial struct or an array of
817 // such structure.
818 void CodeGenFunction::defaultInitNonTrivialCStructVar(LValue Dst) {
819   GenDefaultInitialize Gen(getContext());
820   Address DstPtr =
821       Builder.CreateElementBitCast(Dst.getAddress(*this), CGM.Int8PtrTy);
822   Gen.setCGF(this);
823   QualType QT = Dst.getType();
824   QT = Dst.isVolatile() ? QT.withVolatile() : QT;
825   Gen.visit(QT, nullptr, CharUnits::Zero(), std::array<Address, 1>({{DstPtr}}));
826 }
827 
828 template <class G, size_t N>
829 static void callSpecialFunction(G &&Gen, StringRef FuncName, QualType QT,
830                                 bool IsVolatile, CodeGenFunction &CGF,
831                                 std::array<Address, N> Addrs) {
832   auto SetArtificialLoc = ApplyDebugLocation::CreateArtificial(CGF);
833   for (unsigned I = 0; I < N; ++I)
834     Addrs[I] = CGF.Builder.CreateElementBitCast(Addrs[I], CGF.CGM.Int8PtrTy);
835   QT = IsVolatile ? QT.withVolatile() : QT;
836   Gen.callFunc(FuncName, QT, Addrs, CGF);
837 }
838 
839 template <class G, size_t N>
840 static llvm::Function *
841 getSpecialFunction(G &&Gen, StringRef FuncName, QualType QT, bool IsVolatile,
842                    std::array<CharUnits, N> Alignments, CodeGenModule &CGM) {
843   QT = IsVolatile ? QT.withVolatile() : QT;
844   // The following call requires an array of addresses as arguments, but doesn't
845   // actually use them (it overwrites them with the addresses of the arguments
846   // of the created function).
847   return Gen.getFunction(FuncName, QT, Alignments, CGM);
848 }
849 
850 // Functions to emit calls to the special functions of a non-trivial C struct.
851 void CodeGenFunction::callCStructDefaultConstructor(LValue Dst) {
852   bool IsVolatile = Dst.isVolatile();
853   Address DstPtr = Dst.getAddress(*this);
854   QualType QT = Dst.getType();
855   GenDefaultInitializeFuncName GenName(DstPtr.getAlignment(), getContext());
856   std::string FuncName = GenName.getName(QT, IsVolatile);
857   callSpecialFunction(GenDefaultInitialize(getContext()), FuncName, QT,
858                       IsVolatile, *this, std::array<Address, 1>({{DstPtr}}));
859 }
860 
861 std::string CodeGenFunction::getNonTrivialCopyConstructorStr(
862     QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx) {
863   GenBinaryFuncName<false> GenName("", Alignment, Alignment, Ctx);
864   return GenName.getName(QT, IsVolatile);
865 }
866 
867 std::string CodeGenFunction::getNonTrivialDestructorStr(QualType QT,
868                                                         CharUnits Alignment,
869                                                         bool IsVolatile,
870                                                         ASTContext &Ctx) {
871   GenDestructorFuncName GenName("", Alignment, Ctx);
872   return GenName.getName(QT, IsVolatile);
873 }
874 
875 void CodeGenFunction::callCStructDestructor(LValue Dst) {
876   bool IsVolatile = Dst.isVolatile();
877   Address DstPtr = Dst.getAddress(*this);
878   QualType QT = Dst.getType();
879   GenDestructorFuncName GenName("__destructor_", DstPtr.getAlignment(),
880                                 getContext());
881   std::string FuncName = GenName.getName(QT, IsVolatile);
882   callSpecialFunction(GenDestructor(getContext()), FuncName, QT, IsVolatile,
883                       *this, std::array<Address, 1>({{DstPtr}}));
884 }
885 
886 void CodeGenFunction::callCStructCopyConstructor(LValue Dst, LValue Src) {
887   bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
888   Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
889   QualType QT = Dst.getType();
890   GenBinaryFuncName<false> GenName("__copy_constructor_", DstPtr.getAlignment(),
891                                    SrcPtr.getAlignment(), getContext());
892   std::string FuncName = GenName.getName(QT, IsVolatile);
893   callSpecialFunction(GenCopyConstructor(getContext()), FuncName, QT,
894                       IsVolatile, *this,
895                       std::array<Address, 2>({{DstPtr, SrcPtr}}));
896 }
897 
898 void CodeGenFunction::callCStructCopyAssignmentOperator(LValue Dst, LValue Src
899 
900 ) {
901   bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
902   Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
903   QualType QT = Dst.getType();
904   GenBinaryFuncName<false> GenName("__copy_assignment_", DstPtr.getAlignment(),
905                                    SrcPtr.getAlignment(), getContext());
906   std::string FuncName = GenName.getName(QT, IsVolatile);
907   callSpecialFunction(GenCopyAssignment(getContext()), FuncName, QT, IsVolatile,
908                       *this, std::array<Address, 2>({{DstPtr, SrcPtr}}));
909 }
910 
911 void CodeGenFunction::callCStructMoveConstructor(LValue Dst, LValue Src) {
912   bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
913   Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
914   QualType QT = Dst.getType();
915   GenBinaryFuncName<true> GenName("__move_constructor_", DstPtr.getAlignment(),
916                                   SrcPtr.getAlignment(), getContext());
917   std::string FuncName = GenName.getName(QT, IsVolatile);
918   callSpecialFunction(GenMoveConstructor(getContext()), FuncName, QT,
919                       IsVolatile, *this,
920                       std::array<Address, 2>({{DstPtr, SrcPtr}}));
921 }
922 
923 void CodeGenFunction::callCStructMoveAssignmentOperator(LValue Dst, LValue Src
924 
925 ) {
926   bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
927   Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
928   QualType QT = Dst.getType();
929   GenBinaryFuncName<true> GenName("__move_assignment_", DstPtr.getAlignment(),
930                                   SrcPtr.getAlignment(), getContext());
931   std::string FuncName = GenName.getName(QT, IsVolatile);
932   callSpecialFunction(GenMoveAssignment(getContext()), FuncName, QT, IsVolatile,
933                       *this, std::array<Address, 2>({{DstPtr, SrcPtr}}));
934 }
935 
936 llvm::Function *clang::CodeGen::getNonTrivialCStructDefaultConstructor(
937     CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
938   ASTContext &Ctx = CGM.getContext();
939   GenDefaultInitializeFuncName GenName(DstAlignment, Ctx);
940   std::string FuncName = GenName.getName(QT, IsVolatile);
941   return getSpecialFunction(GenDefaultInitialize(Ctx), FuncName, QT, IsVolatile,
942                             std::array<CharUnits, 1>({{DstAlignment}}), CGM);
943 }
944 
945 llvm::Function *clang::CodeGen::getNonTrivialCStructCopyConstructor(
946     CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
947     bool IsVolatile, QualType QT) {
948   ASTContext &Ctx = CGM.getContext();
949   GenBinaryFuncName<false> GenName("__copy_constructor_", DstAlignment,
950                                    SrcAlignment, Ctx);
951   std::string FuncName = GenName.getName(QT, IsVolatile);
952   return getSpecialFunction(
953       GenCopyConstructor(Ctx), FuncName, QT, IsVolatile,
954       std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
955 }
956 
957 llvm::Function *clang::CodeGen::getNonTrivialCStructMoveConstructor(
958     CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
959     bool IsVolatile, QualType QT) {
960   ASTContext &Ctx = CGM.getContext();
961   GenBinaryFuncName<true> GenName("__move_constructor_", DstAlignment,
962                                   SrcAlignment, Ctx);
963   std::string FuncName = GenName.getName(QT, IsVolatile);
964   return getSpecialFunction(
965       GenMoveConstructor(Ctx), FuncName, QT, IsVolatile,
966       std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
967 }
968 
969 llvm::Function *clang::CodeGen::getNonTrivialCStructCopyAssignmentOperator(
970     CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
971     bool IsVolatile, QualType QT) {
972   ASTContext &Ctx = CGM.getContext();
973   GenBinaryFuncName<false> GenName("__copy_assignment_", DstAlignment,
974                                    SrcAlignment, Ctx);
975   std::string FuncName = GenName.getName(QT, IsVolatile);
976   return getSpecialFunction(
977       GenCopyAssignment(Ctx), FuncName, QT, IsVolatile,
978       std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
979 }
980 
981 llvm::Function *clang::CodeGen::getNonTrivialCStructMoveAssignmentOperator(
982     CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
983     bool IsVolatile, QualType QT) {
984   ASTContext &Ctx = CGM.getContext();
985   GenBinaryFuncName<true> GenName("__move_assignment_", DstAlignment,
986                                   SrcAlignment, Ctx);
987   std::string FuncName = GenName.getName(QT, IsVolatile);
988   return getSpecialFunction(
989       GenMoveAssignment(Ctx), FuncName, QT, IsVolatile,
990       std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
991 }
992 
993 llvm::Function *clang::CodeGen::getNonTrivialCStructDestructor(
994     CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
995   ASTContext &Ctx = CGM.getContext();
996   GenDestructorFuncName GenName("__destructor_", DstAlignment, Ctx);
997   std::string FuncName = GenName.getName(QT, IsVolatile);
998   return getSpecialFunction(GenDestructor(Ctx), FuncName, QT, IsVolatile,
999                             std::array<CharUnits, 1>({{DstAlignment}}), CGM);
1000 }
1001