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