clang 19.0.0git
CGDeclCXX.cpp
Go to the documentation of this file.
1//===--- CGDeclCXX.cpp - Emit LLVM Code for C++ declarations --------------===//
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 contains code dealing with code generation of C++ declarations
10//
11//===----------------------------------------------------------------------===//
12
13#include "CGCXXABI.h"
14#include "CGHLSLRuntime.h"
15#include "CGObjCRuntime.h"
16#include "CGOpenMPRuntime.h"
17#include "CodeGenFunction.h"
18#include "TargetInfo.h"
19#include "clang/AST/Attr.h"
21#include "llvm/ADT/StringExtras.h"
22#include "llvm/IR/Intrinsics.h"
23#include "llvm/IR/MDBuilder.h"
24#include "llvm/Support/Path.h"
25
26using namespace clang;
27using namespace CodeGen;
28
29static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D,
30 ConstantAddress DeclPtr) {
31 assert(
32 (D.hasGlobalStorage() ||
33 (D.hasLocalStorage() && CGF.getContext().getLangOpts().OpenCLCPlusPlus)) &&
34 "VarDecl must have global or local (in the case of OpenCL) storage!");
35 assert(!D.getType()->isReferenceType() &&
36 "Should not call EmitDeclInit on a reference!");
37
38 QualType type = D.getType();
39 LValue lv = CGF.MakeAddrLValue(DeclPtr, type);
40
41 const Expr *Init = D.getInit();
42 switch (CGF.getEvaluationKind(type)) {
43 case TEK_Scalar: {
44 CodeGenModule &CGM = CGF.CGM;
45 if (lv.isObjCStrong())
47 DeclPtr, D.getTLSKind());
48 else if (lv.isObjCWeak())
50 DeclPtr);
51 else
52 CGF.EmitScalarInit(Init, &D, lv, false);
53 return;
54 }
55 case TEK_Complex:
56 CGF.EmitComplexExprIntoLValue(Init, lv, /*isInit*/ true);
57 return;
58 case TEK_Aggregate:
59 CGF.EmitAggExpr(Init,
64 return;
65 }
66 llvm_unreachable("bad evaluation kind");
67}
68
69/// Emit code to cause the destruction of the given variable with
70/// static storage duration.
71static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
72 ConstantAddress Addr) {
73 // Honor __attribute__((no_destroy)) and bail instead of attempting
74 // to emit a reference to a possibly nonexistent destructor, which
75 // in turn can cause a crash. This will result in a global constructor
76 // that isn't balanced out by a destructor call as intended by the
77 // attribute. This also checks for -fno-c++-static-destructors and
78 // bails even if the attribute is not present.
80
81 // FIXME: __attribute__((cleanup)) ?
82
83 switch (DtorKind) {
85 return;
86
88 break;
89
93 // We don't care about releasing objects during process teardown.
94 assert(!D.getTLSKind() && "should have rejected this");
95 return;
96 }
97
98 llvm::FunctionCallee Func;
99 llvm::Constant *Argument;
100
101 CodeGenModule &CGM = CGF.CGM;
102 QualType Type = D.getType();
103
104 // Special-case non-array C++ destructors, if they have the right signature.
105 // Under some ABIs, destructors return this instead of void, and cannot be
106 // passed directly to __cxa_atexit if the target does not allow this
107 // mismatch.
109 bool CanRegisterDestructor =
110 Record && (!CGM.getCXXABI().HasThisReturn(
111 GlobalDecl(Record->getDestructor(), Dtor_Complete)) ||
113 // If __cxa_atexit is disabled via a flag, a different helper function is
114 // generated elsewhere which uses atexit instead, and it takes the destructor
115 // directly.
116 bool UsingExternalHelper = !CGM.getCodeGenOpts().CXAAtExit;
117 if (Record && (CanRegisterDestructor || UsingExternalHelper)) {
118 assert(!Record->hasTrivialDestructor());
119 CXXDestructorDecl *Dtor = Record->getDestructor();
120
122 if (CGF.getContext().getLangOpts().OpenCL) {
123 auto DestAS =
125 auto DestTy = llvm::PointerType::get(
126 CGM.getLLVMContext(), CGM.getContext().getTargetAddressSpace(DestAS));
127 auto SrcAS = D.getType().getQualifiers().getAddressSpace();
128 if (DestAS == SrcAS)
129 Argument = Addr.getPointer();
130 else
131 // FIXME: On addr space mismatch we are passing NULL. The generation
132 // of the global destructor function should be adjusted accordingly.
133 Argument = llvm::ConstantPointerNull::get(DestTy);
134 } else {
135 Argument = Addr.getPointer();
136 }
137 // Otherwise, the standard logic requires a helper function.
138 } else {
139 Addr = Addr.withElementType(CGF.ConvertTypeForMem(Type));
140 Func = CodeGenFunction(CGM)
141 .generateDestroyHelper(Addr, Type, CGF.getDestroyer(DtorKind),
142 CGF.needsEHCleanup(DtorKind), &D);
143 Argument = llvm::Constant::getNullValue(CGF.Int8PtrTy);
144 }
145
146 CGM.getCXXABI().registerGlobalDtor(CGF, D, Func, Argument);
147}
148
149/// Emit code to cause the variable at the given address to be considered as
150/// constant from this point onwards.
151static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D,
152 llvm::Constant *Addr) {
153 return CGF.EmitInvariantStart(
154 Addr, CGF.getContext().getTypeSizeInChars(D.getType()));
155}
156
157void CodeGenFunction::EmitInvariantStart(llvm::Constant *Addr, CharUnits Size) {
158 // Do not emit the intrinsic if we're not optimizing.
159 if (!CGM.getCodeGenOpts().OptimizationLevel)
160 return;
161
162 // Grab the llvm.invariant.start intrinsic.
163 llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start;
164 // Overloaded address space type.
165 llvm::Type *ObjectPtr[1] = {Int8PtrTy};
166 llvm::Function *InvariantStart = CGM.getIntrinsic(InvStartID, ObjectPtr);
167
168 // Emit a call with the size in bytes of the object.
169 uint64_t Width = Size.getQuantity();
170 llvm::Value *Args[2] = {llvm::ConstantInt::getSigned(Int64Ty, Width), Addr};
171 Builder.CreateCall(InvariantStart, Args);
172}
173
175 llvm::GlobalVariable *GV,
176 bool PerformInit) {
177
178 const Expr *Init = D.getInit();
179 QualType T = D.getType();
180
181 // The address space of a static local variable (DeclPtr) may be different
182 // from the address space of the "this" argument of the constructor. In that
183 // case, we need an addrspacecast before calling the constructor.
184 //
185 // struct StructWithCtor {
186 // __device__ StructWithCtor() {...}
187 // };
188 // __device__ void foo() {
189 // __shared__ StructWithCtor s;
190 // ...
191 // }
192 //
193 // For example, in the above CUDA code, the static local variable s has a
194 // "shared" address space qualifier, but the constructor of StructWithCtor
195 // expects "this" in the "generic" address space.
196 unsigned ExpectedAddrSpace = getTypes().getTargetAddressSpace(T);
197 unsigned ActualAddrSpace = GV->getAddressSpace();
198 llvm::Constant *DeclPtr = GV;
199 if (ActualAddrSpace != ExpectedAddrSpace) {
200 llvm::PointerType *PTy =
201 llvm::PointerType::get(getLLVMContext(), ExpectedAddrSpace);
202 DeclPtr = llvm::ConstantExpr::getAddrSpaceCast(DeclPtr, PTy);
203 }
204
205 ConstantAddress DeclAddr(
206 DeclPtr, GV->getValueType(), getContext().getDeclAlign(&D));
207
208 if (!T->isReferenceType()) {
209 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd &&
210 D.hasAttr<OMPThreadPrivateDeclAttr>()) {
212 &D, DeclAddr, D.getAttr<OMPThreadPrivateDeclAttr>()->getLocation(),
213 PerformInit, this);
214 }
215 bool NeedsDtor =
217 if (PerformInit)
218 EmitDeclInit(*this, D, DeclAddr);
219 if (D.getType().isConstantStorage(getContext(), true, !NeedsDtor))
220 EmitDeclInvariant(*this, D, DeclPtr);
221 else
222 EmitDeclDestroy(*this, D, DeclAddr);
223 return;
224 }
225
226 assert(PerformInit && "cannot have constant initializer which needs "
227 "destruction for reference");
229 EmitStoreOfScalar(RV.getScalarVal(), DeclAddr, false, T);
230}
231
232/// Create a stub function, suitable for being passed to atexit,
233/// which passes the given address to the given destructor function.
234llvm::Function *CodeGenFunction::createAtExitStub(const VarDecl &VD,
235 llvm::FunctionCallee dtor,
236 llvm::Constant *addr) {
237 // Get the destructor function type, void(*)(void).
238 llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false);
239 SmallString<256> FnName;
240 {
241 llvm::raw_svector_ostream Out(FnName);
243 }
244
246 llvm::Function *fn = CGM.CreateGlobalInitOrCleanUpFunction(
247 ty, FnName.str(), FI, VD.getLocation());
248
249 CodeGenFunction CGF(CGM);
250
251 CGF.StartFunction(GlobalDecl(&VD, DynamicInitKind::AtExit),
253 VD.getLocation(), VD.getInit()->getExprLoc());
254 // Emit an artificial location for this function.
256
257 llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr);
258
259 // Make sure the call and the callee agree on calling convention.
260 if (auto *dtorFn = dyn_cast<llvm::Function>(
261 dtor.getCallee()->stripPointerCastsAndAliases()))
262 call->setCallingConv(dtorFn->getCallingConv());
263
264 CGF.FinishFunction();
265
266 return fn;
267}
268
269/// Create a stub function, suitable for being passed to __pt_atexit_np,
270/// which passes the given address to the given destructor function.
272 const VarDecl &D, llvm::FunctionCallee Dtor, llvm::Constant *Addr,
273 llvm::FunctionCallee &AtExit) {
274 SmallString<256> FnName;
275 {
276 llvm::raw_svector_ostream Out(FnName);
278 }
279
283
284 // Get the stub function type, int(*)(int,...).
285 llvm::FunctionType *StubTy =
286 llvm::FunctionType::get(CGM.IntTy, {CGM.IntTy}, true);
287
288 llvm::Function *DtorStub = CGM.CreateGlobalInitOrCleanUpFunction(
289 StubTy, FnName.str(), FI, D.getLocation());
290
291 CodeGenFunction CGF(CGM);
292
293 FunctionArgList Args;
296 Args.push_back(&IPD);
297 QualType ResTy = CGM.getContext().IntTy;
298
299 CGF.StartFunction(GlobalDecl(&D, DynamicInitKind::AtExit), ResTy, DtorStub,
300 FI, Args, D.getLocation(), D.getInit()->getExprLoc());
301
302 // Emit an artificial location for this function.
304
305 llvm::CallInst *call = CGF.Builder.CreateCall(Dtor, Addr);
306
307 // Make sure the call and the callee agree on calling convention.
308 if (auto *DtorFn = dyn_cast<llvm::Function>(
309 Dtor.getCallee()->stripPointerCastsAndAliases()))
310 call->setCallingConv(DtorFn->getCallingConv());
311
312 // Return 0 from function
313 CGF.Builder.CreateStore(llvm::Constant::getNullValue(CGM.IntTy),
314 CGF.ReturnValue);
315
316 CGF.FinishFunction();
317
318 return DtorStub;
319}
320
321/// Register a global destructor using the C atexit runtime function.
323 llvm::FunctionCallee dtor,
324 llvm::Constant *addr) {
325 // Create a function which calls the destructor.
326 llvm::Constant *dtorStub = createAtExitStub(VD, dtor, addr);
328}
329
330/// Register a global destructor using the LLVM 'llvm.global_dtors' global.
332 llvm::FunctionCallee Dtor,
333 llvm::Constant *Addr) {
334 // Create a function which calls the destructor.
335 llvm::Function *dtorStub = createAtExitStub(VD, Dtor, Addr);
336 CGM.AddGlobalDtor(dtorStub);
337}
338
339void CodeGenFunction::registerGlobalDtorWithAtExit(llvm::Constant *dtorStub) {
340 // extern "C" int atexit(void (*f)(void));
341 assert(dtorStub->getType() ==
342 llvm::PointerType::get(
343 llvm::FunctionType::get(CGM.VoidTy, false),
344 dtorStub->getType()->getPointerAddressSpace()) &&
345 "Argument to atexit has a wrong type.");
346
347 llvm::FunctionType *atexitTy =
348 llvm::FunctionType::get(IntTy, dtorStub->getType(), false);
349
350 llvm::FunctionCallee atexit =
351 CGM.CreateRuntimeFunction(atexitTy, "atexit", llvm::AttributeList(),
352 /*Local=*/true);
353 if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit.getCallee()))
354 atexitFn->setDoesNotThrow();
355
356 EmitNounwindRuntimeCall(atexit, dtorStub);
357}
358
359llvm::Value *
361 // The unatexit subroutine unregisters __dtor functions that were previously
362 // registered by the atexit subroutine. If the referenced function is found,
363 // it is removed from the list of functions that are called at normal program
364 // termination and the unatexit returns a value of 0, otherwise a non-zero
365 // value is returned.
366 //
367 // extern "C" int unatexit(void (*f)(void));
368 assert(dtorStub->getType() ==
369 llvm::PointerType::get(
370 llvm::FunctionType::get(CGM.VoidTy, false),
371 dtorStub->getType()->getPointerAddressSpace()) &&
372 "Argument to unatexit has a wrong type.");
373
374 llvm::FunctionType *unatexitTy =
375 llvm::FunctionType::get(IntTy, {dtorStub->getType()}, /*isVarArg=*/false);
376
377 llvm::FunctionCallee unatexit =
378 CGM.CreateRuntimeFunction(unatexitTy, "unatexit", llvm::AttributeList());
379
380 cast<llvm::Function>(unatexit.getCallee())->setDoesNotThrow();
381
382 return EmitNounwindRuntimeCall(unatexit, dtorStub);
383}
384
386 llvm::GlobalVariable *DeclPtr,
387 bool PerformInit) {
388 // If we've been asked to forbid guard variables, emit an error now.
389 // This diagnostic is hard-coded for Darwin's use case; we can find
390 // better phrasing if someone else needs it.
391 if (CGM.getCodeGenOpts().ForbidGuardVariables)
393 "this initialization requires a guard variable, which "
394 "the kernel does not support");
395
396 CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit);
397}
398
399void CodeGenFunction::EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
400 llvm::BasicBlock *InitBlock,
401 llvm::BasicBlock *NoInitBlock,
402 GuardKind Kind,
403 const VarDecl *D) {
404 assert((Kind == GuardKind::TlsGuard || D) && "no guarded variable");
405
406 // A guess at how many times we will enter the initialization of a
407 // variable, depending on the kind of variable.
408 static const uint64_t InitsPerTLSVar = 1024;
409 static const uint64_t InitsPerLocalVar = 1024 * 1024;
410
411 llvm::MDNode *Weights;
412 if (Kind == GuardKind::VariableGuard && !D->isLocalVarDecl()) {
413 // For non-local variables, don't apply any weighting for now. Due to our
414 // use of COMDATs, we expect there to be at most one initialization of the
415 // variable per DSO, but we have no way to know how many DSOs will try to
416 // initialize the variable.
417 Weights = nullptr;
418 } else {
419 uint64_t NumInits;
420 // FIXME: For the TLS case, collect and use profiling information to
421 // determine a more accurate brach weight.
422 if (Kind == GuardKind::TlsGuard || D->getTLSKind())
423 NumInits = InitsPerTLSVar;
424 else
425 NumInits = InitsPerLocalVar;
426
427 // The probability of us entering the initializer is
428 // 1 / (total number of times we attempt to initialize the variable).
429 llvm::MDBuilder MDHelper(CGM.getLLVMContext());
430 Weights = MDHelper.createBranchWeights(1, NumInits - 1);
431 }
432
433 Builder.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights);
434}
435
437 llvm::FunctionType *FTy, const Twine &Name, const CGFunctionInfo &FI,
438 SourceLocation Loc, bool TLS, llvm::GlobalVariable::LinkageTypes Linkage) {
439 llvm::Function *Fn = llvm::Function::Create(FTy, Linkage, Name, &getModule());
440
441 if (!getLangOpts().AppleKext && !TLS) {
442 // Set the section if needed.
443 if (const char *Section = getTarget().getStaticInitSectionSpecifier())
444 Fn->setSection(Section);
445 }
446
447 if (Linkage == llvm::GlobalVariable::InternalLinkage)
449
450 Fn->setCallingConv(getRuntimeCC());
451
452 if (!getLangOpts().Exceptions)
453 Fn->setDoesNotThrow();
454
455 if (getLangOpts().Sanitize.has(SanitizerKind::Address) &&
456 !isInNoSanitizeList(SanitizerKind::Address, Fn, Loc))
457 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
458
459 if (getLangOpts().Sanitize.has(SanitizerKind::KernelAddress) &&
460 !isInNoSanitizeList(SanitizerKind::KernelAddress, Fn, Loc))
461 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
462
463 if (getLangOpts().Sanitize.has(SanitizerKind::HWAddress) &&
464 !isInNoSanitizeList(SanitizerKind::HWAddress, Fn, Loc))
465 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
466
467 if (getLangOpts().Sanitize.has(SanitizerKind::KernelHWAddress) &&
468 !isInNoSanitizeList(SanitizerKind::KernelHWAddress, Fn, Loc))
469 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
470
471 if (getLangOpts().Sanitize.has(SanitizerKind::MemtagStack) &&
472 !isInNoSanitizeList(SanitizerKind::MemtagStack, Fn, Loc))
473 Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
474
475 if (getLangOpts().Sanitize.has(SanitizerKind::Thread) &&
476 !isInNoSanitizeList(SanitizerKind::Thread, Fn, Loc))
477 Fn->addFnAttr(llvm::Attribute::SanitizeThread);
478
479 if (getLangOpts().Sanitize.has(SanitizerKind::Memory) &&
480 !isInNoSanitizeList(SanitizerKind::Memory, Fn, Loc))
481 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
482
483 if (getLangOpts().Sanitize.has(SanitizerKind::KernelMemory) &&
484 !isInNoSanitizeList(SanitizerKind::KernelMemory, Fn, Loc))
485 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
486
487 if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack) &&
488 !isInNoSanitizeList(SanitizerKind::SafeStack, Fn, Loc))
489 Fn->addFnAttr(llvm::Attribute::SafeStack);
490
491 if (getLangOpts().Sanitize.has(SanitizerKind::ShadowCallStack) &&
492 !isInNoSanitizeList(SanitizerKind::ShadowCallStack, Fn, Loc))
493 Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
494
495 return Fn;
496}
497
498/// Create a global pointer to a function that will initialize a global
499/// variable. The user has requested that this pointer be emitted in a specific
500/// section.
501void CodeGenModule::EmitPointerToInitFunc(const VarDecl *D,
502 llvm::GlobalVariable *GV,
503 llvm::Function *InitFunc,
504 InitSegAttr *ISA) {
505 llvm::GlobalVariable *PtrArray = new llvm::GlobalVariable(
506 TheModule, InitFunc->getType(), /*isConstant=*/true,
507 llvm::GlobalValue::PrivateLinkage, InitFunc, "__cxx_init_fn_ptr");
508 PtrArray->setSection(ISA->getSection());
509 addUsedGlobal(PtrArray);
510
511 // If the GV is already in a comdat group, then we have to join it.
512 if (llvm::Comdat *C = GV->getComdat())
513 PtrArray->setComdat(C);
514}
515
516void
517CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
518 llvm::GlobalVariable *Addr,
519 bool PerformInit) {
520
521 // According to E.2.3.1 in CUDA-7.5 Programming guide: __device__,
522 // __constant__ and __shared__ variables defined in namespace scope,
523 // that are of class type, cannot have a non-empty constructor. All
524 // the checks have been done in Sema by now. Whatever initializers
525 // are allowed are empty and we just need to ignore them here.
526 if (getLangOpts().CUDAIsDevice && !getLangOpts().GPUAllowDeviceInit &&
527 (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>() ||
528 D->hasAttr<CUDASharedAttr>()))
529 return;
530
531 // Check if we've already initialized this decl.
532 auto I = DelayedCXXInitPosition.find(D);
533 if (I != DelayedCXXInitPosition.end() && I->second == ~0U)
534 return;
535
536 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
537 SmallString<256> FnName;
538 {
539 llvm::raw_svector_ostream Out(FnName);
541 }
542
543 // Create a variable initialization function.
544 llvm::Function *Fn = CreateGlobalInitOrCleanUpFunction(
545 FTy, FnName.str(), getTypes().arrangeNullaryFunction(), D->getLocation());
546
547 auto *ISA = D->getAttr<InitSegAttr>();
549 PerformInit);
550
551 llvm::GlobalVariable *COMDATKey =
552 supportsCOMDAT() && D->isExternallyVisible() ? Addr : nullptr;
553
554 if (D->getTLSKind()) {
555 // FIXME: Should we support init_priority for thread_local?
556 // FIXME: We only need to register one __cxa_thread_atexit function for the
557 // entire TU.
558 CXXThreadLocalInits.push_back(Fn);
559 CXXThreadLocalInitVars.push_back(D);
560 } else if (PerformInit && ISA) {
561 // Contract with backend that "init_seg(compiler)" corresponds to priority
562 // 200 and "init_seg(lib)" corresponds to priority 400.
563 int Priority = -1;
564 if (ISA->getSection() == ".CRT$XCC")
565 Priority = 200;
566 else if (ISA->getSection() == ".CRT$XCL")
567 Priority = 400;
568
569 if (Priority != -1)
570 AddGlobalCtor(Fn, Priority, ~0U, COMDATKey);
571 else
572 EmitPointerToInitFunc(D, Addr, Fn, ISA);
573 } else if (auto *IPA = D->getAttr<InitPriorityAttr>()) {
574 OrderGlobalInitsOrStermFinalizers Key(IPA->getPriority(),
575 PrioritizedCXXGlobalInits.size());
576 PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn));
578 getContext().GetGVALinkageForVariable(D) == GVA_DiscardableODR ||
579 D->hasAttr<SelectAnyAttr>()) {
580 // C++ [basic.start.init]p2:
581 // Definitions of explicitly specialized class template static data
582 // members have ordered initialization. Other class template static data
583 // members (i.e., implicitly or explicitly instantiated specializations)
584 // have unordered initialization.
585 //
586 // As a consequence, we can put them into their own llvm.global_ctors entry.
587 //
588 // If the global is externally visible, put the initializer into a COMDAT
589 // group with the global being initialized. On most platforms, this is a
590 // minor startup time optimization. In the MS C++ ABI, there are no guard
591 // variables, so this COMDAT key is required for correctness.
592 //
593 // SelectAny globals will be comdat-folded. Put the initializer into a
594 // COMDAT group associated with the global, so the initializers get folded
595 // too.
596 I = DelayedCXXInitPosition.find(D);
597 // CXXGlobalInits.size() is the lex order number for the next deferred
598 // VarDecl. Use it when the current VarDecl is non-deferred. Although this
599 // lex order number is shared between current VarDecl and some following
600 // VarDecls, their order of insertion into `llvm.global_ctors` is the same
601 // as the lexing order and the following stable sort would preserve such
602 // order.
603 unsigned LexOrder =
604 I == DelayedCXXInitPosition.end() ? CXXGlobalInits.size() : I->second;
605 AddGlobalCtor(Fn, 65535, LexOrder, COMDATKey);
606 if (COMDATKey && (getTriple().isOSBinFormatELF() ||
607 getTarget().getCXXABI().isMicrosoft())) {
608 // When COMDAT is used on ELF or in the MS C++ ABI, the key must be in
609 // llvm.used to prevent linker GC.
610 addUsedGlobal(COMDATKey);
611 }
612
613 // If we used a COMDAT key for the global ctor, the init function can be
614 // discarded if the global ctor entry is discarded.
615 // FIXME: Do we need to restrict this to ELF and Wasm?
616 llvm::Comdat *C = Addr->getComdat();
617 if (COMDATKey && C &&
618 (getTarget().getTriple().isOSBinFormatELF() ||
619 getTarget().getTriple().isOSBinFormatWasm())) {
620 Fn->setComdat(C);
621 }
622 } else {
623 I = DelayedCXXInitPosition.find(D); // Re-do lookup in case of re-hash.
624 if (I == DelayedCXXInitPosition.end()) {
625 CXXGlobalInits.push_back(Fn);
626 } else if (I->second != ~0U) {
627 assert(I->second < CXXGlobalInits.size() &&
628 CXXGlobalInits[I->second] == nullptr);
629 CXXGlobalInits[I->second] = Fn;
630 }
631 }
632
633 // Remember that we already emitted the initializer for this global.
634 DelayedCXXInitPosition[D] = ~0U;
635}
636
637void CodeGenModule::EmitCXXThreadLocalInitFunc() {
639 *this, CXXThreadLocals, CXXThreadLocalInits, CXXThreadLocalInitVars);
640
641 CXXThreadLocalInits.clear();
642 CXXThreadLocalInitVars.clear();
643 CXXThreadLocals.clear();
644}
645
646/* Build the initializer for a C++20 module:
647 This is arranged to be run only once regardless of how many times the module
648 might be included transitively. This arranged by using a guard variable.
649
650 If there are no initializers at all (and also no imported modules) we reduce
651 this to an empty function (since the Itanium ABI requires that this function
652 be available to a caller, which might be produced by a different
653 implementation).
654
655 First we call any initializers for imported modules.
656 We then call initializers for the Global Module Fragment (if present)
657 We then call initializers for the current module.
658 We then call initializers for the Private Module Fragment (if present)
659*/
660
661void CodeGenModule::EmitCXXModuleInitFunc(Module *Primary) {
662 assert(Primary->isInterfaceOrPartition() &&
663 "The function should only be called for C++20 named module interface"
664 " or partition.");
665
666 while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
667 CXXGlobalInits.pop_back();
668
669 // As noted above, we create the function, even if it is empty.
670 // Module initializers for imported modules are emitted first.
671
672 // Collect all the modules that we import
674 // Ones that we export
675 for (auto I : Primary->Exports)
676 AllImports.insert(I.getPointer());
677 // Ones that we only import.
678 for (Module *M : Primary->Imports)
679 AllImports.insert(M);
680 // Ones that we import in the global module fragment or the private module
681 // fragment.
682 for (Module *SubM : Primary->submodules()) {
683 assert((SubM->isGlobalModule() || SubM->isPrivateModule()) &&
684 "The sub modules of C++20 module unit should only be global module "
685 "fragments or private module framents.");
686 assert(SubM->Exports.empty() &&
687 "The global mdoule fragments and the private module fragments are "
688 "not allowed to export import modules.");
689 for (Module *M : SubM->Imports)
690 AllImports.insert(M);
691 }
692
694 for (Module *M : AllImports) {
695 // No Itanium initializer in header like modules.
696 if (M->isHeaderLikeModule())
697 continue; // TODO: warn of mixed use of module map modules and C++20?
698 // We're allowed to skip the initialization if we are sure it doesn't
699 // do any thing.
701 continue;
702 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
703 SmallString<256> FnName;
704 {
705 llvm::raw_svector_ostream Out(FnName);
706 cast<ItaniumMangleContext>(getCXXABI().getMangleContext())
707 .mangleModuleInitializer(M, Out);
708 }
709 assert(!GetGlobalValue(FnName.str()) &&
710 "We should only have one use of the initializer call");
711 llvm::Function *Fn = llvm::Function::Create(
712 FTy, llvm::Function::ExternalLinkage, FnName.str(), &getModule());
713 ModuleInits.push_back(Fn);
714 }
715
716 // Add any initializers with specified priority; this uses the same approach
717 // as EmitCXXGlobalInitFunc().
718 if (!PrioritizedCXXGlobalInits.empty()) {
719 SmallVector<llvm::Function *, 8> LocalCXXGlobalInits;
720 llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
721 PrioritizedCXXGlobalInits.end());
723 I = PrioritizedCXXGlobalInits.begin(),
724 E = PrioritizedCXXGlobalInits.end();
725 I != E;) {
727 std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp());
728
729 for (; I < PrioE; ++I)
730 ModuleInits.push_back(I->second);
731 }
732 }
733
734 // Now append the ones without specified priority.
735 for (auto *F : CXXGlobalInits)
736 ModuleInits.push_back(F);
737
738 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
740
741 // We now build the initializer for this module, which has a mangled name
742 // as per the Itanium ABI . The action of the initializer is guarded so that
743 // each init is run just once (even though a module might be imported
744 // multiple times via nested use).
745 llvm::Function *Fn;
746 {
747 SmallString<256> InitFnName;
748 llvm::raw_svector_ostream Out(InitFnName);
749 cast<ItaniumMangleContext>(getCXXABI().getMangleContext())
750 .mangleModuleInitializer(Primary, Out);
752 FTy, llvm::Twine(InitFnName), FI, SourceLocation(), false,
753 llvm::GlobalVariable::ExternalLinkage);
754
755 // If we have a completely empty initializer then we do not want to create
756 // the guard variable.
758 if (!ModuleInits.empty()) {
759 // Create the guard var.
760 llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
761 getModule(), Int8Ty, /*isConstant=*/false,
762 llvm::GlobalVariable::InternalLinkage,
763 llvm::ConstantInt::get(Int8Ty, 0), InitFnName.str() + "__in_chrg");
764 CharUnits GuardAlign = CharUnits::One();
765 Guard->setAlignment(GuardAlign.getAsAlign());
766 GuardAddr = ConstantAddress(Guard, Int8Ty, GuardAlign);
767 }
768 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, ModuleInits,
769 GuardAddr);
770 }
771
772 // We allow for the case that a module object is added to a linked binary
773 // without a specific call to the the initializer. This also ensures that
774 // implementation partition initializers are called when the partition
775 // is not imported as an interface.
776 AddGlobalCtor(Fn);
777
778 // See the comment in EmitCXXGlobalInitFunc about OpenCL global init
779 // functions.
780 if (getLangOpts().OpenCL) {
782 Fn->setCallingConv(llvm::CallingConv::SPIR_KERNEL);
783 }
784
785 assert(!getLangOpts().CUDA || !getLangOpts().CUDAIsDevice ||
786 getLangOpts().GPUAllowDeviceInit);
787 if (getLangOpts().HIP && getLangOpts().CUDAIsDevice) {
788 Fn->setCallingConv(llvm::CallingConv::AMDGPU_KERNEL);
789 Fn->addFnAttr("device-init");
790 }
791
792 // We are done with the inits.
793 AllImports.clear();
794 PrioritizedCXXGlobalInits.clear();
795 CXXGlobalInits.clear();
796 ModuleInits.clear();
797}
798
800 SmallString<128> FileName = llvm::sys::path::filename(M.getName());
801
802 if (FileName.empty())
803 FileName = "<null>";
804
805 for (size_t i = 0; i < FileName.size(); ++i) {
806 // Replace everything that's not [a-zA-Z0-9._] with a _. This set happens
807 // to be the set of C preprocessing numbers.
809 FileName[i] = '_';
810 }
811
812 return FileName;
813}
814
815static std::string getPrioritySuffix(unsigned int Priority) {
816 assert(Priority <= 65535 && "Priority should always be <= 65535.");
817
818 // Compute the function suffix from priority. Prepend with zeroes to make
819 // sure the function names are also ordered as priorities.
820 std::string PrioritySuffix = llvm::utostr(Priority);
821 PrioritySuffix = std::string(6 - PrioritySuffix.size(), '0') + PrioritySuffix;
822
823 return PrioritySuffix;
824}
825
826void
827CodeGenModule::EmitCXXGlobalInitFunc() {
828 while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
829 CXXGlobalInits.pop_back();
830
831 // When we import C++20 modules, we must run their initializers first.
833 if (CXX20ModuleInits)
834 for (Module *M : ImportedModules) {
835 // No Itanium initializer in header like modules.
836 if (M->isHeaderLikeModule())
837 continue;
838 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
839 SmallString<256> FnName;
840 {
841 llvm::raw_svector_ostream Out(FnName);
842 cast<ItaniumMangleContext>(getCXXABI().getMangleContext())
843 .mangleModuleInitializer(M, Out);
844 }
845 assert(!GetGlobalValue(FnName.str()) &&
846 "We should only have one use of the initializer call");
847 llvm::Function *Fn = llvm::Function::Create(
848 FTy, llvm::Function::ExternalLinkage, FnName.str(), &getModule());
849 ModuleInits.push_back(Fn);
850 }
851
852 if (ModuleInits.empty() && CXXGlobalInits.empty() &&
853 PrioritizedCXXGlobalInits.empty())
854 return;
855
856 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
858
859 // Create our global prioritized initialization function.
860 if (!PrioritizedCXXGlobalInits.empty()) {
861 SmallVector<llvm::Function *, 8> LocalCXXGlobalInits;
862 llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
863 PrioritizedCXXGlobalInits.end());
864 // Iterate over "chunks" of ctors with same priority and emit each chunk
865 // into separate function. Note - everything is sorted first by priority,
866 // second - by lex order, so we emit ctor functions in proper order.
868 I = PrioritizedCXXGlobalInits.begin(),
869 E = PrioritizedCXXGlobalInits.end(); I != E; ) {
871 PrioE = std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp());
872
873 LocalCXXGlobalInits.clear();
874
875 unsigned int Priority = I->first.priority;
876 llvm::Function *Fn = CreateGlobalInitOrCleanUpFunction(
877 FTy, "_GLOBAL__I_" + getPrioritySuffix(Priority), FI);
878
879 // Prepend the module inits to the highest priority set.
880 if (!ModuleInits.empty()) {
881 for (auto *F : ModuleInits)
882 LocalCXXGlobalInits.push_back(F);
883 ModuleInits.clear();
884 }
885
886 for (; I < PrioE; ++I)
887 LocalCXXGlobalInits.push_back(I->second);
888
889 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, LocalCXXGlobalInits);
890 AddGlobalCtor(Fn, Priority);
891 }
892 PrioritizedCXXGlobalInits.clear();
893 }
894
895 if (getCXXABI().useSinitAndSterm() && ModuleInits.empty() &&
896 CXXGlobalInits.empty())
897 return;
898
899 for (auto *F : CXXGlobalInits)
900 ModuleInits.push_back(F);
901 CXXGlobalInits.clear();
902
903 // Include the filename in the symbol name. Including "sub_" matches gcc
904 // and makes sure these symbols appear lexicographically behind the symbols
905 // with priority emitted above. Module implementation units behave the same
906 // way as a non-modular TU with imports.
907 llvm::Function *Fn;
908 if (CXX20ModuleInits && getContext().getCurrentNamedModule() &&
909 !getContext().getCurrentNamedModule()->isModuleImplementation()) {
910 SmallString<256> InitFnName;
911 llvm::raw_svector_ostream Out(InitFnName);
912 cast<ItaniumMangleContext>(getCXXABI().getMangleContext())
913 .mangleModuleInitializer(getContext().getCurrentNamedModule(), Out);
915 FTy, llvm::Twine(InitFnName), FI, SourceLocation(), false,
916 llvm::GlobalVariable::ExternalLinkage);
917 } else
919 FTy,
920 llvm::Twine("_GLOBAL__sub_I_", getTransformedFileName(getModule())),
921 FI);
922
923 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, ModuleInits);
924 AddGlobalCtor(Fn);
925
926 // In OpenCL global init functions must be converted to kernels in order to
927 // be able to launch them from the host.
928 // FIXME: Some more work might be needed to handle destructors correctly.
929 // Current initialization function makes use of function pointers callbacks.
930 // We can't support function pointers especially between host and device.
931 // However it seems global destruction has little meaning without any
932 // dynamic resource allocation on the device and program scope variables are
933 // destroyed by the runtime when program is released.
934 if (getLangOpts().OpenCL) {
936 Fn->setCallingConv(llvm::CallingConv::SPIR_KERNEL);
937 }
938
939 assert(!getLangOpts().CUDA || !getLangOpts().CUDAIsDevice ||
940 getLangOpts().GPUAllowDeviceInit);
941 if (getLangOpts().HIP && getLangOpts().CUDAIsDevice) {
942 Fn->setCallingConv(llvm::CallingConv::AMDGPU_KERNEL);
943 Fn->addFnAttr("device-init");
944 }
945
946 ModuleInits.clear();
947}
948
949void CodeGenModule::EmitCXXGlobalCleanUpFunc() {
950 if (CXXGlobalDtorsOrStermFinalizers.empty() &&
951 PrioritizedCXXStermFinalizers.empty())
952 return;
953
954 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
956
957 // Create our global prioritized cleanup function.
958 if (!PrioritizedCXXStermFinalizers.empty()) {
960 llvm::array_pod_sort(PrioritizedCXXStermFinalizers.begin(),
961 PrioritizedCXXStermFinalizers.end());
962 // Iterate over "chunks" of dtors with same priority and emit each chunk
963 // into separate function. Note - everything is sorted first by priority,
964 // second - by lex order, so we emit dtor functions in proper order.
966 I = PrioritizedCXXStermFinalizers.begin(),
967 E = PrioritizedCXXStermFinalizers.end();
968 I != E;) {
970 std::upper_bound(I + 1, E, *I, StermFinalizerPriorityCmp());
971
972 LocalCXXStermFinalizers.clear();
973
974 unsigned int Priority = I->first.priority;
975 llvm::Function *Fn = CreateGlobalInitOrCleanUpFunction(
976 FTy, "_GLOBAL__a_" + getPrioritySuffix(Priority), FI);
977
978 for (; I < PrioE; ++I) {
979 llvm::FunctionCallee DtorFn = I->second;
980 LocalCXXStermFinalizers.emplace_back(DtorFn.getFunctionType(),
981 DtorFn.getCallee(), nullptr);
982 }
983
985 Fn, LocalCXXStermFinalizers);
986 AddGlobalDtor(Fn, Priority);
987 }
988 PrioritizedCXXStermFinalizers.clear();
989 }
990
991 if (CXXGlobalDtorsOrStermFinalizers.empty())
992 return;
993
994 // Create our global cleanup function.
995 llvm::Function *Fn =
996 CreateGlobalInitOrCleanUpFunction(FTy, "_GLOBAL__D_a", FI);
997
999 Fn, CXXGlobalDtorsOrStermFinalizers);
1000 AddGlobalDtor(Fn);
1001 CXXGlobalDtorsOrStermFinalizers.clear();
1002}
1003
1004/// Emit the code necessary to initialize the given global variable.
1006 const VarDecl *D,
1007 llvm::GlobalVariable *Addr,
1008 bool PerformInit) {
1009 // Check if we need to emit debug info for variable initializer.
1010 if (D->hasAttr<NoDebugAttr>())
1011 DebugInfo = nullptr; // disable debug info indefinitely for this function
1012
1013 CurEHLocation = D->getBeginLoc();
1014
1016 getContext().VoidTy, Fn, getTypes().arrangeNullaryFunction(),
1017 FunctionArgList());
1018 // Emit an artificial location for this function.
1019 auto AL = ApplyDebugLocation::CreateArtificial(*this);
1020
1021 // Use guarded initialization if the global variable is weak. This
1022 // occurs for, e.g., instantiated static data members and
1023 // definitions explicitly marked weak.
1024 //
1025 // Also use guarded initialization for a variable with dynamic TLS and
1026 // unordered initialization. (If the initialization is ordered, the ABI
1027 // layer will guard the whole-TU initialization for us.)
1028 if (Addr->hasWeakLinkage() || Addr->hasLinkOnceLinkage() ||
1031 EmitCXXGuardedInit(*D, Addr, PerformInit);
1032 } else {
1033 EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit);
1034 }
1035
1036 if (getLangOpts().HLSL)
1038
1040}
1041
1042void
1045 ConstantAddress Guard) {
1046 {
1047 auto NL = ApplyDebugLocation::CreateEmpty(*this);
1049 getTypes().arrangeNullaryFunction(), FunctionArgList());
1050 // Emit an artificial location for this function.
1051 auto AL = ApplyDebugLocation::CreateArtificial(*this);
1052
1053 llvm::BasicBlock *ExitBlock = nullptr;
1054 if (Guard.isValid()) {
1055 // If we have a guard variable, check whether we've already performed
1056 // these initializations. This happens for TLS initialization functions.
1057 llvm::Value *GuardVal = Builder.CreateLoad(Guard);
1058 llvm::Value *Uninit = Builder.CreateIsNull(GuardVal,
1059 "guard.uninitialized");
1060 llvm::BasicBlock *InitBlock = createBasicBlock("init");
1061 ExitBlock = createBasicBlock("exit");
1062 EmitCXXGuardedInitBranch(Uninit, InitBlock, ExitBlock,
1063 GuardKind::TlsGuard, nullptr);
1064 EmitBlock(InitBlock);
1065 // Mark as initialized before initializing anything else. If the
1066 // initializers use previously-initialized thread_local vars, that's
1067 // probably supposed to be OK, but the standard doesn't say.
1068 Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(),1), Guard);
1069
1070 // The guard variable can't ever change again.
1072 Guard.getPointer(),
1074 CGM.getDataLayout().getTypeAllocSize(GuardVal->getType())));
1075 }
1076
1077 RunCleanupsScope Scope(*this);
1078
1079 // When building in Objective-C++ ARC mode, create an autorelease pool
1080 // around the global initializers.
1081 if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) {
1082 llvm::Value *token = EmitObjCAutoreleasePoolPush();
1084 }
1085
1086 for (unsigned i = 0, e = Decls.size(); i != e; ++i)
1087 if (Decls[i])
1088 EmitRuntimeCall(Decls[i]);
1089
1090 Scope.ForceCleanup();
1091
1092 if (ExitBlock) {
1093 Builder.CreateBr(ExitBlock);
1094 EmitBlock(ExitBlock);
1095 }
1096 }
1097
1099}
1100
1102 llvm::Function *Fn,
1103 ArrayRef<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
1104 llvm::Constant *>>
1105 DtorsOrStermFinalizers) {
1106 {
1107 auto NL = ApplyDebugLocation::CreateEmpty(*this);
1109 getTypes().arrangeNullaryFunction(), FunctionArgList());
1110 // Emit an artificial location for this function.
1111 auto AL = ApplyDebugLocation::CreateArtificial(*this);
1112
1113 // Emit the cleanups, in reverse order from construction.
1114 for (unsigned i = 0, e = DtorsOrStermFinalizers.size(); i != e; ++i) {
1115 llvm::FunctionType *CalleeTy;
1116 llvm::Value *Callee;
1117 llvm::Constant *Arg;
1118 std::tie(CalleeTy, Callee, Arg) = DtorsOrStermFinalizers[e - i - 1];
1119
1120 llvm::CallInst *CI = nullptr;
1121 if (Arg == nullptr) {
1122 assert(
1124 "Arg could not be nullptr unless using sinit and sterm functions.");
1125 CI = Builder.CreateCall(CalleeTy, Callee);
1126 } else
1127 CI = Builder.CreateCall(CalleeTy, Callee, Arg);
1128
1129 // Make sure the call and the callee agree on calling convention.
1130 if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
1131 CI->setCallingConv(F->getCallingConv());
1132 }
1133 }
1134
1136}
1137
1138/// generateDestroyHelper - Generates a helper function which, when
1139/// invoked, destroys the given object. The address of the object
1140/// should be in global memory.
1142 Address addr, QualType type, Destroyer *destroyer,
1143 bool useEHCleanupForArray, const VarDecl *VD) {
1144 FunctionArgList args;
1147 args.push_back(&Dst);
1148
1149 const CGFunctionInfo &FI =
1151 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
1152 llvm::Function *fn = CGM.CreateGlobalInitOrCleanUpFunction(
1153 FTy, "__cxx_global_array_dtor", FI, VD->getLocation());
1154
1155 CurEHLocation = VD->getBeginLoc();
1156
1158 getContext().VoidTy, fn, FI, args);
1159 // Emit an artificial location for this function.
1160 auto AL = ApplyDebugLocation::CreateArtificial(*this);
1161
1162 emitDestroy(addr, type, destroyer, useEHCleanupForArray);
1163
1165
1166 return fn;
1167}
static std::string getPrioritySuffix(unsigned int Priority)
Definition: CGDeclCXX.cpp:815
static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D, ConstantAddress DeclPtr)
Definition: CGDeclCXX.cpp:29
static SmallString< 128 > getTransformedFileName(llvm::Module &M)
Definition: CGDeclCXX.cpp:799
static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D, ConstantAddress Addr)
Emit code to cause the destruction of the given variable with static storage duration.
Definition: CGDeclCXX.cpp:71
static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D, llvm::Constant *Addr)
Emit code to cause the variable at the given address to be considered as constant from this point onw...
Definition: CGDeclCXX.cpp:151
int Priority
Definition: Format.cpp:2979
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
Definition: MachO.h:31
SourceLocation Loc
Definition: SemaObjC.cpp:755
const LangOptions & getLangOpts() const
Definition: ASTContext.h:775
CanQualType IntTy
Definition: ASTContext.h:1100
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CanQualType VoidTy
Definition: ASTContext.h:1091
unsigned getTargetAddressSpace(LangAS AS) const
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2799
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
Definition: CharUnits.h:189
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
Definition: Address.h:111
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
Definition: CGValue.h:607
static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)
Apply TemporaryLocation if it is valid.
Definition: CGDebugInfo.h:864
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
Set the IRBuilder to not attach debug locations.
Definition: CGDebugInfo.h:881
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:136
llvm::Value * CreateIsNull(Address Addr, const Twine &Name="")
Definition: CGBuilder.h:355
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:108
virtual bool HasThisReturn(GlobalDecl GD) const
Returns true if the given constructor or destructor is one of the kinds that the ABI says returns 'th...
Definition: CGCXXABI.h:123
virtual bool useSinitAndSterm() const
Definition: CGCXXABI.h:133
virtual void EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)=0
Emits the guarded initializer and destructor setup for the given variable, given that it couldn't be ...
virtual void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D, llvm::FunctionCallee Dtor, llvm::Constant *Addr)=0
Emit code to force the execution of a destructor during global teardown.
virtual bool canCallMismatchedFunctionType() const
Returns true if the target allows calling a function through a pointer with a different signature tha...
Definition: CGCXXABI.h:143
virtual void EmitThreadLocalInitFuncs(CodeGenModule &CGM, ArrayRef< const VarDecl * > CXXThreadLocals, ArrayRef< llvm::Function * > CXXThreadLocalInits, ArrayRef< const VarDecl * > CXXThreadLocalInitVars)=0
Emits ABI-required functions necessary to initialize thread_local variables in this translation unit.
MangleContext & getMangleContext()
Gets the mangle context.
Definition: CGCXXABI.h:113
CGFunctionInfo - Class to encapsulate the information about a function definition.
void annotateHLSLResource(const VarDecl *D, llvm::GlobalVariable *GV)
virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest)=0
virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest, bool threadlocal=false)=0
virtual llvm::Function * emitThreadPrivateVarDefinition(const VarDecl *VD, Address VDAddr, SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF=nullptr)
Emit a code for initialization of threadprivate variable.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void GenerateCXXGlobalInitFunc(llvm::Function *Fn, ArrayRef< llvm::Function * > CXXThreadLocals, ConstantAddress Guard=ConstantAddress::invalid())
GenerateCXXGlobalInitFunc - Generates code for initializing global variables.
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
llvm::Value * EmitObjCAutoreleasePoolPush()
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
const LangOptions & getLangOpts() const
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
llvm::Type * ConvertTypeForMem(QualType T)
llvm::Function * createTLSAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr, llvm::FunctionCallee &AtExit)
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
void registerGlobalDtorWithLLVM(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)
Registers the dtor using 'llvm.global_dtors' for platforms that do not support an 'atexit()' function...
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
void emitDestroy(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
llvm::Function * generateDestroyHelper(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray, const VarDecl *VD)
void GenerateCXXGlobalCleanUpFunc(llvm::Function *Fn, ArrayRef< std::tuple< llvm::FunctionType *, llvm::WeakTrackingVH, llvm::Constant * > > DtorsOrStermFinalizers)
GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global variables.
void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)
Emit code in this function to perform a guarded variable initialization.
void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV, bool PerformInit)
EmitCXXGlobalVarDeclInit - Create the initializer for a C++ variable with global storage.
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...
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::Function * createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, llvm::Constant *Addr)
void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn, llvm::Constant *addr)
Call atexit() with a function that passes the given argument to the given function.
llvm::Value * unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub)
Call unatexit() with function dtorStub.
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind.
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size)
CodeGenTypes & getTypes() const
void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D, llvm::GlobalVariable *Addr, bool PerformInit)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr)
llvm::LLVMContext & getLLVMContext()
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
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...
void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit, llvm::BasicBlock *InitBlock, llvm::BasicBlock *NoInitBlock, GuardKind Kind, const VarDecl *D)
Emit a branch to select whether or not to perform guarded initialization.
This class organizes the cross-function state that is used while generating LLVM code.
void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
CGHLSLRuntime & getHLSLRuntime()
Return a reference to the configured HLSL runtime.
llvm::Module & getModule() const
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name.
llvm::FunctionCallee getAddrAndTypeOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Definition: CGCXX.cpp:220
bool isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn, SourceLocation Loc) const
const LangOptions & getLangOpts() const
const TargetInfo & getTarget() const
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
const llvm::DataLayout & getDataLayout() const
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can't be done.
CGCXXABI & getCXXABI() const
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
const llvm::Triple & getTriple() const
void AddGlobalDtor(llvm::Function *Dtor, int Priority=65535, bool IsDtorAttrFunc=false)
AddGlobalDtor - Add a function to the list that will be called when the module is unloaded.
ASTContext & getContext() const
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
llvm::LLVMContext & getLLVMContext()
llvm::GlobalValue * GetGlobalValue(StringRef Ref)
void GenKernelArgMetadata(llvm::Function *FN, const FunctionDecl *FD=nullptr, CodeGenFunction *CGF=nullptr)
OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument information in the program executab...
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
void AddGlobalCtor(llvm::Function *Ctor, int Priority=65535, unsigned LexOrder=~0U, llvm::Constant *AssociatedData=nullptr)
AddGlobalCtor - Add a function to the list that will be called before main() runs.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=std::nullopt)
llvm::Function * CreateGlobalInitOrCleanUpFunction(llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI, SourceLocation Loc=SourceLocation(), bool TLS=false, llvm::GlobalVariable::LinkageTypes Linkage=llvm::GlobalVariable::InternalLinkage)
Definition: CGDeclCXX.cpp:436
const CGFunctionInfo & arrangeLLVMFunctionInfo(CanQualType returnType, FnInfoOpts opts, ArrayRef< CanQualType > argTypes, FunctionType::ExtInfo info, ArrayRef< FunctionProtoType::ExtParameterInfo > paramInfos, RequiredArgs args)
"Arrange" the LLVM information for a call or type with the given signature.
Definition: CGCall.cpp:766
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
unsigned getTargetAddressSpace(QualType T) const
const CGFunctionInfo & arrangeNullaryFunction()
A nullary function is a freestanding function of type 'void ()'.
Definition: CGCall.cpp:722
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:260
ConstantAddress withElementType(llvm::Type *ElemTy) const
Definition: Address.h:276
static ConstantAddress invalid()
Definition: Address.h:268
llvm::Constant * getPointer() const
Definition: Address.h:272
FunctionArgList - Type for representing both the decl and type of parameters to a function.
Definition: CGCall.h:352
LValue - This represents an lvalue references.
Definition: CGValue.h:181
bool isObjCStrong() const
Definition: CGValue.h:327
bool isObjCWeak() const
Definition: CGValue.h:324
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
bool isValid() const
Definition: Address.h:61
virtual LangAS getAddrSpaceOfCxaAtexitPtrParam() const
Get address space of pointer parameter for __cxa_atexit.
Definition: TargetInfo.h:326
T * getAttr() const
Definition: DeclBase.h:579
SourceLocation getLocation() const
Definition: DeclBase.h:445
bool hasAttr() const
Definition: DeclBase.h:583
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:822
This represents one expression.
Definition: Expr.h:110
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:277
A class which abstracts out some details necessary for making a call.
Definition: Type.h:4367
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
virtual void mangleDynamicAtExitDestructor(const VarDecl *D, raw_ostream &)=0
virtual void mangleDynamicInitializer(const VarDecl *D, raw_ostream &)=0
Describes a module or submodule.
Definition: Module.h:105
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
Definition: Module.h:415
bool isNamedModuleInterfaceHasInit() const
Definition: Module.h:628
bool isInterfaceOrPartition() const
Definition: Module.h:615
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition: Module.h:402
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:783
bool isHeaderLikeModule() const
Is this module have similar semantics as headers.
Definition: Module.h:592
bool isExternallyVisible() const
Definition: Decl.h:408
A (possibly-)qualified type.
Definition: Type.h:940
@ DK_cxx_destructor
Definition: Type.h:1520
@ DK_nontrivial_c_struct
Definition: Type.h:1523
@ DK_objc_weak_lifetime
Definition: Type.h:1522
@ DK_objc_strong_lifetime
Definition: Type.h:1521
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:7399
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
Definition: Type.h:1039
LangAS getAddressSpace() const
Definition: Type.h:557
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
Encodes a location in the source.
The base class of the type hierarchy.
Definition: Type.h:1813
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1871
bool isReferenceType() const
Definition: Type.h:7624
QualType getType() const
Definition: Decl.h:717
Represents a variable declaration or definition.
Definition: Decl.h:918
TLSKind getTLSKind() const
Definition: Decl.cpp:2165
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1213
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
Definition: Decl.cpp:2820
const Expr * getInit() const
Definition: Decl.h:1355
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1171
@ TLS_Dynamic
TLS with a dynamic initializer.
Definition: Decl.h:944
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
Definition: Decl.h:1240
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2756
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
The JSON file list parser is used to communicate input to InstallAPI.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:209
@ OpenCL
Definition: LangStandard.h:65
@ CPlusPlus
Definition: LangStandard.h:55
@ GVA_DiscardableODR
Definition: Linkage.h:75
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition: Linkage.h:24
@ Dtor_Complete
Complete object dtor.
Definition: ABI.h:35
LLVM_READONLY bool isPreprocessingNumberBody(unsigned char c)
Return true if this is the body character of a C preprocessing number, which is [a-zA-Z0-9_.
Definition: CharInfo.h:169
const FunctionProtoType * T
@ Other
Other implicit parameter.
unsigned long uint64_t
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
llvm::CallingConv::ID getRuntimeCC() const
llvm::IntegerType * IntTy
int