Bug Summary

File:clang/lib/CodeGen/CGNonTrivialStruct.cpp
Warning:line 483, column 5
Address of stack memory associated with local variable 'NewCGF' is still referred to by a temporary object on the stack upon returning to the caller. This will be a dangling reference

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGNonTrivialStruct.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/CodeGen -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/CodeGen/CGNonTrivialStruct.cpp
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
21using namespace clang;
22using namespace CodeGen;
23
24// Return the size of a field in number of bits.
25static 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
32namespace {
33enum { DstIdx = 0, SrcIdx = 1 };
34const char *ValNameStr[2] = {"dst", "src"};
35
36template <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")__builtin_unreachable();
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
77template <class Derived, bool IsMove>
78struct 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")(static_cast<void> (0));
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
150template <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
218template <class Derived>
219struct 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.
228static llvm::Constant *getNullForVariable(Address Addr) {
229 llvm::Type *Ty = Addr.getElementType();
230 return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(Ty));
231}
232
233template <bool IsMove>
234struct 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
270struct 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
288struct 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.
306template <size_t N>
307static 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
324template <size_t N, size_t... Ints>
325static 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 Alignments[Ints])...}};
332}
333
334// Template classes that are used as bases for classes that emit special
335// functions.
336template <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.CreateBitCast(DstAddr, CGF.CGM.Int8PtrTy);
370 llvm::Value *DstArrayEnd =
371 CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, BC.getPointer(), SizeInBytes);
372 DstArrayEnd = CGF.Builder.CreateBitCast(DstArrayEnd, CGF.CGM.Int8PtrPtrTy,
373 "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] = Address(
404 PHIs[I], 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")(static_cast<void> (0));
427 if (Offset.getQuantity() == 0)
428 return Addr;
429 Addr = CGF->Builder.CreateBitCast(Addr, CGF->CGM.Int8PtrTy);
430 Addr = CGF->Builder.CreateConstInBoundsGEP(Addr, Offset.getQuantity());
431 return CGF->Builder.CreateBitCast(Addr, CGF->CGM.Int8PtrPtrTy);
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)) {
4
Assuming 'F' is null
5
Taking false branch
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;
6
Address of stack memory associated with local variable 'NewCGF' is still referred to by a temporary object on the stack upon returning to the caller. This will be a dangling reference
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] =
495 CallerCGF.Builder.CreateBitCast(Addrs[I], CallerCGF.CGM.Int8PtrPtrTy)
496 .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
511template <class Derived, bool IsMove>
512struct 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::PointerType *PtrTy = this->CGF->ConvertType(RT)->getPointerTo();
558 Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], Offset);
559 LValue DstBase = this->CGF->MakeAddrLValue(
560 this->CGF->Builder.CreateBitCast(DstAddr, PtrTy), 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.CreateBitCast(SrcAddr, PtrTy), FT);
565 SrcLV = this->CGF->EmitLValueForField(SrcBase, FD);
566 } else {
567 llvm::PointerType *Ty = this->CGF->ConvertTypeForMem(FT)->getPointerTo();
568 Address DstAddr = this->CGF->Builder.CreateBitCast(Addrs[DstIdx], Ty);
569 Address SrcAddr = this->CGF->Builder.CreateBitCast(Addrs[SrcIdx], Ty);
570 DstLV = this->CGF->MakeAddrLValue(DstAddr, FT);
571 SrcLV = this->CGF->MakeAddrLValue(SrcAddr, FT);
572 }
573 RValue SrcVal = this->CGF->EmitLoadOfLValue(SrcLV, SourceLocation());
574 this->CGF->EmitStoreThroughLValue(SrcVal, DstLV);
575 }
576};
577
578// These classes that emit the special functions for a non-trivial struct.
579struct GenDestructor : StructVisitor<GenDestructor>,
580 GenFuncBase<GenDestructor>,
581 DestructedTypeVisitor<GenDestructor> {
582 using Super = DestructedTypeVisitor<GenDestructor>;
583 GenDestructor(ASTContext &Ctx) : StructVisitor<GenDestructor>(Ctx) {}
584
585 void visitWithKind(QualType::DestructionKind DK, QualType FT,
586 const FieldDecl *FD, CharUnits CurStructOffset,
587 std::array<Address, 1> Addrs) {
588 if (const auto *AT = getContext().getAsArrayType(FT)) {
589 visitArray(DK, AT, FT.isVolatileQualified(), FD, CurStructOffset, Addrs);
590 return;
591 }
592
593 Super::visitWithKind(DK, FT, FD, CurStructOffset, Addrs);
594 }
595
596 void visitARCStrong(QualType QT, const FieldDecl *FD,
597 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
598 CGF->destroyARCStrongImprecise(
599 *CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
600 }
601
602 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
603 std::array<Address, 1> Addrs) {
604 CGF->destroyARCWeak(
605 *CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
606 }
607
608 void callSpecialFunction(QualType FT, CharUnits Offset,
609 std::array<Address, 1> Addrs) {
610 CGF->callCStructDestructor(
611 CGF->MakeAddrLValue(getAddrWithOffset(Addrs[DstIdx], Offset), FT));
612 }
613};
614
615struct GenDefaultInitialize
616 : StructVisitor<GenDefaultInitialize>,
617 GenFuncBase<GenDefaultInitialize>,
618 DefaultInitializedTypeVisitor<GenDefaultInitialize> {
619 using Super = DefaultInitializedTypeVisitor<GenDefaultInitialize>;
620 typedef GenFuncBase<GenDefaultInitialize> GenFuncBaseTy;
621
622 GenDefaultInitialize(ASTContext &Ctx)
623 : StructVisitor<GenDefaultInitialize>(Ctx) {}
624
625 void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
626 const FieldDecl *FD, CharUnits CurStructOffset,
627 std::array<Address, 1> Addrs) {
628 if (const auto *AT = getContext().getAsArrayType(FT)) {
629 visitArray(PDIK, AT, FT.isVolatileQualified(), FD, CurStructOffset,
630 Addrs);
631 return;
632 }
633
634 Super::visitWithKind(PDIK, FT, FD, CurStructOffset, Addrs);
635 }
636
637 void visitARCStrong(QualType QT, const FieldDecl *FD,
638 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
639 CGF->EmitNullInitialization(
640 getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
641 }
642
643 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
644 std::array<Address, 1> Addrs) {
645 CGF->EmitNullInitialization(
646 getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
647 }
648
649 template <class FieldKind, size_t... Is>
650 void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
651 const FieldDecl *FD, CharUnits CurStructOffset,
652 std::array<Address, 1> Addrs) {
653 if (!FK)
654 return visitTrivial(QualType(AT, 0), FD, CurStructOffset, Addrs);
655
656 ASTContext &Ctx = getContext();
657 CharUnits Size = Ctx.getTypeSizeInChars(QualType(AT, 0));
658 QualType EltTy = Ctx.getBaseElementType(QualType(AT, 0));
659
660 if (Size < CharUnits::fromQuantity(16) || EltTy->getAs<RecordType>()) {
661 GenFuncBaseTy::visitArray(FK, AT, IsVolatile, FD, CurStructOffset, Addrs);
662 return;
663 }
664
665 llvm::Constant *SizeVal = CGF->Builder.getInt64(Size.getQuantity());
666 Address DstAddr = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
667 Address Loc = CGF->Builder.CreateElementBitCast(DstAddr, CGF->Int8Ty);
668 CGF->Builder.CreateMemSet(Loc, CGF->Builder.getInt8(0), SizeVal,
669 IsVolatile);
670 }
671
672 void callSpecialFunction(QualType FT, CharUnits Offset,
673 std::array<Address, 1> Addrs) {
674 CGF->callCStructDefaultConstructor(
675 CGF->MakeAddrLValue(getAddrWithOffset(Addrs[DstIdx], Offset), FT));
676 }
677};
678
679struct GenCopyConstructor : GenBinaryFunc<GenCopyConstructor, false> {
680 GenCopyConstructor(ASTContext &Ctx)
681 : GenBinaryFunc<GenCopyConstructor, false>(Ctx) {}
682
683 void visitARCStrong(QualType QT, const FieldDecl *FD,
684 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
685 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
686 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
687 llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
688 Addrs[SrcIdx], QT.isVolatileQualified(), QT, SourceLocation());
689 llvm::Value *Val = CGF->EmitARCRetain(QT, SrcVal);
690 CGF->EmitStoreOfScalar(Val, CGF->MakeAddrLValue(Addrs[DstIdx], QT), true);
691 }
692
693 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
694 std::array<Address, 2> Addrs) {
695 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
696 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
697 CGF->EmitARCCopyWeak(Addrs[DstIdx], Addrs[SrcIdx]);
698 }
699
700 void callSpecialFunction(QualType FT, CharUnits Offset,
701 std::array<Address, 2> Addrs) {
702 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
703 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
704 CGF->callCStructCopyConstructor(CGF->MakeAddrLValue(Addrs[DstIdx], FT),
705 CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
706 }
707};
708
709struct GenMoveConstructor : GenBinaryFunc<GenMoveConstructor, true> {
710 GenMoveConstructor(ASTContext &Ctx)
711 : GenBinaryFunc<GenMoveConstructor, true>(Ctx) {}
712
713 void visitARCStrong(QualType QT, const FieldDecl *FD,
714 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
715 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
716 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
717 LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
718 llvm::Value *SrcVal =
719 CGF->EmitLoadOfLValue(SrcLV, SourceLocation()).getScalarVal();
720 CGF->EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress(*CGF)), SrcLV);
721 CGF->EmitStoreOfScalar(SrcVal, CGF->MakeAddrLValue(Addrs[DstIdx], QT),
722 /* isInitialization */ true);
723 }
724
725 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
726 std::array<Address, 2> Addrs) {
727 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
728 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
729 CGF->EmitARCMoveWeak(Addrs[DstIdx], Addrs[SrcIdx]);
730 }
731
732 void callSpecialFunction(QualType FT, CharUnits Offset,
733 std::array<Address, 2> Addrs) {
734 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
735 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
736 CGF->callCStructMoveConstructor(CGF->MakeAddrLValue(Addrs[DstIdx], FT),
737 CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
738 }
739};
740
741struct GenCopyAssignment : GenBinaryFunc<GenCopyAssignment, false> {
742 GenCopyAssignment(ASTContext &Ctx)
743 : GenBinaryFunc<GenCopyAssignment, false>(Ctx) {}
744
745 void visitARCStrong(QualType QT, const FieldDecl *FD,
746 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
747 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
748 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
749 llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
750 Addrs[SrcIdx], QT.isVolatileQualified(), QT, SourceLocation());
751 CGF->EmitARCStoreStrong(CGF->MakeAddrLValue(Addrs[DstIdx], QT), SrcVal,
752 false);
753 }
754
755 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
756 std::array<Address, 2> Addrs) {
757 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
758 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
759 CGF->emitARCCopyAssignWeak(QT, Addrs[DstIdx], Addrs[SrcIdx]);
760 }
761
762 void callSpecialFunction(QualType FT, CharUnits Offset,
763 std::array<Address, 2> Addrs) {
764 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
765 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
766 CGF->callCStructCopyAssignmentOperator(
767 CGF->MakeAddrLValue(Addrs[DstIdx], FT),
768 CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
769 }
770};
771
772struct GenMoveAssignment : GenBinaryFunc<GenMoveAssignment, true> {
773 GenMoveAssignment(ASTContext &Ctx)
774 : GenBinaryFunc<GenMoveAssignment, true>(Ctx) {}
775
776 void visitARCStrong(QualType QT, const FieldDecl *FD,
777 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
778 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
779 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
780 LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
781 llvm::Value *SrcVal =
782 CGF->EmitLoadOfLValue(SrcLV, SourceLocation()).getScalarVal();
783 CGF->EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress(*CGF)), SrcLV);
784 LValue DstLV = CGF->MakeAddrLValue(Addrs[DstIdx], QT);
785 llvm::Value *DstVal =
786 CGF->EmitLoadOfLValue(DstLV, SourceLocation()).getScalarVal();
787 CGF->EmitStoreOfScalar(SrcVal, DstLV);
788 CGF->EmitARCRelease(DstVal, ARCImpreciseLifetime);
789 }
790
791 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
792 std::array<Address, 2> Addrs) {
793 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
794 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
795 CGF->emitARCMoveAssignWeak(QT, Addrs[DstIdx], Addrs[SrcIdx]);
796 }
797
798 void callSpecialFunction(QualType FT, CharUnits Offset,
799 std::array<Address, 2> Addrs) {
800 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
801 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
802 CGF->callCStructMoveAssignmentOperator(
803 CGF->MakeAddrLValue(Addrs[DstIdx], FT),
804 CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
805 }
806};
807
808} // namespace
809
810void CodeGenFunction::destroyNonTrivialCStruct(CodeGenFunction &CGF,
811 Address Addr, QualType Type) {
812 CGF.callCStructDestructor(CGF.MakeAddrLValue(Addr, Type));
813}
814
815// Default-initialize a variable that is a non-trivial struct or an array of
816// such structure.
817void CodeGenFunction::defaultInitNonTrivialCStructVar(LValue Dst) {
818 GenDefaultInitialize Gen(getContext());
819 Address DstPtr =
820 Builder.CreateBitCast(Dst.getAddress(*this), CGM.Int8PtrPtrTy);
821 Gen.setCGF(this);
822 QualType QT = Dst.getType();
823 QT = Dst.isVolatile() ? QT.withVolatile() : QT;
824 Gen.visit(QT, nullptr, CharUnits::Zero(), std::array<Address, 1>({{DstPtr}}));
825}
826
827template <class G, size_t N>
828static void callSpecialFunction(G &&Gen, StringRef FuncName, QualType QT,
829 bool IsVolatile, CodeGenFunction &CGF,
830 std::array<Address, N> Addrs) {
831 auto SetArtificialLoc = ApplyDebugLocation::CreateArtificial(CGF);
832 for (unsigned I = 0; I < N; ++I)
833 Addrs[I] = CGF.Builder.CreateBitCast(Addrs[I], CGF.CGM.Int8PtrPtrTy);
834 QT = IsVolatile ? QT.withVolatile() : QT;
835 Gen.callFunc(FuncName, QT, Addrs, CGF);
836}
837
838template <class G, size_t N>
839static llvm::Function *
840getSpecialFunction(G &&Gen, StringRef FuncName, QualType QT, bool IsVolatile,
841 std::array<CharUnits, N> Alignments, CodeGenModule &CGM) {
842 QT = IsVolatile
1.1
'IsVolatile' is false
? QT.withVolatile() : QT;
2
'?' condition is false
843 // The following call requires an array of addresses as arguments, but doesn't
844 // actually use them (it overwrites them with the addresses of the arguments
845 // of the created function).
846 return Gen.getFunction(FuncName, QT, Alignments, CGM);
3
Calling 'GenFuncBase::getFunction'
847}
848
849// Functions to emit calls to the special functions of a non-trivial C struct.
850void CodeGenFunction::callCStructDefaultConstructor(LValue Dst) {
851 bool IsVolatile = Dst.isVolatile();
852 Address DstPtr = Dst.getAddress(*this);
853 QualType QT = Dst.getType();
854 GenDefaultInitializeFuncName GenName(DstPtr.getAlignment(), getContext());
855 std::string FuncName = GenName.getName(QT, IsVolatile);
856 callSpecialFunction(GenDefaultInitialize(getContext()), FuncName, QT,
857 IsVolatile, *this, std::array<Address, 1>({{DstPtr}}));
858}
859
860std::string CodeGenFunction::getNonTrivialCopyConstructorStr(
861 QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx) {
862 GenBinaryFuncName<false> GenName("", Alignment, Alignment, Ctx);
863 return GenName.getName(QT, IsVolatile);
864}
865
866std::string CodeGenFunction::getNonTrivialDestructorStr(QualType QT,
867 CharUnits Alignment,
868 bool IsVolatile,
869 ASTContext &Ctx) {
870 GenDestructorFuncName GenName("", Alignment, Ctx);
871 return GenName.getName(QT, IsVolatile);
872}
873
874void CodeGenFunction::callCStructDestructor(LValue Dst) {
875 bool IsVolatile = Dst.isVolatile();
876 Address DstPtr = Dst.getAddress(*this);
877 QualType QT = Dst.getType();
878 GenDestructorFuncName GenName("__destructor_", DstPtr.getAlignment(),
879 getContext());
880 std::string FuncName = GenName.getName(QT, IsVolatile);
881 callSpecialFunction(GenDestructor(getContext()), FuncName, QT, IsVolatile,
882 *this, std::array<Address, 1>({{DstPtr}}));
883}
884
885void CodeGenFunction::callCStructCopyConstructor(LValue Dst, LValue Src) {
886 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
887 Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
888 QualType QT = Dst.getType();
889 GenBinaryFuncName<false> GenName("__copy_constructor_", DstPtr.getAlignment(),
890 SrcPtr.getAlignment(), getContext());
891 std::string FuncName = GenName.getName(QT, IsVolatile);
892 callSpecialFunction(GenCopyConstructor(getContext()), FuncName, QT,
893 IsVolatile, *this,
894 std::array<Address, 2>({{DstPtr, SrcPtr}}));
895}
896
897void CodeGenFunction::callCStructCopyAssignmentOperator(LValue Dst, LValue Src
898
899) {
900 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
901 Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
902 QualType QT = Dst.getType();
903 GenBinaryFuncName<false> GenName("__copy_assignment_", DstPtr.getAlignment(),
904 SrcPtr.getAlignment(), getContext());
905 std::string FuncName = GenName.getName(QT, IsVolatile);
906 callSpecialFunction(GenCopyAssignment(getContext()), FuncName, QT, IsVolatile,
907 *this, std::array<Address, 2>({{DstPtr, SrcPtr}}));
908}
909
910void CodeGenFunction::callCStructMoveConstructor(LValue Dst, LValue Src) {
911 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
912 Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
913 QualType QT = Dst.getType();
914 GenBinaryFuncName<true> GenName("__move_constructor_", DstPtr.getAlignment(),
915 SrcPtr.getAlignment(), getContext());
916 std::string FuncName = GenName.getName(QT, IsVolatile);
917 callSpecialFunction(GenMoveConstructor(getContext()), FuncName, QT,
918 IsVolatile, *this,
919 std::array<Address, 2>({{DstPtr, SrcPtr}}));
920}
921
922void CodeGenFunction::callCStructMoveAssignmentOperator(LValue Dst, LValue Src
923
924) {
925 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
926 Address DstPtr = Dst.getAddress(*this), SrcPtr = Src.getAddress(*this);
927 QualType QT = Dst.getType();
928 GenBinaryFuncName<true> GenName("__move_assignment_", DstPtr.getAlignment(),
929 SrcPtr.getAlignment(), getContext());
930 std::string FuncName = GenName.getName(QT, IsVolatile);
931 callSpecialFunction(GenMoveAssignment(getContext()), FuncName, QT, IsVolatile,
932 *this, std::array<Address, 2>({{DstPtr, SrcPtr}}));
933}
934
935llvm::Function *clang::CodeGen::getNonTrivialCStructDefaultConstructor(
936 CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
937 ASTContext &Ctx = CGM.getContext();
938 GenDefaultInitializeFuncName GenName(DstAlignment, Ctx);
939 std::string FuncName = GenName.getName(QT, IsVolatile);
940 return getSpecialFunction(GenDefaultInitialize(Ctx), FuncName, QT, IsVolatile,
941 std::array<CharUnits, 1>({{DstAlignment}}), CGM);
942}
943
944llvm::Function *clang::CodeGen::getNonTrivialCStructCopyConstructor(
945 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
946 bool IsVolatile, QualType QT) {
947 ASTContext &Ctx = CGM.getContext();
948 GenBinaryFuncName<false> GenName("__copy_constructor_", DstAlignment,
949 SrcAlignment, Ctx);
950 std::string FuncName = GenName.getName(QT, IsVolatile);
951 return getSpecialFunction(
952 GenCopyConstructor(Ctx), FuncName, QT, IsVolatile,
953 std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
954}
955
956llvm::Function *clang::CodeGen::getNonTrivialCStructMoveConstructor(
957 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
958 bool IsVolatile, QualType QT) {
959 ASTContext &Ctx = CGM.getContext();
960 GenBinaryFuncName<true> GenName("__move_constructor_", DstAlignment,
961 SrcAlignment, Ctx);
962 std::string FuncName = GenName.getName(QT, IsVolatile);
963 return getSpecialFunction(
964 GenMoveConstructor(Ctx), FuncName, QT, IsVolatile,
965 std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
966}
967
968llvm::Function *clang::CodeGen::getNonTrivialCStructCopyAssignmentOperator(
969 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
970 bool IsVolatile, QualType QT) {
971 ASTContext &Ctx = CGM.getContext();
972 GenBinaryFuncName<false> GenName("__copy_assignment_", DstAlignment,
973 SrcAlignment, Ctx);
974 std::string FuncName = GenName.getName(QT, IsVolatile);
975 return getSpecialFunction(
976 GenCopyAssignment(Ctx), FuncName, QT, IsVolatile,
977 std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
978}
979
980llvm::Function *clang::CodeGen::getNonTrivialCStructMoveAssignmentOperator(
981 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
982 bool IsVolatile, QualType QT) {
983 ASTContext &Ctx = CGM.getContext();
984 GenBinaryFuncName<true> GenName("__move_assignment_", DstAlignment,
985 SrcAlignment, Ctx);
986 std::string FuncName = GenName.getName(QT, IsVolatile);
987 return getSpecialFunction(
988 GenMoveAssignment(Ctx), FuncName, QT, IsVolatile,
989 std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
990}
991
992llvm::Function *clang::CodeGen::getNonTrivialCStructDestructor(
993 CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
994 ASTContext &Ctx = CGM.getContext();
995 GenDestructorFuncName GenName("__destructor_", DstAlignment, Ctx);
996 std::string FuncName = GenName.getName(QT, IsVolatile);
997 return getSpecialFunction(GenDestructor(Ctx), FuncName, QT, IsVolatile,
1
Calling 'getSpecialFunction<(anonymous namespace)::GenDestructor, 1UL>'
998 std::array<CharUnits, 1>({{DstAlignment}}), CGM);
999}