File: | build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/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 |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
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")::llvm::llvm_unreachable_internal("field of a C++ struct type is not expected" , "clang/lib/CodeGen/CGNonTrivialStruct.cpp", 56); | |||
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")(static_cast <bool> (!FT.isVolatileQualified() && "volatile field not expected") ? void (0) : __assert_fail ("!FT.isVolatileQualified() && \"volatile field not expected\"" , "clang/lib/CodeGen/CGNonTrivialStruct.cpp", 109, __extension__ __PRETTY_FUNCTION__)); | |||
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")(static_cast <bool> (Addr.isValid() && "invalid address" ) ? void (0) : __assert_fail ("Addr.isValid() && \"invalid address\"" , "clang/lib/CodeGen/CGNonTrivialStruct.cpp", 426, __extension__ __PRETTY_FUNCTION__)); | |||
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
| |||
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 | } |