clang 19.0.0git
CGNonTrivialStruct.cpp
Go to the documentation of this file.
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"
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");
57 }
58
59 template <class... Ts> void flushTrivialFields(Ts... Args) {}
60
62 return FD ? Ctx.getASTRecordLayout(FD->getParent())
63 .getFieldOffset(FD->getFieldIndex())
64 : 0;
65 }
66
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;
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>
94 const FieldDecl *FD, CharUnits CurStructOffset,
95 Ts &&... Args) {
96 if (const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
97 asDerived().visitArray(PCK, AT, FT.isVolatileQualified(), FD,
98 CurStructOffset, std::forward<Ts>(Args)...);
99 return;
100 }
101
102 Super::visitWithKind(PCK, FT, FD, CurStructOffset,
103 std::forward<Ts>(Args)...);
104 }
105
106 template <class... Ts>
107 void visitTrivial(QualType FT, const FieldDecl *FD, CharUnits CurStructOffset,
108 Ts... Args) {
109 assert(!FT.isVolatileQualified() && "volatile field not expected");
110 ASTContext &Ctx = asDerived().getContext();
111 uint64_t FieldSize = getFieldSize(FD, FT, Ctx);
112
113 // Ignore zero-sized fields.
114 if (FieldSize == 0)
115 return;
116
117 uint64_t FStartInBits = asDerived().getFieldOffsetInBits(FD);
118 uint64_t FEndInBits = FStartInBits + FieldSize;
119 uint64_t RoundedFEnd = llvm::alignTo(FEndInBits, Ctx.getCharWidth());
120
121 // Set Start if this is the first field of a sequence of trivial fields.
122 if (Start == End)
123 Start = CurStructOffset + Ctx.toCharUnitsFromBits(FStartInBits);
124 End = CurStructOffset + Ctx.toCharUnitsFromBits(RoundedFEnd);
125 }
126
127 CharUnits Start = CharUnits::Zero(), End = CharUnits::Zero();
128};
129
130// This function creates the mangled name of a special function of a non-trivial
131// C struct. Since there is no ODR in C, the function is mangled based on the
132// struct contents and not the name. The mangled name has the following
133// structure:
134//
135// <function-name> ::= <prefix> <alignment-info> "_" <struct-field-info>
136// <prefix> ::= "__destructor_" | "__default_constructor_" |
137// "__copy_constructor_" | "__move_constructor_" |
138// "__copy_assignment_" | "__move_assignment_"
139// <alignment-info> ::= <dst-alignment> ["_" <src-alignment>]
140// <struct-field-info> ::= <field-info>+
141// <field-info> ::= <struct-or-scalar-field-info> | <array-field-info>
142// <struct-or-scalar-field-info> ::= "_S" <struct-field-info> |
143// <strong-field-info> | <trivial-field-info>
144// <array-field-info> ::= "_AB" <array-offset> "s" <element-size> "n"
145// <num-elements> <innermost-element-info> "_AE"
146// <innermost-element-info> ::= <struct-or-scalar-field-info>
147// <strong-field-info> ::= "_s" ["b"] ["v"] <field-offset>
148// <trivial-field-info> ::= "_t" ["v"] <field-offset> "_" <field-size>
149
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> {
274 GenDefaultInitializeFuncName(CharUnits DstAlignment, ASTContext &Ctx)
275 : GenUnaryFuncName<GenDefaultInitializeFuncName>("__default_constructor_",
276 DstAlignment, Ctx) {}
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> {
291 GenDestructorFuncName(const char *Prefix, CharUnits DstAlignment,
292 ASTContext &Ctx)
293 : GenUnaryFuncName<GenDestructorFuncName>(Prefix, DstAlignment, Ctx) {}
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();
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 ImplicitParamKind::Other));
317
318 llvm::append_range(Args, Params);
319
320 return CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args);
321}
322
323template <size_t N, size_t... Ints>
324static std::array<Address, N> getParamAddrs(std::index_sequence<Ints...> IntSeq,
325 std::array<CharUnits, N> Alignments,
326 const 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], KnownNonNull)...}};
331}
332
333// Template classes that are used as bases for classes that emit special
334// functions.
335template <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 llvm::Value *DstArrayEnd = CGF.Builder.CreateInBoundsGEP(
369 CGF.Int8Ty, DstAddr.emitRawPointer(CGF), SizeInBytes);
370 llvm::BasicBlock *PreheaderBB = CGF.Builder.GetInsertBlock();
371
372 // Create the header block and insert the phi instructions.
373 llvm::BasicBlock *HeaderBB = CGF.createBasicBlock("loop.header");
374 CGF.EmitBlock(HeaderBB);
375 llvm::PHINode *PHIs[N];
376
377 for (unsigned I = 0; I < N; ++I) {
378 PHIs[I] = CGF.Builder.CreatePHI(CGF.CGM.Int8PtrPtrTy, 2, "addr.cur");
379 PHIs[I]->addIncoming(StartAddrs[I].emitRawPointer(CGF), PreheaderBB);
380 }
381
382 // Create the exit and loop body blocks.
383 llvm::BasicBlock *ExitBB = CGF.createBasicBlock("loop.exit");
384 llvm::BasicBlock *LoopBB = CGF.createBasicBlock("loop.body");
385
386 // Emit the comparison and conditional branch instruction that jumps to
387 // either the exit or the loop body.
388 llvm::Value *Done =
389 CGF.Builder.CreateICmpEQ(PHIs[DstIdx], DstArrayEnd, "done");
390 CGF.Builder.CreateCondBr(Done, ExitBB, LoopBB);
391
392 // Visit the element of the array in the loop body.
393 CGF.EmitBlock(LoopBB);
394 QualType EltQT = AT->getElementType();
395 CharUnits EltSize = Ctx.getTypeSizeInChars(EltQT);
396 std::array<Address, N> NewAddrs = Addrs;
397
398 for (unsigned I = 0; I < N; ++I)
399 NewAddrs[I] =
400 Address(PHIs[I], CGF.Int8PtrTy,
401 StartAddrs[I].getAlignment().alignmentAtOffset(EltSize));
402
403 EltQT = IsVolatile ? EltQT.withVolatile() : EltQT;
404 this->asDerived().visitWithKind(FK, EltQT, nullptr, CharUnits::Zero(),
405 NewAddrs);
406
407 LoopBB = CGF.Builder.GetInsertBlock();
408
409 for (unsigned I = 0; I < N; ++I) {
410 // Instrs to update the destination and source addresses.
411 // Update phi instructions.
412 NewAddrs[I] = getAddrWithOffset(NewAddrs[I], EltSize);
413 PHIs[I]->addIncoming(NewAddrs[I].emitRawPointer(CGF), LoopBB);
414 }
415
416 // Insert an unconditional branch to the header block.
417 CGF.Builder.CreateBr(HeaderBB);
418 CGF.EmitBlock(ExitBB);
419 }
420
421 /// Return an address with the specified offset from the passed address.
422 Address getAddrWithOffset(Address Addr, CharUnits Offset) {
423 assert(Addr.isValid() && "invalid address");
424 if (Offset.getQuantity() == 0)
425 return Addr;
426 Addr = Addr.withElementType(CGF->CGM.Int8Ty);
427 Addr = CGF->Builder.CreateConstInBoundsGEP(Addr, Offset.getQuantity());
428 return Addr.withElementType(CGF->CGM.Int8PtrTy);
429 }
430
431 Address getAddrWithOffset(Address Addr, CharUnits StructFieldOffset,
432 const FieldDecl *FD) {
433 return getAddrWithOffset(Addr, StructFieldOffset +
434 asDerived().getFieldOffset(FD));
435 }
436
437 template <size_t N>
438 llvm::Function *getFunction(StringRef FuncName, QualType QT,
439 std::array<CharUnits, N> Alignments,
440 CodeGenModule &CGM) {
441 // If the special function already exists in the module, return it.
442 if (llvm::Function *F = CGM.getModule().getFunction(FuncName)) {
443 bool WrongType = false;
444 if (!F->getReturnType()->isVoidTy())
445 WrongType = true;
446 else {
447 for (const llvm::Argument &Arg : F->args())
448 if (Arg.getType() != CGM.Int8PtrPtrTy)
449 WrongType = true;
450 }
451
452 if (WrongType) {
453 std::string FuncName = std::string(F->getName());
454 SourceLocation Loc = QT->castAs<RecordType>()->getDecl()->getLocation();
455 CGM.Error(Loc, "special function " + FuncName +
456 " for non-trivial C struct has incorrect type");
457 return nullptr;
458 }
459 return F;
460 }
461
462 ASTContext &Ctx = CGM.getContext();
463 FunctionArgList Args;
464 const CGFunctionInfo &FI = getFunctionInfo<N>(CGM, Args);
465 llvm::FunctionType *FuncTy = CGM.getTypes().GetFunctionType(FI);
466 llvm::Function *F =
467 llvm::Function::Create(FuncTy, llvm::GlobalValue::LinkOnceODRLinkage,
468 FuncName, &CGM.getModule());
469 F->setVisibility(llvm::GlobalValue::HiddenVisibility);
470 CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, F, /*IsThunk=*/false);
472 CodeGenFunction NewCGF(CGM);
473 setCGF(&NewCGF);
474 CGF->StartFunction(GlobalDecl(), Ctx.VoidTy, F, FI, Args);
476 std::array<Address, N> Addrs =
477 getParamAddrs<N>(std::make_index_sequence<N>{}, Alignments, Args, CGF);
478 asDerived().visitStructFields(QT, CharUnits::Zero(), Addrs);
479 CGF->FinishFunction();
480 return F;
481 }
482
483 template <size_t N>
484 void callFunc(StringRef FuncName, QualType QT, std::array<Address, N> Addrs,
485 CodeGenFunction &CallerCGF) {
486 std::array<CharUnits, N> Alignments;
487 llvm::Value *Ptrs[N];
488
489 for (unsigned I = 0; I < N; ++I) {
490 Alignments[I] = Addrs[I].getAlignment();
491 Ptrs[I] = Addrs[I].emitRawPointer(CallerCGF);
492 }
493
494 if (llvm::Function *F =
495 getFunction(FuncName, QT, Alignments, CallerCGF.CGM))
496 CallerCGF.EmitNounwindRuntimeCall(F, Ptrs);
497 }
498
499 Derived &asDerived() { return static_cast<Derived &>(*this); }
500
501 void setCGF(CodeGenFunction *F) { CGF = F; }
502
503 CodeGenFunction *CGF = nullptr;
504};
505
506template <class Derived, bool IsMove>
507struct GenBinaryFunc : CopyStructVisitor<Derived, IsMove>,
508 GenFuncBase<Derived> {
509 GenBinaryFunc(ASTContext &Ctx) : CopyStructVisitor<Derived, IsMove>(Ctx) {}
510
511 void flushTrivialFields(std::array<Address, 2> Addrs) {
512 CharUnits Size = this->End - this->Start;
513
514 if (Size.getQuantity() == 0)
515 return;
516
517 Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], this->Start);
518 Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], this->Start);
519
520 // Emit memcpy.
521 if (Size.getQuantity() >= 16 ||
522 !llvm::has_single_bit<uint32_t>(Size.getQuantity())) {
523 llvm::Value *SizeVal =
524 llvm::ConstantInt::get(this->CGF->SizeTy, Size.getQuantity());
525 DstAddr = DstAddr.withElementType(this->CGF->Int8Ty);
526 SrcAddr = SrcAddr.withElementType(this->CGF->Int8Ty);
527 this->CGF->Builder.CreateMemCpy(DstAddr, SrcAddr, SizeVal, false);
528 } else {
529 llvm::Type *Ty = llvm::Type::getIntNTy(
530 this->CGF->getLLVMContext(),
531 Size.getQuantity() * this->CGF->getContext().getCharWidth());
532 DstAddr = DstAddr.withElementType(Ty);
533 SrcAddr = SrcAddr.withElementType(Ty);
534 llvm::Value *SrcVal = this->CGF->Builder.CreateLoad(SrcAddr, false);
535 this->CGF->Builder.CreateStore(SrcVal, DstAddr, false);
536 }
537
538 this->Start = this->End = CharUnits::Zero();
539 }
540
541 template <class... Ts>
542 void visitVolatileTrivial(QualType FT, const FieldDecl *FD, CharUnits Offset,
543 std::array<Address, 2> Addrs) {
544 LValue DstLV, SrcLV;
545 if (FD) {
546 // No need to copy zero-length bit-fields.
547 if (FD->isZeroLengthBitField(this->CGF->getContext()))
548 return;
549
550 QualType RT = QualType(FD->getParent()->getTypeForDecl(), 0);
551 llvm::Type *Ty = this->CGF->ConvertType(RT);
552 Address DstAddr = this->getAddrWithOffset(Addrs[DstIdx], Offset);
553 LValue DstBase =
554 this->CGF->MakeAddrLValue(DstAddr.withElementType(Ty), FT);
555 DstLV = this->CGF->EmitLValueForField(DstBase, FD);
556 Address SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], Offset);
557 LValue SrcBase =
558 this->CGF->MakeAddrLValue(SrcAddr.withElementType(Ty), FT);
559 SrcLV = this->CGF->EmitLValueForField(SrcBase, FD);
560 } else {
561 llvm::Type *Ty = this->CGF->ConvertTypeForMem(FT);
562 Address DstAddr = Addrs[DstIdx].withElementType(Ty);
563 Address SrcAddr = Addrs[SrcIdx].withElementType(Ty);
564 DstLV = this->CGF->MakeAddrLValue(DstAddr, FT);
565 SrcLV = this->CGF->MakeAddrLValue(SrcAddr, FT);
566 }
567 RValue SrcVal = this->CGF->EmitLoadOfLValue(SrcLV, SourceLocation());
568 this->CGF->EmitStoreThroughLValue(SrcVal, DstLV);
569 }
570};
571
572// These classes that emit the special functions for a non-trivial struct.
573struct GenDestructor : StructVisitor<GenDestructor>,
574 GenFuncBase<GenDestructor>,
575 DestructedTypeVisitor<GenDestructor> {
577 GenDestructor(ASTContext &Ctx) : StructVisitor<GenDestructor>(Ctx) {}
578
580 const FieldDecl *FD, CharUnits CurStructOffset,
581 std::array<Address, 1> Addrs) {
582 if (const auto *AT = getContext().getAsArrayType(FT)) {
583 visitArray(DK, AT, FT.isVolatileQualified(), FD, CurStructOffset, Addrs);
584 return;
585 }
586
587 Super::visitWithKind(DK, FT, FD, CurStructOffset, Addrs);
588 }
589
590 void visitARCStrong(QualType QT, const FieldDecl *FD,
591 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
593 *CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
594 }
595
596 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
597 std::array<Address, 1> Addrs) {
598 CGF->destroyARCWeak(
599 *CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
600 }
601
602 void callSpecialFunction(QualType FT, CharUnits Offset,
603 std::array<Address, 1> Addrs) {
605 CGF->MakeAddrLValue(getAddrWithOffset(Addrs[DstIdx], Offset), FT));
606 }
607};
608
609struct GenDefaultInitialize
610 : StructVisitor<GenDefaultInitialize>,
611 GenFuncBase<GenDefaultInitialize>,
612 DefaultInitializedTypeVisitor<GenDefaultInitialize> {
614 typedef GenFuncBase<GenDefaultInitialize> GenFuncBaseTy;
615
616 GenDefaultInitialize(ASTContext &Ctx)
617 : StructVisitor<GenDefaultInitialize>(Ctx) {}
618
620 const FieldDecl *FD, CharUnits CurStructOffset,
621 std::array<Address, 1> Addrs) {
622 if (const auto *AT = getContext().getAsArrayType(FT)) {
623 visitArray(PDIK, AT, FT.isVolatileQualified(), FD, CurStructOffset,
624 Addrs);
625 return;
626 }
627
628 Super::visitWithKind(PDIK, FT, FD, CurStructOffset, Addrs);
629 }
630
631 void visitARCStrong(QualType QT, const FieldDecl *FD,
632 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
634 getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
635 }
636
637 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
638 std::array<Address, 1> Addrs) {
640 getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);
641 }
642
643 template <class FieldKind, size_t... Is>
644 void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
645 const FieldDecl *FD, CharUnits CurStructOffset,
646 std::array<Address, 1> Addrs) {
647 if (!FK)
648 return visitTrivial(QualType(AT, 0), FD, CurStructOffset, Addrs);
649
650 ASTContext &Ctx = getContext();
652 QualType EltTy = Ctx.getBaseElementType(QualType(AT, 0));
653
654 if (Size < CharUnits::fromQuantity(16) || EltTy->getAs<RecordType>()) {
655 GenFuncBaseTy::visitArray(FK, AT, IsVolatile, FD, CurStructOffset, Addrs);
656 return;
657 }
658
659 llvm::Constant *SizeVal = CGF->Builder.getInt64(Size.getQuantity());
660 Address DstAddr = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
661 Address Loc = DstAddr.withElementType(CGF->Int8Ty);
662 CGF->Builder.CreateMemSet(Loc, CGF->Builder.getInt8(0), SizeVal,
663 IsVolatile);
664 }
665
666 void callSpecialFunction(QualType FT, CharUnits Offset,
667 std::array<Address, 1> Addrs) {
669 CGF->MakeAddrLValue(getAddrWithOffset(Addrs[DstIdx], Offset), FT));
670 }
671};
672
673struct GenCopyConstructor : GenBinaryFunc<GenCopyConstructor, false> {
674 GenCopyConstructor(ASTContext &Ctx)
675 : GenBinaryFunc<GenCopyConstructor, false>(Ctx) {}
676
677 void visitARCStrong(QualType QT, const FieldDecl *FD,
678 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
679 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
680 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
681 llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
682 Addrs[SrcIdx], QT.isVolatileQualified(), QT, SourceLocation());
683 llvm::Value *Val = CGF->EmitARCRetain(QT, SrcVal);
684 CGF->EmitStoreOfScalar(Val, CGF->MakeAddrLValue(Addrs[DstIdx], QT), true);
685 }
686
687 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
688 std::array<Address, 2> Addrs) {
689 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
690 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
691 CGF->EmitARCCopyWeak(Addrs[DstIdx], Addrs[SrcIdx]);
692 }
693
694 void callSpecialFunction(QualType FT, CharUnits Offset,
695 std::array<Address, 2> Addrs) {
696 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
697 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
698 CGF->callCStructCopyConstructor(CGF->MakeAddrLValue(Addrs[DstIdx], FT),
699 CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
700 }
701};
702
703struct GenMoveConstructor : GenBinaryFunc<GenMoveConstructor, true> {
704 GenMoveConstructor(ASTContext &Ctx)
705 : GenBinaryFunc<GenMoveConstructor, true>(Ctx) {}
706
707 void visitARCStrong(QualType QT, const FieldDecl *FD,
708 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
709 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
710 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
711 LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
712 llvm::Value *SrcVal =
714 CGF->EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress()), SrcLV);
715 CGF->EmitStoreOfScalar(SrcVal, CGF->MakeAddrLValue(Addrs[DstIdx], QT),
716 /* isInitialization */ true);
717 }
718
719 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
720 std::array<Address, 2> Addrs) {
721 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
722 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
723 CGF->EmitARCMoveWeak(Addrs[DstIdx], Addrs[SrcIdx]);
724 }
725
726 void callSpecialFunction(QualType FT, CharUnits Offset,
727 std::array<Address, 2> Addrs) {
728 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
729 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
730 CGF->callCStructMoveConstructor(CGF->MakeAddrLValue(Addrs[DstIdx], FT),
731 CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
732 }
733};
734
735struct GenCopyAssignment : GenBinaryFunc<GenCopyAssignment, false> {
736 GenCopyAssignment(ASTContext &Ctx)
737 : GenBinaryFunc<GenCopyAssignment, false>(Ctx) {}
738
739 void visitARCStrong(QualType QT, const FieldDecl *FD,
740 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
741 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
742 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
743 llvm::Value *SrcVal = CGF->EmitLoadOfScalar(
744 Addrs[SrcIdx], QT.isVolatileQualified(), QT, SourceLocation());
745 CGF->EmitARCStoreStrong(CGF->MakeAddrLValue(Addrs[DstIdx], QT), SrcVal,
746 false);
747 }
748
749 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
750 std::array<Address, 2> Addrs) {
751 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
752 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
753 CGF->emitARCCopyAssignWeak(QT, Addrs[DstIdx], Addrs[SrcIdx]);
754 }
755
756 void callSpecialFunction(QualType FT, CharUnits Offset,
757 std::array<Address, 2> Addrs) {
758 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
759 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
761 CGF->MakeAddrLValue(Addrs[DstIdx], FT),
762 CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
763 }
764};
765
766struct GenMoveAssignment : GenBinaryFunc<GenMoveAssignment, true> {
767 GenMoveAssignment(ASTContext &Ctx)
768 : GenBinaryFunc<GenMoveAssignment, true>(Ctx) {}
769
770 void visitARCStrong(QualType QT, const FieldDecl *FD,
771 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
772 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
773 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
774 LValue SrcLV = CGF->MakeAddrLValue(Addrs[SrcIdx], QT);
775 llvm::Value *SrcVal =
777 CGF->EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress()), SrcLV);
778 LValue DstLV = CGF->MakeAddrLValue(Addrs[DstIdx], QT);
779 llvm::Value *DstVal =
781 CGF->EmitStoreOfScalar(SrcVal, DstLV);
783 }
784
785 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
786 std::array<Address, 2> Addrs) {
787 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);
788 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);
789 CGF->emitARCMoveAssignWeak(QT, Addrs[DstIdx], Addrs[SrcIdx]);
790 }
791
792 void callSpecialFunction(QualType FT, CharUnits Offset,
793 std::array<Address, 2> Addrs) {
794 Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);
795 Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);
797 CGF->MakeAddrLValue(Addrs[DstIdx], FT),
798 CGF->MakeAddrLValue(Addrs[SrcIdx], FT));
799 }
800};
801
802} // namespace
803
804void CodeGenFunction::destroyNonTrivialCStruct(CodeGenFunction &CGF,
805 Address Addr, QualType Type) {
807}
808
809// Default-initialize a variable that is a non-trivial struct or an array of
810// such structure.
812 GenDefaultInitialize Gen(getContext());
814 Gen.setCGF(this);
815 QualType QT = Dst.getType();
816 QT = Dst.isVolatile() ? QT.withVolatile() : QT;
817 Gen.visit(QT, nullptr, CharUnits::Zero(), std::array<Address, 1>({{DstPtr}}));
818}
819
820template <class G, size_t N>
821static void callSpecialFunction(G &&Gen, StringRef FuncName, QualType QT,
822 bool IsVolatile, CodeGenFunction &CGF,
823 std::array<Address, N> Addrs) {
824 auto SetArtificialLoc = ApplyDebugLocation::CreateArtificial(CGF);
825 for (unsigned I = 0; I < N; ++I)
826 Addrs[I] = Addrs[I].withElementType(CGF.CGM.Int8PtrTy);
827 QT = IsVolatile ? QT.withVolatile() : QT;
828 Gen.callFunc(FuncName, QT, Addrs, CGF);
829}
830
831template <class G, size_t N>
832static llvm::Function *
833getSpecialFunction(G &&Gen, StringRef FuncName, QualType QT, bool IsVolatile,
834 std::array<CharUnits, N> Alignments, CodeGenModule &CGM) {
835 QT = IsVolatile ? QT.withVolatile() : QT;
836 // The following call requires an array of addresses as arguments, but doesn't
837 // actually use them (it overwrites them with the addresses of the arguments
838 // of the created function).
839 return Gen.getFunction(FuncName, QT, Alignments, CGM);
840}
841
842// Functions to emit calls to the special functions of a non-trivial C struct.
844 bool IsVolatile = Dst.isVolatile();
845 Address DstPtr = Dst.getAddress();
846 QualType QT = Dst.getType();
847 GenDefaultInitializeFuncName GenName(DstPtr.getAlignment(), getContext());
848 std::string FuncName = GenName.getName(QT, IsVolatile);
849 callSpecialFunction(GenDefaultInitialize(getContext()), FuncName, QT,
850 IsVolatile, *this, std::array<Address, 1>({{DstPtr}}));
851}
852
854 QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx) {
855 GenBinaryFuncName<false> GenName("", Alignment, Alignment, Ctx);
856 return GenName.getName(QT, IsVolatile);
857}
858
860 CharUnits Alignment,
861 bool IsVolatile,
862 ASTContext &Ctx) {
863 GenDestructorFuncName GenName("", Alignment, Ctx);
864 return GenName.getName(QT, IsVolatile);
865}
866
868 bool IsVolatile = Dst.isVolatile();
869 Address DstPtr = Dst.getAddress();
870 QualType QT = Dst.getType();
871 GenDestructorFuncName GenName("__destructor_", DstPtr.getAlignment(),
872 getContext());
873 std::string FuncName = GenName.getName(QT, IsVolatile);
874 callSpecialFunction(GenDestructor(getContext()), FuncName, QT, IsVolatile,
875 *this, std::array<Address, 1>({{DstPtr}}));
876}
877
879 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
880 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
881 QualType QT = Dst.getType();
882 GenBinaryFuncName<false> GenName("__copy_constructor_", DstPtr.getAlignment(),
883 SrcPtr.getAlignment(), getContext());
884 std::string FuncName = GenName.getName(QT, IsVolatile);
885 callSpecialFunction(GenCopyConstructor(getContext()), FuncName, QT,
886 IsVolatile, *this,
887 std::array<Address, 2>({{DstPtr, SrcPtr}}));
888}
889
891
892) {
893 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
894 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
895 QualType QT = Dst.getType();
896 GenBinaryFuncName<false> GenName("__copy_assignment_", DstPtr.getAlignment(),
897 SrcPtr.getAlignment(), getContext());
898 std::string FuncName = GenName.getName(QT, IsVolatile);
899 callSpecialFunction(GenCopyAssignment(getContext()), FuncName, QT, IsVolatile,
900 *this, std::array<Address, 2>({{DstPtr, SrcPtr}}));
901}
902
904 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
905 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
906 QualType QT = Dst.getType();
907 GenBinaryFuncName<true> GenName("__move_constructor_", DstPtr.getAlignment(),
908 SrcPtr.getAlignment(), getContext());
909 std::string FuncName = GenName.getName(QT, IsVolatile);
910 callSpecialFunction(GenMoveConstructor(getContext()), FuncName, QT,
911 IsVolatile, *this,
912 std::array<Address, 2>({{DstPtr, SrcPtr}}));
913}
914
916
917) {
918 bool IsVolatile = Dst.isVolatile() || Src.isVolatile();
919 Address DstPtr = Dst.getAddress(), SrcPtr = Src.getAddress();
920 QualType QT = Dst.getType();
921 GenBinaryFuncName<true> GenName("__move_assignment_", DstPtr.getAlignment(),
922 SrcPtr.getAlignment(), getContext());
923 std::string FuncName = GenName.getName(QT, IsVolatile);
924 callSpecialFunction(GenMoveAssignment(getContext()), FuncName, QT, IsVolatile,
925 *this, std::array<Address, 2>({{DstPtr, SrcPtr}}));
926}
927
929 CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
930 ASTContext &Ctx = CGM.getContext();
931 GenDefaultInitializeFuncName GenName(DstAlignment, Ctx);
932 std::string FuncName = GenName.getName(QT, IsVolatile);
933 return getSpecialFunction(GenDefaultInitialize(Ctx), FuncName, QT, IsVolatile,
934 std::array<CharUnits, 1>({{DstAlignment}}), CGM);
935}
936
938 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
939 bool IsVolatile, QualType QT) {
940 ASTContext &Ctx = CGM.getContext();
941 GenBinaryFuncName<false> GenName("__copy_constructor_", DstAlignment,
942 SrcAlignment, Ctx);
943 std::string FuncName = GenName.getName(QT, IsVolatile);
944 return getSpecialFunction(
945 GenCopyConstructor(Ctx), FuncName, QT, IsVolatile,
946 std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
947}
948
950 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
951 bool IsVolatile, QualType QT) {
952 ASTContext &Ctx = CGM.getContext();
953 GenBinaryFuncName<true> GenName("__move_constructor_", DstAlignment,
954 SrcAlignment, Ctx);
955 std::string FuncName = GenName.getName(QT, IsVolatile);
956 return getSpecialFunction(
957 GenMoveConstructor(Ctx), FuncName, QT, IsVolatile,
958 std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
959}
960
962 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
963 bool IsVolatile, QualType QT) {
964 ASTContext &Ctx = CGM.getContext();
965 GenBinaryFuncName<false> GenName("__copy_assignment_", DstAlignment,
966 SrcAlignment, Ctx);
967 std::string FuncName = GenName.getName(QT, IsVolatile);
968 return getSpecialFunction(
969 GenCopyAssignment(Ctx), FuncName, QT, IsVolatile,
970 std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
971}
972
974 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
975 bool IsVolatile, QualType QT) {
976 ASTContext &Ctx = CGM.getContext();
977 GenBinaryFuncName<true> GenName("__move_assignment_", DstAlignment,
978 SrcAlignment, Ctx);
979 std::string FuncName = GenName.getName(QT, IsVolatile);
980 return getSpecialFunction(
981 GenMoveAssignment(Ctx), FuncName, QT, IsVolatile,
982 std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);
983}
984
986 CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
987 ASTContext &Ctx = CGM.getContext();
988 GenDestructorFuncName GenName("__destructor_", DstAlignment, Ctx);
989 std::string FuncName = GenName.getName(QT, IsVolatile);
990 return getSpecialFunction(GenDestructor(Ctx), FuncName, QT, IsVolatile,
991 std::array<CharUnits, 1>({{DstAlignment}}), CGM);
992}
static bool getFieldOffsetInBits(CodeGenFunction &CGF, const RecordDecl *RD, const FieldDecl *FD, int64_t &Offset)
The offset of a field from the beginning of the record.
Definition: CGExpr.cpp:4103
static uint64_t getFieldSize(const FieldDecl *FD, QualType FT, ASTContext &Ctx)
static void callSpecialFunction(G &&Gen, StringRef FuncName, QualType QT, bool IsVolatile, CodeGenFunction &CGF, std::array< Address, N > Addrs)
static llvm::Function * getSpecialFunction(G &&Gen, StringRef FuncName, QualType QT, bool IsVolatile, std::array< CharUnits, N > Alignments, CodeGenModule &CGM)
static llvm::Constant * getNullForVariable(Address addr)
Given the address of a variable of pointer type, find the correct null to store into it.
Definition: CGObjC.cpp:45
static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD)
static std::string getName(const CallEvent &Call)
SourceLocation Loc
Definition: SemaObjC.cpp:758
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:185
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
CanQualType VoidPtrTy
Definition: ASTContext.h:1121
IdentifierTable & Idents
Definition: ASTContext.h:647
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2359
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CanQualType VoidTy
Definition: ASTContext.h:1094
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const
Return number of constant array elements.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2363
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:3537
QualType getElementType() const
Definition: Type.h:3549
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:185
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
Definition: Address.h:111
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
Return the pointer contained in this class after authenticating it and adding offset to it if necessa...
Definition: Address.h:220
CharUnits getAlignment() const
Definition: Address.h:166
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:184
Address withElementType(llvm::Type *ElemTy) const
Return address with different element type, but same pointer and alignment.
Definition: Address.h:241
bool isValid() const
Definition: Address.h:154
static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)
Apply TemporaryLocation if it is valid.
Definition: CGDebugInfo.h:870
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:135
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:396
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:107
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:363
Address CreateConstInBoundsGEP(Address Addr, uint64_t Index, const llvm::Twine &Name="")
Given addr = T* ... produce name = getelementptr inbounds addr, i64 index where i64 is actually the t...
Definition: CGBuilder.h:260
Address CreateInBoundsGEP(Address Addr, ArrayRef< llvm::Value * > IdxList, llvm::Type *ElementType, CharUnits Align, const Twine &Name="")
Definition: CGBuilder.h:344
CGFunctionInfo - Class to encapsulate the information about a function definition.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
void EmitARCMoveWeak(Address dst, Address src)
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
void callCStructDefaultConstructor(LValue Dst)
llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)
emitArrayLength - Compute the length of an array, even if it's a VLA, and drill down to the base elem...
void callCStructCopyAssignmentOperator(LValue Dst, LValue Src)
void callCStructMoveConstructor(LValue Dst, LValue Src)
void callCStructCopyConstructor(LValue Dst, LValue Src)
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
void callCStructDestructor(LValue Dst)
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
llvm::Type * ConvertTypeForMem(QualType T)
LValue EmitLValueForField(LValue Base, const FieldDecl *Field)
static std::string getNonTrivialDestructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
void EmitARCCopyWeak(Address dst, Address src)
void defaultInitNonTrivialCStructVar(LValue Dst)
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
llvm::Value * EmitARCRetain(QualType type, llvm::Value *value)
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)
void callCStructMoveAssignmentOperator(LValue Dst, LValue Src)
llvm::Type * ConvertType(QualType T)
void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
static Destroyer destroyARCStrongImprecise
llvm::LLVMContext & getLLVMContext()
static std::string getNonTrivialCopyConstructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
This class organizes the cross-function state that is used while generating LLVM code.
llvm::Module & getModule() const
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can't be done.
ASTContext & getContext() const
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)
Set the LLVM function attributes (sext, zext, etc).
void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)
Set the LLVM function attributes which only apply to a function definition.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1632
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
Definition: CGCall.cpp:680
FunctionArgList - Type for representing both the decl and type of parameters to a function.
Definition: CGCall.h:368
LValue - This represents an lvalue references.
Definition: CGValue.h:181
bool isVolatile() const
Definition: CGValue.h:331
Address getAddress() const
Definition: CGValue.h:370
QualType getType() const
Definition: CGValue.h:294
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
Definition: CGValue.h:41
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:70
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:3575
Represents a member of a struct/union/class.
Definition: Decl.h:3059
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:3150
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
Definition: Decl.cpp:4640
bool isZeroLengthBitField(const ASTContext &Ctx) const
Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...
Definition: Decl.cpp:4593
unsigned getBitWidthValue(const ASTContext &Ctx) const
Computes the bit width of this field, if this is a bit field.
Definition: Decl.cpp:4588
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Definition: Decl.h:3272
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:5375
A (possibly-)qualified type.
Definition: Type.h:940
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:7459
PrimitiveDefaultInitializeKind
Definition: Type.h:1465
QualType withVolatile() const
Definition: Type.h:1176
Represents a struct/union/class.
Definition: Decl.h:4170
field_range fields() const
Definition: Decl.h:4376
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:5568
Encodes a location in the source.
const Type * getTypeForDecl() const
Definition: Decl.h:3416
The base class of the type hierarchy.
Definition: Type.h:1827
bool isBlockPointerType() const
Definition: Type.h:7636
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:8213
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:8146
llvm::Function * getNonTrivialCStructCopyConstructor(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)
Returns the copy constructor for a C struct with non-trivially copyable fields, generating it if nece...
llvm::Function * getNonTrivialCStructMoveConstructor(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)
Returns the move constructor for a C struct with non-trivially copyable fields, generating it if nece...
llvm::Function * getNonTrivialCStructCopyAssignmentOperator(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)
Returns the copy assignment operator for a C struct with non-trivially copyable fields,...
llvm::Function * getNonTrivialCStructMoveAssignmentOperator(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)
Return the move assignment operator for a C struct with non-trivially copyable fields,...
@ ARCImpreciseLifetime
Definition: CGValue.h:135
llvm::Function * getNonTrivialCStructDestructor(CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT)
Returns the destructor for a C struct with non-trivially copyable fields, generating it if necessary.
llvm::Function * getNonTrivialCStructDefaultConstructor(CodeGenModule &GCM, CharUnits DstAlignment, bool IsVolatile, QualType QT)
Returns the default constructor for a C struct with non-trivially copyable fields,...
The JSON file list parser is used to communicate input to InstallAPI.
unsigned long uint64_t
#define true
Definition: stdbool.h:25
#define false
Definition: stdbool.h:26
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
RetTy visitWithKind(QualType::PrimitiveCopyKind PCK, QualType FT, Ts &&... Args)
RetTy visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT, Ts &&... Args)
RetTy visitWithKind(QualType::DestructionKind DK, QualType FT, Ts &&... Args)